projects / hashcat.git / blob
? search:


1856ebc36e08b731714fdc0980b55d4107c2d1ed
[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
10 #include <getopt.h>
11
12 #ifdef _CUDA
13 const char *PROGNAME = "cudaHashcat";
14 #elif _OCL
15 const char *PROGNAME = "oclHashcat";
16 #endif
17
18 const char *VERSION_TXT = "2.01";
19 const uint VERSION_BIN = 201;
20 const uint RESTORE_MIN = 200;
21
22 #define INCR_RULES 10000
23 #define INCR_SALTS 100000
24 #define INCR_MASKS 1000
25 #define INCR_POT 1000
26
27 // comment-out for kernel source mode
28
29 #define BINARY_KERNEL
30
31 #define USAGE 0
32 #define VERSION 0
33 #define QUIET 0
34 #define MARKOV_THRESHOLD 0
35 #define MARKOV_DISABLE 0
36 #define MARKOV_CLASSIC 0
37 #define BENCHMARK 0
38 #define BENCHMARK_MODE 1
39 #define RESTORE 0
40 #define RESTORE_TIMER 60
41 #define RESTORE_DISABLE 0
42 #define STATUS 0
43 #define STATUS_TIMER 10
44 #define STATUS_AUTOMAT 0
45 #define LOOPBACK 0
46 #define WEAK_HASH_THRESHOLD 100
47 #define SHOW 0
48 #define LEFT 0
49 #define USERNAME 0
50 #define REMOVE 0
51 #define REMOVE_TIMER 60
52 #define SKIP 0
53 #define LIMIT 0
54 #define KEYSPACE 0
55 #define POTFILE_DISABLE 0
56 #define DEBUG_MODE 0
57 #define RP_GEN 0
58 #define RP_GEN_FUNC_MIN 1
59 #define RP_GEN_FUNC_MAX 4
60 #define RP_GEN_SEED 0
61 #define RULE_BUF_L ":"
62 #define RULE_BUF_R ":"
63 #define FORCE 0
64 #define RUNTIME 0
65 #define HEX_CHARSET 0
66 #define HEX_SALT 0
67 #define HEX_WORDLIST 0
68 #define OUTFILE_FORMAT 3
69 #define OUTFILE_AUTOHEX 1
70 #define OUTFILE_CHECK_TIMER 5
71 #define ATTACK_MODE 0
72 #define HASH_MODE 0
73 #define SEGMENT_SIZE 32
74 #define INCREMENT 0
75 #define INCREMENT_MIN 1
76 #define INCREMENT_MAX PW_MAX
77 #define SEPARATOR ':'
78 #define BITMAP_MIN 16
79 #define BITMAP_MAX 24
80 #define GPU_ASYNC 0
81 #define GPU_TEMP_DISABLE 0
82 #define GPU_TEMP_ABORT 90
83 #define GPU_TEMP_RETAIN 80
84 #define WORKLOAD_PROFILE 2
85 #define GPU_ACCEL 0
86 #define GPU_LOOPS 0
87 #define GPU_RULES 1024
88 #define GPU_COMBS 1024
89 #define GPU_BFS 1024
90 #define GPU_THREADS_AMD 64
91 #define GPU_THREADS_NV 256
92 #define POWERTUNE_ENABLE 0
93 #define LOGFILE_DISABLE 0
94 #define SCRYPT_TMTO 0
95
96 #define VECT_SIZE_1 1
97 #define VECT_SIZE_2 2
98 #define VECT_SIZE_4 4
99 #define VECT_SIZE_8 8
100
101 #define WL_MODE_STDIN 1
102 #define WL_MODE_FILE 2
103 #define WL_MODE_MASK 3
104
105 #define HL_MODE_FILE 4
106 #define HL_MODE_ARG 5
107
108 #define HLFMT_HASHCAT 0
109 #define HLFMT_PWDUMP 1
110 #define HLFMT_PASSWD 2
111 #define HLFMT_SHADOW 3
112 #define HLFMT_DCC 4
113 #define HLFMT_DCC2 5
114 #define HLFMT_NETNTLM1 7
115 #define HLFMT_NETNTLM2 8
116 #define HLFMT_NSLDAP 9
117 #define HLFMT_NSLDAPS 10
118 #define HLFMTS_CNT 11
119
120 #define ATTACK_MODE_STRAIGHT 0
121 #define ATTACK_MODE_COMBI 1
122 #define ATTACK_MODE_TOGGLE 2
123 #define ATTACK_MODE_BF 3
124 #define ATTACK_MODE_PERM 4
125 #define ATTACK_MODE_TABLE 5
126 #define ATTACK_MODE_HYBRID1 6
127 #define ATTACK_MODE_HYBRID2 7
128 #define ATTACK_MODE_NONE 100
129
130 #define ATTACK_KERN_STRAIGHT 0
131 #define ATTACK_KERN_COMBI 1
132 #define ATTACK_KERN_BF 3
133 #define ATTACK_KERN_NONE 100
134
135 #define ATTACK_EXEC_ON_CPU 10
136 #define ATTACK_EXEC_ON_GPU 11
137
138 #define COMBINATOR_MODE_BASE_LEFT 10001
139 #define COMBINATOR_MODE_BASE_RIGHT 10002
140
141 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
142 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
143
144 #define MAX_CUT_TRIES 4
145
146 #define MAX_DICTSTAT 10000
147
148 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 128
149
150 #define global_free(attr) \
151 { \
152 myfree ((void *) data.attr); \
153 \
154 data.attr = NULL; \
155 }
156
157 #define local_free(attr) \
158 { \
159 myfree ((void *) attr); \
160 \
161 attr = NULL; \
162 }
163
164 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
165 {
166 900,
167 0,
168 5100,
169 100,
170 1400,
171 10800,
172 1700,
173 5000,
174 10100,
175 6000,
176 6100,
177 6900,
178 11700,
179 11800,
180 400,
181 8900,
182 11900,
183 12000,
184 10900,
185 12100,
186 23,
187 2500,
188 5300,
189 5400,
190 5500,
191 5600,
192 7300,
193 7500,
194 8300,
195 11100,
196 11200,
197 11400,
198 121,
199 2611,
200 2711,
201 2811,
202 8400,
203 11,
204 2612,
205 7900,
206 21,
207 11000,
208 124,
209 10000,
210 3711,
211 7600,
212 12,
213 131,
214 132,
215 1731,
216 200,
217 300,
218 3100,
219 112,
220 12300,
221 8000,
222 141,
223 1441,
224 1600,
225 12600,
226 1421,
227 101,
228 111,
229 1711,
230 3000,
231 1000,
232 1100,
233 2100,
234 12800,
235 1500,
236 12400,
237 500,
238 3200,
239 7400,
240 1800,
241 122,
242 1722,
243 7100,
244 6300,
245 6700,
246 6400,
247 6500,
248 2400,
249 2410,
250 5700,
251 9200,
252 9300,
253 22,
254 501,
255 5800,
256 8100,
257 8500,
258 7200,
259 9900,
260 7700,
261 7800,
262 10300,
263 8600,
264 8700,
265 9100,
266 133,
267 11600,
268 12500,
269 6211,
270 6221,
271 6231,
272 6241,
273 8800,
274 12200,
275 9700,
276 9710,
277 9800,
278 9810,
279 9400,
280 9500,
281 9600,
282 10400,
283 10410,
284 10500,
285 10600,
286 10700,
287 9000,
288 5200,
289 6800,
290 6600,
291 8200,
292 11300,
293 12700
294 };
295
296 /**
297 * types
298 */
299
300 static void (*get_next_word_func) (char *, uint32_t, uint32_t *, uint32_t *);
301
302 /**
303 * globals
304 */
305
306 static unsigned int full01 = 0x01010101;
307 static unsigned int full80 = 0x80808080;
308
309 int SUPPRESS_OUTPUT = 0;
310
311 hc_thread_mutex_t mux_adl;
312 hc_thread_mutex_t mux_counter;
313 hc_thread_mutex_t mux_dispatcher;
314 hc_thread_mutex_t mux_display;
315
316 hc_global_data_t data;
317
318 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
319
320 const char *USAGE_MINI[] =
321 {
322 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
323 "",
324 "Try --help for more help.",
325 NULL
326 };
327
328 const char *USAGE_BIG[] =
329 {
330 "%s, advanced password recovery",
331 "",
332 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
333 "",
334 "=======",
335 "Options",
336 "=======",
337 "",
338 "* General:",
339 "",
340 " -m, --hash-type=NUM Hash-type, see references below",
341 " -a, --attack-mode=NUM Attack-mode, see references below",
342 " -V, --version Print version",
343 " -h, --help Print help",
344 " --quiet Suppress output",
345 "",
346 "* Benchmark:",
347 "",
348 " -b, --benchmark Run benchmark",
349 " --benchmark-mode=NUM Benchmark-mode, see references below",
350 "",
351 "* Misc:",
352 "",
353 " --hex-charset Assume charset is given in hex",
354 " --hex-salt Assume salt is given in hex",
355 " --hex-wordlist Assume words in wordlist is given in hex",
356 " --force Ignore warnings",
357 " --status Enable automatic update of the status-screen",
358 " --status-timer=NUM Seconds between status-screen update",
359 " --status-automat Display the status view in a machine readable format",
360 " --loopback Add new plains to induct directory",
361 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
362 "",
363 "* Markov:",
364 "",
365 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
366 " --markov-disable Disables markov-chains, emulates classic brute-force",
367 " --markov-classic Enables classic markov-chains, no per-position enhancement",
368 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
369 "",
370 "* Session:",
371 "",
372 " --runtime=NUM Abort session after NUM seconds of runtime",
373 " --session=STR Define specific session name",
374 " --restore Restore session from --session",
375 " --restore-disable Do not write restore file",
376 "",
377 "* Files:",
378 "",
379 " -o, --outfile=FILE Define outfile for recovered hash",
380 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
381 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
382 " --outfile-check-timer=NUM Seconds between outfile checks",
383 " -p, --separator=CHAR Separator char for hashlists and outfile",
384 " --show Show cracked passwords only",
385 " --left Show un-cracked passwords only",
386 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
387 " --remove Enable remove of hash once it is cracked",
388 " --remove-timer=NUM Update input hash file each NUM seconds",
389 " --potfile-disable Do not write potfile",
390 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
391 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
392 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
393 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
394 " --logfile-disable Disable the logfile",
395 " --truecrypt-keyfiles=FILE Keyfiles used, seperate with comma",
396 "",
397 "* Resources:",
398 "",
399 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
400 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
401 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
402 " --cpu-affinity=STR Locks to CPU devices, seperate with comma",
403 " --gpu-async Use non-blocking async calls (NV only)",
404 " -d, --gpu-devices=STR Devices to use, separate with comma",
405 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
406 " -n, --gpu-accel=NUM Workload tuning: 1, 8, 40, 80, 160",
407 " -u, --gpu-loops=NUM Workload fine-tuning: 8 - 1024",
408 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
409 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
410 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
411 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
412 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
413 "",
414 "* Distributed:",
415 "",
416 " -s, --skip=NUM Skip number of words",
417 " -l, --limit=NUM Limit number of words",
418 " --keyspace Show keyspace base:mod values and quit",
419 "",
420 "* Rules:",
421 "",
422 " -j, --rule-left=RULE Single rule applied to each word from left dict",
423 " -k, --rule-right=RULE Single rule applied to each word from right dict",
424 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
425 " -g, --generate-rules=NUM Generate NUM random rules",
426 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
427 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
428 " --generate-rules-seed=NUM Force RNG seed to NUM",
429 "",
430 "* Custom charsets:",
431 "",
432 " -1, --custom-charset1=CS User-defined charsets",
433 " -2, --custom-charset2=CS Example:",
434 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
435 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
436 "",
437 "* Increment:",
438 "",
439 " -i, --increment Enable increment mode",
440 " --increment-min=NUM Start incrementing at NUM",
441 " --increment-max=NUM Stop incrementing at NUM",
442 "",
443 "==========",
444 "References",
445 "==========",
446 "",
447 "* Workload Profile:",
448 "",
449 " 1 = Reduced performance profile (low latency desktop)",
450 " 2 = Default performance profile",
451 " 3 = Tuned performance profile (high latency desktop)",
452 "",
453 "* Benchmark Settings:",
454 "",
455 " 0 = Manual Tuning",
456 " 1 = Performance Tuning, default",
457 "",
458 "* Outfile Formats:",
459 "",
460 " 1 = hash[:salt]",
461 " 2 = plain",
462 " 3 = hash[:salt]:plain",
463 " 4 = hex_plain",
464 " 5 = hash[:salt]:hex_plain",
465 " 6 = plain:hex_plain",
466 " 7 = hash[:salt]:plain:hex_plain",
467 " 8 = crackpos",
468 " 9 = hash[:salt]:crackpos",
469 " 10 = plain:crackpos",
470 " 11 = hash[:salt]:plain:crackpos",
471 " 12 = hex_plain:crackpos",
472 " 13 = hash[:salt]:hex_plain:crackpos",
473 " 14 = plain:hex_plain:crackpos",
474 " 15 = hash[:salt]:plain:hex_plain:crackpos",
475 "",
476 "* Debug mode output formats (for hybrid mode only, by using rules):",
477 "",
478 " 1 = save finding rule",
479 " 2 = save original word",
480 " 3 = save original word and finding rule",
481 " 4 = save original word, finding rule and modified plain",
482 "",
483 "* Built-in charsets:",
484 "",
485 " ?l = abcdefghijklmnopqrstuvwxyz",
486 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
487 " ?d = 0123456789",
488 " ?s = !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~",
489 " ?a = ?l?u?d?s",
490 " ?b = 0x00 - 0xff",
491 "",
492 "* Attack modes:",
493 "",
494 " 0 = Straight",
495 " 1 = Combination",
496 " 3 = Brute-force",
497 " 6 = Hybrid dict + mask",
498 " 7 = Hybrid mask + dict",
499 "",
500 "* Hash types:",
501 "",
502 "[[ Roll-your-own: Raw Hashes ]]",
503 "",
504 " 900 = MD4",
505 " 0 = MD5",
506 " 5100 = Half MD5",
507 " 100 = SHA1",
508 " 10800 = SHA-384",
509 " 1400 = SHA-256",
510 " 1700 = SHA-512",
511 " 5000 = SHA-3(Keccak)",
512 " 10100 = SipHash",
513 " 6000 = RipeMD160",
514 " 6100 = Whirlpool",
515 " 6900 = GOST R 34.11-94",
516 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
517 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
518 "",
519 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
520 "",
521 " 10 = md5($pass.$salt)",
522 " 20 = md5($salt.$pass)",
523 " 30 = md5(unicode($pass).$salt)",
524 " 40 = md5($salt.unicode($pass))",
525 " 3800 = md5($salt.$pass.$salt)",
526 " 3710 = md5($salt.md5($pass))",
527 " 2600 = md5(md5($pass)",
528 " 4300 = md5(strtoupper(md5($pass)))",
529 " 4400 = md5(sha1($pass))",
530 " 110 = sha1($pass.$salt)",
531 " 120 = sha1($salt.$pass)",
532 " 130 = sha1(unicode($pass).$salt)",
533 " 140 = sha1($salt.unicode($pass))",
534 " 4500 = sha1(sha1($pass)",
535 " 4700 = sha1(md5($pass))",
536 " 4900 = sha1($salt.$pass.$salt)",
537 " 1410 = sha256($pass.$salt)",
538 " 1420 = sha256($salt.$pass)",
539 " 1430 = sha256(unicode($pass).$salt)",
540 " 1440 = sha256($salt.unicode($pass))",
541 " 1710 = sha512($pass.$salt)",
542 " 1720 = sha512($salt.$pass)",
543 " 1730 = sha512(unicode($pass).$salt)",
544 " 1740 = sha512($salt.unicode($pass))",
545 "",
546 "[[ Roll-your-own: Authenticated Hashes ]]",
547 "",
548 " 50 = HMAC-MD5 (key = $pass)",
549 " 60 = HMAC-MD5 (key = $salt)",
550 " 150 = HMAC-SHA1 (key = $pass)",
551 " 160 = HMAC-SHA1 (key = $salt)",
552 " 1450 = HMAC-SHA256 (key = $pass)",
553 " 1460 = HMAC-SHA256 (key = $salt)",
554 " 1750 = HMAC-SHA512 (key = $pass)",
555 " 1760 = HMAC-SHA512 (key = $salt)",
556 "",
557 "[[ Generic KDF ]]",
558 "",
559 " 400 = phpass",
560 " 8900 = scrypt",
561 " 11900 = PBKDF2-HMAC-MD5",
562 " 12000 = PBKDF2-HMAC-SHA1",
563 " 10900 = PBKDF2-HMAC-SHA256",
564 " 12100 = PBKDF2-HMAC-SHA512",
565 "",
566 "[[ Network protocols, Challenge-Response ]]",
567 "",
568 " 23 = Skype",
569 " 2500 = WPA/WPA2",
570 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
571 " 5300 = IKE-PSK MD5",
572 " 5400 = IKE-PSK SHA1",
573 " 5500 = NetNTLMv1",
574 " 5500 = NetNTLMv1 + ESS",
575 " 5600 = NetNTLMv2",
576 " 7300 = IPMI2 RAKP HMAC-SHA1",
577 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
578 " 8300 = DNSSEC (NSEC3)",
579 " 10200 = Cram MD5",
580 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
581 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
582 " 11400 = SIP digest authentication (MD5)",
583 "",
584 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
585 "",
586 " 121 = SMF (Simple Machines Forum)",
587 " 400 = phpBB3",
588 " 2611 = vBulletin < v3.8.5",
589 " 2711 = vBulletin > v3.8.5",
590 " 2811 = MyBB",
591 " 2811 = IPB (Invison Power Board)",
592 " 8400 = WBB3 (Woltlab Burning Board)",
593 " 11 = Joomla < 2.5.18",
594 " 400 = Joomla > 2.5.18",
595 " 400 = Wordpress",
596 " 2612 = PHPS",
597 " 7900 = Drupal7",
598 " 21 = osCommerce",
599 " 21 = xt:Commerce",
600 " 11000 = PrestaShop",
601 " 124 = Django (SHA-1)",
602 " 10000 = Django (PBKDF2-SHA256)",
603 " 3711 = Mediawiki B type",
604 " 7600 = Redmine",
605 "",
606 "[[ Database Server ]]",
607 "",
608 " 12 = PostgreSQL",
609 " 131 = MSSQL(2000)",
610 " 132 = MSSQL(2005)",
611 " 1731 = MSSQL(2012)",
612 " 1731 = MSSQL(2014)",
613 " 200 = MySQL323",
614 " 300 = MySQL4.1/MySQL5",
615 " 3100 = Oracle H: Type (Oracle 7+)",
616 " 112 = Oracle S: Type (Oracle 11+)",
617 " 12300 = Oracle T: Type (Oracle 12+)",
618 " 8000 = Sybase ASE",
619 "",
620 "[[ HTTP, SMTP, LDAP Server]]",
621 "",
622 " 141 = EPiServer 6.x < v4",
623 " 1441 = EPiServer 6.x > v4",
624 " 1600 = Apache $apr1$",
625 " 12600 = ColdFusion 10+",
626 " 1421 = hMailServer",
627 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
628 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
629 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
630 "",
631 "[[ Checksums ]]",
632 "",
633 " 11500 = CRC32",
634 "",
635 "[[ Operating-Systems ]]",
636 "",
637 " 3000 = LM",
638 " 1000 = NTLM",
639 " 1100 = Domain Cached Credentials (DCC), MS Cache",
640 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
641 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
642 " 1500 = descrypt, DES(Unix), Traditional DES",
643 " 12400 = BSDiCrypt, Extended DES",
644 " 500 = md5crypt $1$, MD5(Unix)",
645 " 3200 = bcrypt $2*$, Blowfish(Unix)",
646 " 7400 = sha256crypt $5$, SHA256(Unix)",
647 " 1800 = sha512crypt $6$, SHA512(Unix)",
648 " 122 = OSX v10.4",
649 " 122 = OSX v10.5",
650 " 122 = OSX v10.6",
651 " 1722 = OSX v10.7",
652 " 7100 = OSX v10.8",
653 " 7100 = OSX v10.9",
654 " 7100 = OSX v10.10",
655 " 6300 = AIX {smd5}",
656 " 6700 = AIX {ssha1}",
657 " 6400 = AIX {ssha256}",
658 " 6500 = AIX {ssha512}",
659 " 2400 = Cisco-PIX",
660 " 2410 = Cisco-ASA",
661 " 500 = Cisco-IOS $1$",
662 " 5700 = Cisco-IOS $4$",
663 " 9200 = Cisco-IOS $8$",
664 " 9300 = Cisco-IOS $9$",
665 " 22 = Juniper Netscreen/SSG (ScreenOS)",
666 " 501 = Juniper IVE",
667 " 5800 = Android PIN",
668 " 8100 = Citrix Netscaler",
669 " 8500 = RACF",
670 " 7200 = GRUB 2",
671 " 9900 = Radmin2",
672 "",
673 "[[ Enterprise Application Software (EAS) ]]",
674 "",
675 " 7700 = SAP CODVN B (BCODE)",
676 " 7800 = SAP CODVN F/G (PASSCODE)",
677 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
678 " 8600 = Lotus Notes/Domino 5",
679 " 8700 = Lotus Notes/Domino 6",
680 " 9100 = Lotus Notes/Domino 8",
681 " 133 = PeopleSoft",
682 "",
683 "[[ Archives ]]",
684 "",
685 " 11600 = 7-Zip",
686 " 12500 = RAR3-hp",
687 "",
688 "[[ Full-Disk encryptions (FDE) ]]",
689 "",
690 " 62XY = TrueCrypt 5.0+",
691 " X = 1 = PBKDF2-HMAC-RipeMD160",
692 " X = 2 = PBKDF2-HMAC-SHA512",
693 " X = 3 = PBKDF2-HMAC-Whirlpool",
694 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
695 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
696 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
697 " Y = 3 = XTS 1536 bit (Ciphers: All)",
698 " 8800 = Android FDE < v4.3",
699 " 12200 = eCryptfs",
700 "",
701 "[[ Documents ]]",
702 "",
703 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
704 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
705 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
706 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
707 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
708 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
709 " 9400 = MS Office 2007",
710 " 9500 = MS Office 2010",
711 " 9600 = MS Office 2013",
712 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
713 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
714 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
715 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
716 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
717 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
718 "",
719 "[[ Password Managers ]]",
720 "",
721 " 9000 = Password Safe v2",
722 " 5200 = Password Safe v3",
723 " 6800 = Lastpass",
724 " 6600 = 1Password, agilekeychain",
725 " 8200 = 1Password, cloudkeychain",
726 " 11300 = Bitcoin/Litecoin wallet.dat",
727 " 12700 = Blockchain, My Wallet",
728 "",
729 NULL
730 };
731
732 /**
733 * oclHashcat specific functions
734 */
735
736 void status_display_automat ()
737 {
738 FILE *out = stdout;
739
740 fprintf (out, "STATUS\t%u\t", data.devices_status);
741
742 /**
743 * speed new
744 */
745
746 fprintf (out, "SPEED\t");
747
748 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
749 {
750 hc_device_param_t *device_param = &data.devices_param[device_id];
751
752 uint64_t speed_cnt = 0;
753 float speed_ms = 0;
754
755 for (int i = 0; i < SPEED_CACHE; i++)
756 {
757 float rec_ms;
758
759 hc_timer_get (device_param->speed_rec[i], rec_ms);
760
761 if (rec_ms > SPEED_MAXAGE) continue;
762
763 speed_cnt += device_param->speed_cnt[i];
764 speed_ms += device_param->speed_ms[i];
765 }
766
767 speed_cnt /= SPEED_CACHE;
768 speed_ms /= SPEED_CACHE;
769
770 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
771 }
772
773 /**
774 * words_cur
775 */
776
777 uint64_t words_cur = get_lowest_words_done ();
778
779 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
780
781 /**
782 * counter
783 */
784
785 uint salts_left = data.salts_cnt - data.salts_done;
786
787 if (salts_left == 0) salts_left = 1;
788
789 uint64_t progress_total = data.words_cnt * salts_left;
790
791 uint64_t all_done = 0;
792 uint64_t all_rejected = 0;
793 uint64_t all_restored = 0;
794
795 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
796 {
797 if (salts_left > 1)
798 {
799 // otherwise the final cracked status shows 0/XXX progress
800
801 if (data.salts_shown[salt_pos] == 1) continue;
802 }
803
804 all_done += data.words_progress_done[salt_pos];
805 all_rejected += data.words_progress_rejected[salt_pos];
806 all_restored += data.words_progress_restored[salt_pos];
807 }
808
809 uint64_t progress_cur = all_restored + all_done + all_rejected;
810 uint64_t progress_end = progress_total;
811
812 uint64_t progress_skip = 0;
813
814 if (data.skip)
815 {
816 progress_skip = MIN (data.skip, data.words_base) * salts_left;
817
818 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.gpu_rules_cnt;
819 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
820 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
821 }
822
823 if (data.limit)
824 {
825 progress_end = MIN (data.limit, data.words_base) * salts_left;
826
827 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.gpu_rules_cnt;
828 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
829 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
830 }
831
832 uint64_t progress_cur_relative_skip = progress_cur - progress_skip;
833 uint64_t progress_end_relative_skip = progress_end - progress_skip;
834
835 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
836
837 /**
838 * cracks
839 */
840
841 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
842 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
843
844 /**
845 * temperature
846 */
847
848 if (data.gpu_temp_disable == 0)
849 {
850 fprintf (out, "TEMP\t");
851
852 hc_thread_mutex_lock (mux_adl);
853
854 for (uint i = 0; i < data.devices_cnt; i++)
855 {
856 int temp = hm_get_temperature_with_device_id (i);
857
858 fprintf (out, "%d\t", temp);
859 }
860
861 hc_thread_mutex_unlock (mux_adl);
862 }
863
864 #ifdef _WIN
865 fputc ('\r', out);
866 fputc ('\n', out);
867 #endif
868
869 #ifdef _POSIX
870 fputc ('\n', out);
871 #endif
872
873 fflush (out);
874 }
875
876 void status_display ()
877 {
878 if (data.devices_status == STATUS_INIT) return;
879 if (data.devices_status == STATUS_STARTING) return;
880 if (data.devices_status == STATUS_BYPASS) return;
881
882 if (data.status_automat == 1)
883 {
884 status_display_automat ();
885
886 return;
887 }
888
889 char tmp_buf[1000];
890
891 uint tmp_len = 0;
892
893 log_info ("Session.Name...: %s", data.session);
894
895 char *status_type = strstatus (data.devices_status);
896
897 uint hash_mode = data.hash_mode;
898
899 char *hash_type = strhashtype (hash_mode); // not a bug
900
901 log_info ("Status.........: %s", status_type);
902
903 /**
904 * show rules
905 */
906
907 if (data.rp_files_cnt)
908 {
909 uint i;
910
911 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
912 {
913 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
914 }
915
916 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
917
918 log_info ("Rules.Type.....: %s", tmp_buf);
919
920 tmp_len = 0;
921 }
922
923 if (data.rp_gen)
924 {
925 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
926
927 if (data.rp_gen_seed)
928 {
929 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
930 }
931 }
932
933 /**
934 * show input
935 */
936
937 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
938 {
939 if (data.wordlist_mode == WL_MODE_FILE)
940 {
941 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
942 }
943 else if (data.wordlist_mode == WL_MODE_STDIN)
944 {
945 log_info ("Input.Mode.....: Pipe");
946 }
947 }
948 else if (data.attack_mode == ATTACK_MODE_COMBI)
949 {
950 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
951 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
952 }
953 else if (data.attack_mode == ATTACK_MODE_BF)
954 {
955 char *mask = data.mask;
956
957 if (mask != NULL)
958 {
959 uint mask_len = data.css_cnt;
960
961 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
962
963 if (mask_len > 0)
964 {
965 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
966 {
967 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
968 {
969 mask_len -= data.salts_buf[0].salt_len;
970 }
971 }
972
973 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
974
975 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
976 }
977
978 if (data.maskcnt > 1)
979 {
980 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
981
982 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
983 }
984
985 log_info ("Input.Mode.....: %s", tmp_buf);
986 }
987
988 tmp_len = 0;
989 }
990 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
991 {
992 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
993 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
994 }
995 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
996 {
997 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
998 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
999 }
1000
1001 if (data.digests_cnt == 1)
1002 {
1003 if (data.hash_mode == 2500)
1004 {
1005 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1006
1007 uint pke[25];
1008
1009 char *pke_ptr = (char *) pke;
1010
1011 for (uint i = 0; i < 25; i++)
1012 {
1013 pke[i] = byte_swap_32 (wpa->pke[i]);
1014 }
1015
1016 char mac1[6];
1017 char mac2[6];
1018
1019 memcpy (mac1, pke_ptr + 23, 6);
1020 memcpy (mac2, pke_ptr + 29, 6);
1021
1022 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1023 (char *) data.salts_buf[0].salt_buf,
1024 mac1[0] & 0xff,
1025 mac1[1] & 0xff,
1026 mac1[2] & 0xff,
1027 mac1[3] & 0xff,
1028 mac1[4] & 0xff,
1029 mac1[5] & 0xff,
1030 mac2[0] & 0xff,
1031 mac2[1] & 0xff,
1032 mac2[2] & 0xff,
1033 mac2[3] & 0xff,
1034 mac2[4] & 0xff,
1035 mac2[5] & 0xff);
1036 }
1037 else if (data.hash_mode == 5200)
1038 {
1039 log_info ("Hash.Target....: File (%s)", data.hashfile);
1040 }
1041 else if (data.hash_mode == 9000)
1042 {
1043 log_info ("Hash.Target....: File (%s)", data.hashfile);
1044 }
1045 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1046 {
1047 log_info ("Hash.Target....: File (%s)", data.hashfile);
1048 }
1049 else
1050 {
1051 char out_buf[4096];
1052
1053 ascii_digest (out_buf, 0, 0);
1054
1055 // limit length
1056 if (strlen (out_buf) > 40)
1057 {
1058 out_buf[41] = '.';
1059 out_buf[42] = '.';
1060 out_buf[43] = '.';
1061 out_buf[44] = 0;
1062 }
1063
1064 log_info ("Hash.Target....: %s", out_buf);
1065 }
1066 }
1067 else
1068 {
1069 if (data.hash_mode == 3000)
1070 {
1071 char out_buf1[4096];
1072 char out_buf2[4096];
1073
1074 ascii_digest (out_buf1, 0, 0);
1075 ascii_digest (out_buf2, 0, 1);
1076
1077 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1078 }
1079 else
1080 {
1081 log_info ("Hash.Target....: File (%s)", data.hashfile);
1082 }
1083 }
1084
1085 log_info ("Hash.Type......: %s", hash_type);
1086
1087 /**
1088 * speed new
1089 */
1090
1091 uint64_t speed_cnt[DEVICES_MAX];
1092 float speed_ms[DEVICES_MAX];
1093
1094 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1095 {
1096 hc_device_param_t *device_param = &data.devices_param[device_id];
1097
1098 // we need to clear values (set to 0) because in case the gpu does
1099 // not get new candidates it idles around but speed display would
1100 // show it as working.
1101 // if we instantly set it to 0 after reading it happens that the
1102 // speed can be shown as zero if the users refreshs to fast.
1103 // therefore, we add a timestamp when a stat was recorded and if its
1104 // to old we will not use it
1105
1106 speed_cnt[device_id] = 0;
1107 speed_ms[device_id] = 0;
1108
1109 for (int i = 0; i < SPEED_CACHE; i++)
1110 {
1111 float rec_ms;
1112
1113 hc_timer_get (device_param->speed_rec[i], rec_ms);
1114
1115 if (rec_ms > SPEED_MAXAGE) continue;
1116
1117 speed_cnt[device_id] += device_param->speed_cnt[i];
1118 speed_ms[device_id] += device_param->speed_ms[i];
1119 }
1120
1121 speed_cnt[device_id] /= SPEED_CACHE;
1122 speed_ms[device_id] /= SPEED_CACHE;
1123 }
1124
1125 float hashes_all_ms = 0;
1126
1127 float hashes_dev_ms[DEVICES_MAX];
1128
1129 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1130 {
1131 hashes_dev_ms[device_id] = 0;
1132
1133 if (speed_ms[device_id])
1134 {
1135 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1136
1137 hashes_all_ms += hashes_dev_ms[device_id];
1138 }
1139 }
1140
1141 /**
1142 * timers
1143 */
1144
1145 float ms_running = 0;
1146
1147 hc_timer_get (data.timer_running, ms_running);
1148
1149 float ms_paused = data.ms_paused;
1150
1151 if (data.devices_status == STATUS_PAUSED)
1152 {
1153 float ms_paused_tmp = 0;
1154
1155 hc_timer_get (data.timer_paused, ms_paused_tmp);
1156
1157 ms_paused += ms_paused_tmp;
1158 }
1159
1160 #ifdef WIN
1161
1162 __time64_t sec_run = ms_running / 1000;
1163
1164 #else
1165
1166 time_t sec_run = ms_running / 1000;
1167
1168 #endif
1169
1170 if (sec_run)
1171 {
1172 char display_run[32];
1173
1174 struct tm tm_run;
1175
1176 struct tm *tmp;
1177
1178 #ifdef WIN
1179
1180 tmp = _gmtime64 (&sec_run);
1181
1182 #else
1183
1184 tmp = gmtime (&sec_run);
1185
1186 #endif
1187
1188 if (tmp != NULL)
1189 {
1190 memcpy (&tm_run, tmp, sizeof (struct tm));
1191
1192 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1193
1194 char *start = ctime (&data.proc_start);
1195
1196 size_t start_len = strlen (start);
1197
1198 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1199 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1200
1201 log_info ("Time.Started...: %s (%s)", start, display_run);
1202 }
1203 }
1204 else
1205 {
1206 log_info ("Time.Started...: 0 secs");
1207 }
1208
1209 /**
1210 * counters
1211 */
1212
1213 uint salts_left = data.salts_cnt - data.salts_done;
1214
1215 if (salts_left == 0) salts_left = 1;
1216
1217 uint64_t progress_total = data.words_cnt * salts_left;
1218
1219 uint64_t all_done = 0;
1220 uint64_t all_rejected = 0;
1221 uint64_t all_restored = 0;
1222
1223 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1224 {
1225 if (salts_left > 1)
1226 {
1227 // otherwise the final cracked status shows 0/XXX progress
1228
1229 if (data.salts_shown[salt_pos] == 1) continue;
1230 }
1231
1232 all_done += data.words_progress_done[salt_pos];
1233 all_rejected += data.words_progress_rejected[salt_pos];
1234 all_restored += data.words_progress_restored[salt_pos];
1235 }
1236
1237 uint64_t progress_cur = all_restored + all_done + all_rejected;
1238 uint64_t progress_end = progress_total;
1239
1240 uint64_t progress_skip = 0;
1241
1242 if (data.skip)
1243 {
1244 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1245
1246 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.gpu_rules_cnt;
1247 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1248 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1249 }
1250
1251 if (data.limit)
1252 {
1253 progress_end = MIN (data.limit, data.words_base) * salts_left;
1254
1255 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.gpu_rules_cnt;
1256 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1257 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1258 }
1259
1260 uint64_t progress_cur_relative_skip = progress_cur - progress_skip;
1261 uint64_t progress_end_relative_skip = progress_end - progress_skip;
1262
1263 float speed_ms_real = ms_running - ms_paused;
1264 uint64_t speed_plains_real = all_done;
1265
1266 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1267 {
1268 if (data.devices_status != STATUS_CRACKED)
1269 {
1270 uint64_t words_per_ms = 0;
1271
1272 if (speed_plains_real && speed_ms_real)
1273 {
1274 words_per_ms = speed_plains_real / speed_ms_real;
1275 }
1276
1277 #ifdef WIN
1278 __time64_t sec_etc = 0;
1279 #else
1280 time_t sec_etc = 0;
1281 #endif
1282
1283 if (words_per_ms)
1284 {
1285 uint64_t progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1286
1287 uint64_t ms_left = progress_left_relative_skip / words_per_ms;
1288
1289 sec_etc = ms_left / 1000;
1290 }
1291
1292 if (sec_etc == 0)
1293 {
1294 log_info ("Time.Estimated.: 0 secs");
1295 }
1296 else if ((uint64_t) sec_etc > ETC_MAX)
1297 {
1298 log_info ("Time.Estimated.: > 10 Years");
1299 }
1300 else
1301 {
1302 char display_etc[32];
1303
1304 struct tm tm_etc;
1305
1306 struct tm *tmp;
1307
1308 #ifdef WIN
1309
1310 tmp = _gmtime64 (&sec_etc);
1311
1312 #else
1313
1314 tmp = gmtime (&sec_etc);
1315
1316 #endif
1317
1318 if (tmp != NULL)
1319 {
1320 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1321
1322 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1323
1324 time_t now;
1325
1326 time (&now);
1327
1328 now += sec_etc;
1329
1330 char *etc = ctime (&now);
1331
1332 size_t etc_len = strlen (etc);
1333
1334 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1335 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1336
1337 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1338 }
1339 }
1340 }
1341 }
1342
1343 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1344 {
1345 char display_dev_cur[16];
1346
1347 memset (display_dev_cur, 0, sizeof (display_dev_cur));
1348
1349 strncpy (display_dev_cur, "0.00", 4);
1350
1351 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1352
1353 log_info ("Speed.GPU.#%d...: %9sH/s", device_id + 1, display_dev_cur);
1354 }
1355
1356 char display_all_cur[16];
1357
1358 memset (display_all_cur, 0, sizeof (display_all_cur));
1359
1360 strncpy (display_all_cur, "0.00", 4);
1361
1362 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1363
1364 if (data.devices_cnt > 1) log_info ("Speed.GPU.#*...: %9sH/s", display_all_cur);
1365
1366 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1367 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1368
1369 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);
1370
1371 // crack-per-time
1372
1373 if (data.digests_cnt > 100)
1374 {
1375 time_t now = time (NULL);
1376
1377 int cpt_cur_min = 0;
1378 int cpt_cur_hour = 0;
1379 int cpt_cur_day = 0;
1380
1381 for (int i = 0; i < CPT_BUF; i++)
1382 {
1383 const uint cracked = data.cpt_buf[i].cracked;
1384 const time_t timestamp = data.cpt_buf[i].timestamp;
1385
1386 if ((timestamp + 60) > now)
1387 {
1388 cpt_cur_min += cracked;
1389 }
1390
1391 if ((timestamp + 3600) > now)
1392 {
1393 cpt_cur_hour += cracked;
1394 }
1395
1396 if ((timestamp + 86400) > now)
1397 {
1398 cpt_cur_day += cracked;
1399 }
1400 }
1401
1402 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1403 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1404 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1405
1406 if ((data.cpt_start + 86400) < now)
1407 {
1408 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1409 cpt_cur_min,
1410 cpt_cur_hour,
1411 cpt_cur_day,
1412 cpt_avg_min,
1413 cpt_avg_hour,
1414 cpt_avg_day);
1415 }
1416 else if ((data.cpt_start + 3600) < now)
1417 {
1418 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1419 cpt_cur_min,
1420 cpt_cur_hour,
1421 cpt_avg_min,
1422 cpt_avg_hour,
1423 cpt_avg_day);
1424 }
1425 else if ((data.cpt_start + 60) < now)
1426 {
1427 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1428 cpt_cur_min,
1429 cpt_avg_min,
1430 cpt_avg_hour,
1431 cpt_avg_day);
1432 }
1433 else
1434 {
1435 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1436 cpt_avg_min,
1437 cpt_avg_hour,
1438 cpt_avg_day);
1439 }
1440 }
1441
1442 // Restore point
1443
1444 uint64_t restore_point = get_lowest_words_done ();
1445
1446 uint64_t restore_total = data.words_base;
1447
1448 float percent_restore = 0;
1449
1450 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1451
1452 if (progress_end_relative_skip)
1453 {
1454 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1455 {
1456 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1457 float percent_rejected = 0.0;
1458
1459 if (progress_cur)
1460 {
1461 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1462 }
1463
1464 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);
1465 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1466
1467 if (data.restore_disable == 0)
1468 {
1469 if (percent_finished != 1)
1470 {
1471 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1472 }
1473 }
1474 }
1475 }
1476 else
1477 {
1478 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1479 {
1480 log_info ("Progress.......: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1481 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1482
1483 if (data.restore_disable == 0)
1484 {
1485 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1486 }
1487 }
1488 else
1489 {
1490 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1491 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1492
1493 // --restore not allowed if stdin is used -- really? why?
1494
1495 //if (data.restore_disable == 0)
1496 //{
1497 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1498 //}
1499 }
1500 }
1501
1502 if (data.gpu_temp_disable == 0)
1503 {
1504 hc_thread_mutex_lock (mux_adl);
1505
1506 for (uint i = 0; i < data.devices_cnt; i++)
1507 {
1508 if (data.hm_device[i].fan_supported == 1)
1509 {
1510 const int temperature = hm_get_temperature_with_device_id (i);
1511 const int utilization = hm_get_utilization_with_device_id (i);
1512 const int fanspeed = hm_get_fanspeed_with_device_id (i);
1513
1514 #ifdef _OCL
1515 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, %2d%% Fan", i + 1, utilization, temperature, fanspeed);
1516 #else
1517 #ifdef LINUX
1518 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, %2d%% Fan", i + 1, utilization, temperature, fanspeed);
1519 #else
1520 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, %2drpm Fan", i + 1, utilization, temperature, fanspeed);
1521 #endif
1522 #endif
1523 }
1524 else
1525 {
1526 const int temperature = hm_get_temperature_with_device_id (i);
1527 const int utilization = hm_get_utilization_with_device_id (i);
1528
1529 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, N/A Fan", i + 1, utilization, temperature);
1530 }
1531 }
1532
1533 hc_thread_mutex_unlock (mux_adl);
1534 }
1535 }
1536
1537 static void status_benchmark ()
1538 {
1539 if (data.devices_status == STATUS_INIT) return;
1540 if (data.devices_status == STATUS_STARTING) return;
1541
1542 if (data.words_cnt == 0) return;
1543
1544 uint64_t speed_cnt[DEVICES_MAX];
1545 float speed_ms[DEVICES_MAX];
1546
1547 uint device_id;
1548
1549 for (device_id = 0; device_id < data.devices_cnt; device_id++)
1550 {
1551 hc_device_param_t *device_param = &data.devices_param[device_id];
1552
1553 speed_cnt[device_id] = 0;
1554 speed_ms[device_id] = 0;
1555
1556 for (int i = 0; i < SPEED_CACHE; i++)
1557 {
1558 speed_cnt[device_id] += device_param->speed_cnt[i];
1559 speed_ms[device_id] += device_param->speed_ms[i];
1560 }
1561
1562 speed_cnt[device_id] /= SPEED_CACHE;
1563 speed_ms[device_id] /= SPEED_CACHE;
1564 }
1565
1566 float hashes_all_ms = 0;
1567
1568 float hashes_dev_ms[DEVICES_MAX];
1569
1570 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1571 {
1572 hashes_dev_ms[device_id] = 0;
1573
1574 if (speed_ms[device_id])
1575 {
1576 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1577
1578 hashes_all_ms += hashes_dev_ms[device_id];
1579 }
1580 }
1581
1582 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1583 {
1584 char display_dev_cur[16];
1585
1586 memset (display_dev_cur, 0, sizeof (display_dev_cur));
1587
1588 strncpy (display_dev_cur, "0.00", 4);
1589
1590 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1591
1592 log_info ("Speed.GPU.#%d.: %9sH/s", device_id + 1, display_dev_cur);
1593 }
1594
1595 char display_all_cur[16];
1596
1597 memset (display_all_cur, 0, sizeof (display_all_cur));
1598
1599 strncpy (display_all_cur, "0.00", 4);
1600
1601 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1602
1603 if (data.devices_cnt > 1) log_info ("Speed.GPU.#*.: %9sH/s", display_all_cur);
1604 }
1605
1606 /**
1607 * oclHashcat -only- functions
1608 */
1609
1610 #ifdef _CUDA
1611
1612 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *install_dir, char *kernel_file)
1613 {
1614 if (attack_exec == ATTACK_EXEC_ON_GPU)
1615 {
1616 if (attack_kern == ATTACK_KERN_STRAIGHT)
1617 snprintf (kernel_file, 255, "%s/nv/m%05d_a0.cu", install_dir, (int) kern_type);
1618 else if (attack_kern == ATTACK_KERN_COMBI)
1619 snprintf (kernel_file, 255, "%s/nv/m%05d_a1.cu", install_dir, (int) kern_type);
1620 else if (attack_kern == ATTACK_KERN_BF)
1621 snprintf (kernel_file, 255, "%s/nv/m%05d_a3.cu", install_dir, (int) kern_type);
1622 }
1623 else
1624 snprintf (kernel_file, 255, "%s/nv/m%05d.cu", install_dir, (int) kern_type);
1625 }
1626
1627 #elif _OCL
1628
1629 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *install_dir, char *kernel_file)
1630 {
1631 if (attack_exec == ATTACK_EXEC_ON_GPU)
1632 {
1633 if (attack_kern == ATTACK_KERN_STRAIGHT)
1634 snprintf (kernel_file, 255, "%s/amd/m%05d_a0.cl", install_dir, (int) kern_type);
1635 else if (attack_kern == ATTACK_KERN_COMBI)
1636 snprintf (kernel_file, 255, "%s/amd/m%05d_a1.cl", install_dir, (int) kern_type);
1637 else if (attack_kern == ATTACK_KERN_BF)
1638 snprintf (kernel_file, 255, "%s/amd/m%05d_a3.cl", install_dir, (int) kern_type);
1639 }
1640 else
1641 snprintf (kernel_file, 255, "%s/amd/m%05d.cl", install_dir, (int) kern_type);
1642 }
1643
1644 #endif
1645
1646
1647 static uint convert_from_hex (char *line_buf, const uint line_len)
1648 {
1649 if (line_len & 1) return (line_len); // not in hex
1650
1651 if (data.hex_wordlist == 1)
1652 {
1653 uint i;
1654 uint j;
1655
1656 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1657 {
1658 line_buf[i] = hex_to_char (&line_buf[j]);
1659 }
1660
1661 memset (line_buf + i, 0, line_len - i);
1662
1663 return (i);
1664 }
1665 else if (line_len >= 6) // $HEX[] = 6
1666 {
1667 if (line_buf[0] != '$') return (line_len);
1668 if (line_buf[1] != 'H') return (line_len);
1669 if (line_buf[2] != 'E') return (line_len);
1670 if (line_buf[3] != 'X') return (line_len);
1671 if (line_buf[4] != '[') return (line_len);
1672 if (line_buf[line_len - 1] != ']') return (line_len);
1673
1674 uint i;
1675 uint j;
1676
1677 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1678 {
1679 line_buf[i] = hex_to_char (&line_buf[j]);
1680 }
1681
1682 memset (line_buf + i, 0, line_len - i);
1683
1684 return (i);
1685 }
1686
1687 return (line_len);
1688 }
1689
1690 static uint count_lines (FILE *fd)
1691 {
1692 uint cnt = 0;
1693
1694 char *buf = (char *) mymalloc (BUFSIZ);
1695
1696 size_t nread_tmp = 0;
1697
1698 char *ptr = buf;
1699
1700 while (!feof (fd))
1701 {
1702 size_t nread = fread (buf, sizeof (char), BUFSIZ, fd);
1703 nread_tmp = nread;
1704
1705 if (nread < 1) continue;
1706
1707 ptr = buf;
1708
1709 do
1710 {
1711 if (*ptr++ == '\n') cnt++;
1712
1713 } while (nread--);
1714 }
1715
1716 // special case (if last line did not contain a newline char ... at the very end of the file)
1717
1718 if (nread_tmp > 3)
1719 {
1720 ptr -= 2;
1721
1722 if (*ptr != '\n')
1723 {
1724 ptr--;
1725
1726 if (*ptr != '\n') // needed ? different on windows systems?
1727 {
1728 cnt++;
1729 }
1730 }
1731 }
1732
1733 myfree (buf);
1734
1735 return cnt;
1736 }
1737
1738 static void clear_prompt ()
1739 {
1740 fputc ('\r', stdout);
1741
1742 for (size_t i = 0; i < strlen (PROMPT); i++)
1743 {
1744 fputc (' ', stdout);
1745 }
1746
1747 fputc ('\r', stdout);
1748
1749 fflush (stdout);
1750 }
1751
1752 static void gidd_to_pw_t (hc_device_param_t *device_param, const uint64_t gidd, pw_t *pw)
1753 {
1754 #ifdef _CUDA
1755 hc_cuCtxPushCurrent (device_param->context);
1756
1757 hc_cuMemcpyDtoH (pw, device_param->d_pws_buf + (gidd * sizeof (pw_t)), sizeof (pw_t));
1758
1759 hc_cuCtxPopCurrent (&device_param->context);
1760
1761 #elif _OCL
1762 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1763
1764 #endif
1765 }
1766
1767 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1768 {
1769 char *outfile = data.outfile;
1770 uint quiet = data.quiet;
1771 FILE *pot_fp = data.pot_fp;
1772 uint loopback = data.loopback;
1773 uint debug_mode = data.debug_mode;
1774 char *debug_file = data.debug_file;
1775
1776 char debug_rule_buf[BLOCK_SIZE];
1777 int debug_rule_len = 0; // -1 error
1778 uint debug_plain_len = 0;
1779
1780 unsigned char debug_plain_ptr[BLOCK_SIZE];
1781
1782 // hash
1783
1784 char out_buf[4096]; memset (out_buf, 0, sizeof (out_buf));
1785
1786 ascii_digest (out_buf, salt_pos, digest_pos);
1787
1788 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1789
1790 // plain
1791
1792 plain_t plain;
1793
1794 #ifdef _CUDA
1795 hc_cuCtxPushCurrent (device_param->context);
1796
1797 hc_cuMemcpyDtoH (&plain, device_param->d_plain_bufs + (idx * sizeof (plain_t)), sizeof (plain_t));
1798
1799 hc_cuCtxPopCurrent (&device_param->context);
1800 #elif _OCL
1801 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, idx * sizeof (plain_t), sizeof (plain_t), &plain, 0, NULL, NULL);
1802 #endif
1803
1804 uint gidvid = plain.gidvid;
1805 uint il_pos = plain.il_pos;
1806
1807 uint64_t crackpos = device_param->words_off;
1808
1809 uint plain_buf[16];
1810
1811 unsigned char *plain_ptr = (unsigned char *) plain_buf;
1812 unsigned int plain_len = 0;
1813
1814 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1815 {
1816 uint64_t gidd = gidvid / device_param->gpu_vector_width;
1817 uint64_t gidm = gidvid % device_param->gpu_vector_width;
1818
1819 pw_t pw;
1820
1821 gidd_to_pw_t (device_param, gidd, &pw);
1822
1823 for (int i = 0, j = gidm; i < 16; i++, j += device_param->gpu_vector_width)
1824 {
1825 plain_buf[i] = pw.hi1[0][j];
1826 }
1827
1828 plain_len = pw.pw_len;
1829
1830 const uint off = device_param->innerloop_pos + il_pos;
1831
1832 if (debug_mode > 0)
1833 {
1834 debug_rule_len = 0;
1835
1836 // save rule
1837 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1838 {
1839 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1840
1841 debug_rule_len = gpu_rule_to_cpu_rule (debug_rule_buf, &data.gpu_rules_buf[off]);
1842 }
1843
1844 // save plain
1845 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1846 {
1847 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1848
1849 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1850
1851 debug_plain_len = plain_len;
1852 }
1853 }
1854
1855 plain_len = apply_rules (data.gpu_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1856
1857 crackpos += gidvid;
1858 crackpos *= data.gpu_rules_cnt;
1859 crackpos += device_param->innerloop_pos + il_pos;
1860
1861 if (plain_len > data.pw_max) plain_len = data.pw_max;
1862 }
1863 else if (data.attack_mode == ATTACK_MODE_COMBI)
1864 {
1865 uint64_t gidd = gidvid / device_param->gpu_vector_width;
1866 uint64_t gidm = gidvid % device_param->gpu_vector_width;
1867
1868 pw_t pw;
1869
1870 gidd_to_pw_t (device_param, gidd, &pw);
1871
1872 for (int i = 0, j = gidm; i < 16; i++, j += device_param->gpu_vector_width)
1873 {
1874 plain_buf[i] = pw.hi1[0][j];
1875 }
1876
1877 plain_len = pw.pw_len;
1878
1879 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1880 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1881
1882 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1883 {
1884 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1885 }
1886 else
1887 {
1888 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1889
1890 memcpy (plain_ptr, comb_buf, comb_len);
1891 }
1892
1893 plain_len += comb_len;
1894
1895 crackpos += gidvid;
1896 crackpos *= data.combs_cnt;
1897 crackpos += device_param->innerloop_pos + il_pos;
1898
1899 if (data.pw_max != PW_DICTMAX1)
1900 {
1901 if (plain_len > data.pw_max) plain_len = data.pw_max;
1902 }
1903 }
1904 else if (data.attack_mode == ATTACK_MODE_BF)
1905 {
1906 uint64_t l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1907 uint64_t r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1908
1909 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1910 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1911
1912 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1913 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1914
1915 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1916 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1917
1918 plain_len = data.css_cnt;
1919
1920 crackpos += gidvid;
1921 crackpos *= data.bfs_cnt;
1922 crackpos += device_param->innerloop_pos + il_pos;
1923 }
1924 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1925 {
1926 uint64_t gidd = gidvid / device_param->gpu_vector_width;
1927 uint64_t gidm = gidvid % device_param->gpu_vector_width;
1928
1929 pw_t pw;
1930
1931 gidd_to_pw_t (device_param, gidd, &pw);
1932
1933 for (int i = 0, j = gidm; i < 16; i++, j += device_param->gpu_vector_width)
1934 {
1935 plain_buf[i] = pw.hi1[0][j];
1936 }
1937
1938 plain_len = pw.pw_len;
1939
1940 uint64_t off = device_param->kernel_params_mp_buf64[3] + il_pos;
1941
1942 uint start = 0;
1943 uint stop = device_param->kernel_params_mp_buf32[4];
1944
1945 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
1946
1947 plain_len += start + stop;
1948
1949 crackpos += gidvid;
1950 crackpos *= data.combs_cnt;
1951 crackpos += device_param->innerloop_pos + il_pos;
1952
1953 if (data.pw_max != PW_DICTMAX1)
1954 {
1955 if (plain_len > data.pw_max) plain_len = data.pw_max;
1956 }
1957 }
1958 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1959 {
1960 uint64_t gidd = gidvid / device_param->gpu_vector_width;
1961 uint64_t gidm = gidvid % device_param->gpu_vector_width;
1962
1963 pw_t pw;
1964
1965 gidd_to_pw_t (device_param, gidd, &pw);
1966
1967 for (int i = 0, j = gidm; i < 16; i++, j += device_param->gpu_vector_width)
1968 {
1969 plain_buf[i] = pw.hi1[0][j];
1970 }
1971
1972 plain_len = pw.pw_len;
1973
1974 uint64_t off = device_param->kernel_params_mp_buf64[3] + il_pos;
1975
1976 uint start = 0;
1977 uint stop = device_param->kernel_params_mp_buf32[4];
1978
1979 memmove (plain_ptr + stop, plain_ptr, plain_len);
1980
1981 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
1982
1983 plain_len += start + stop;
1984
1985 crackpos += gidvid;
1986 crackpos *= data.combs_cnt;
1987 crackpos += device_param->innerloop_pos + il_pos;
1988
1989 if (data.pw_max != PW_DICTMAX1)
1990 {
1991 if (plain_len > data.pw_max) plain_len = data.pw_max;
1992 }
1993 }
1994
1995 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
1996 {
1997 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1998 {
1999 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2000 {
2001 plain_len = plain_len - data.salts_buf[0].salt_len;
2002 }
2003 }
2004
2005 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2006 {
2007 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2008 {
2009 plain_ptr[j] = plain_ptr[i];
2010 }
2011
2012 plain_len = plain_len / 2;
2013 }
2014 }
2015
2016 // if enabled, update also the potfile
2017
2018 if (pot_fp)
2019 {
2020 fprintf (pot_fp, "%s:", out_buf);
2021
2022 format_plain (pot_fp, plain_ptr, plain_len, 1);
2023
2024 fputc ('\n', pot_fp);
2025
2026 fflush (pot_fp);
2027 }
2028
2029 // outfile
2030
2031 FILE *out_fp = NULL;
2032
2033 if (outfile != NULL)
2034 {
2035 if ((out_fp = fopen (outfile, "ab")) == NULL)
2036 {
2037 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2038
2039 out_fp = stdout;
2040 }
2041 }
2042 else
2043 {
2044 out_fp = stdout;
2045
2046 if (quiet == 0) clear_prompt ();
2047 }
2048
2049 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2050
2051 if (outfile != NULL)
2052 {
2053 if (out_fp != stdout)
2054 {
2055 fclose (out_fp);
2056 }
2057 }
2058 else
2059 {
2060 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2061 {
2062 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2063 {
2064 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2065 if (quiet == 0) fflush (stdout);
2066 }
2067 }
2068 }
2069
2070 // loopback
2071
2072 if (loopback)
2073 {
2074 char *loopback_file = data.loopback_file;
2075
2076 FILE *fb_fp = NULL;
2077
2078 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2079 {
2080 format_plain (fb_fp, plain_ptr, plain_len, 1);
2081
2082 fputc ('\n', fb_fp);
2083
2084 fclose (fb_fp);
2085 }
2086 }
2087
2088 // (rule) debug mode
2089
2090 // the next check implies that:
2091 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2092 // - debug_mode > 0
2093
2094 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2095 {
2096 if (debug_rule_len < 0) debug_rule_len = 0;
2097
2098 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2099
2100 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2101
2102 if ((quiet == 0) && (debug_file == NULL))
2103 {
2104 fprintf (stdout, "%s", PROMPT);
2105 fflush (stdout);
2106 }
2107 }
2108 }
2109
2110 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2111 {
2112 salt_t *salt_buf = &data.salts_buf[salt_pos];
2113
2114 int found = 0;
2115
2116 #ifdef _CUDA
2117
2118 hc_cuCtxPushCurrent (device_param->context);
2119
2120 hc_cuMemcpyDtoH (device_param->result, device_param->d_result, device_param->size_results);
2121
2122 hc_cuCtxPopCurrent (&device_param->context);
2123
2124 for (uint i = 0; i < GPU_THREADS_NV; i++) if (device_param->result[i] == 1) found = 1;
2125
2126 #elif _OCL
2127
2128 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2129
2130 for (uint i = 0; i < GPU_THREADS_AMD; i++) if (device_param->result[i] == 1) found = 1;
2131
2132 #endif
2133
2134 if (found == 1)
2135 {
2136 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2137
2138 log_info_nn ("");
2139
2140 #ifdef _CUDA
2141
2142 hc_cuCtxPushCurrent (device_param->context);
2143
2144 hc_cuMemcpyDtoH (&data.digests_shown_tmp[salt_buf->digests_offset], device_param->d_digests_shown + (salt_buf->digests_offset * sizeof (uint)), salt_buf->digests_cnt * sizeof (uint));
2145
2146 hc_cuCtxPopCurrent (&device_param->context);
2147
2148 #elif _OCL
2149
2150 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);
2151
2152 #endif
2153
2154 uint cpt_cracked = 0;
2155
2156 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2157 {
2158 uint idx = salt_buf->digests_offset + digest_pos;
2159
2160 if (data.digests_shown_tmp[idx] == 0) continue;
2161
2162 if (data.digests_shown[idx] == 1) continue;
2163
2164 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2165 {
2166 data.digests_shown[idx] = 1;
2167
2168 data.digests_done++;
2169
2170 cpt_cracked++;
2171
2172 salt_buf->digests_done++;
2173
2174 if (salt_buf->digests_done == salt_buf->digests_cnt)
2175 {
2176 data.salts_shown[salt_pos] = 1;
2177
2178 data.salts_done++;
2179 }
2180 }
2181
2182 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2183
2184 check_hash (device_param, salt_pos, digest_pos);
2185 }
2186
2187 if (cpt_cracked > 0)
2188 {
2189 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2190 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2191
2192 data.cpt_pos++;
2193
2194 data.cpt_total += cpt_cracked;
2195
2196 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2197 }
2198
2199 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2200 {
2201 // we need to reset cracked state on the gpu
2202 // otherwise host thinks again and again the hash was cracked
2203 // and returns invalid password each time
2204
2205 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2206
2207 #ifdef _CUDA
2208
2209 hc_cuCtxPushCurrent (device_param->context);
2210
2211 hc_cuMemsetD8 (device_param->d_digests_shown + (salt_buf->digests_offset * sizeof (uint)), 0, salt_buf->digests_cnt * sizeof (uint));
2212
2213 hc_cuCtxPopCurrent (&device_param->context);
2214
2215 #elif _OCL
2216
2217 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);
2218
2219 #endif
2220 }
2221
2222 #ifdef _CUDA
2223
2224 hc_cuCtxPushCurrent (device_param->context);
2225
2226 hc_cuMemsetD8 (device_param->d_result, 0, device_param->size_results);
2227
2228 hc_cuCtxPopCurrent (&device_param->context);
2229
2230 #elif _OCL
2231
2232 memset (device_param->result, 0, device_param->size_results);
2233
2234 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2235
2236 #endif
2237 }
2238 }
2239
2240 static void save_hash ()
2241 {
2242 char *hashfile = data.hashfile;
2243
2244 char new_hashfile[256];
2245 char old_hashfile[256];
2246
2247 memset (new_hashfile, 0, sizeof (new_hashfile));
2248 memset (old_hashfile, 0, sizeof (old_hashfile));
2249
2250 snprintf (new_hashfile, 255, "%s.new", hashfile);
2251 snprintf (old_hashfile, 255, "%s.old", hashfile);
2252
2253 unlink (new_hashfile);
2254
2255 char separator = data.separator;
2256
2257 FILE *fp = fopen (new_hashfile, "wb");
2258
2259 if (fp == NULL)
2260 {
2261 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2262
2263 exit (-1);
2264 }
2265
2266 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2267 {
2268 if (data.salts_shown[salt_pos] == 1) continue;
2269
2270 salt_t *salt_buf = &data.salts_buf[salt_pos];
2271
2272 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2273 {
2274 uint idx = salt_buf->digests_offset + digest_pos;
2275
2276 if (data.digests_shown[idx] == 1) continue;
2277
2278 if (data.hash_mode != 2500)
2279 {
2280 char out_buf[4096];
2281
2282 memset (out_buf, 0, sizeof (out_buf));
2283
2284 if (data.username == 1)
2285 {
2286 user_t *user = data.hash_info[idx]->user;
2287
2288 uint i;
2289
2290 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2291
2292 fputc (separator, fp);
2293 }
2294
2295 ascii_digest (out_buf, salt_pos, digest_pos);
2296
2297 fputs (out_buf, fp);
2298
2299 log_out (fp, "");
2300 }
2301 else
2302 {
2303 hccap_t hccap;
2304
2305 to_hccap_t (&hccap, salt_pos, digest_pos);
2306
2307 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2308 }
2309 }
2310 }
2311
2312 fflush (fp);
2313
2314 fclose (fp);
2315
2316 unlink (old_hashfile);
2317
2318 if (rename (hashfile, old_hashfile) != 0)
2319 {
2320 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2321
2322 exit (-1);
2323 }
2324
2325 unlink (hashfile);
2326
2327 if (rename (new_hashfile, hashfile) != 0)
2328 {
2329 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2330
2331 exit (-1);
2332 }
2333
2334 unlink (old_hashfile);
2335 }
2336
2337 static float find_gpu_blocks_div (const uint64_t total_left, const uint gpu_blocks_all)
2338 {
2339 // function called only in case gpu_blocks_all > words_left)
2340
2341 float gpu_blocks_div = (float) (total_left) / gpu_blocks_all;
2342
2343 gpu_blocks_div += gpu_blocks_div / 100;
2344
2345 uint32_t gpu_blocks_new = (uint32_t) (gpu_blocks_all * gpu_blocks_div);
2346
2347 while (gpu_blocks_new < total_left)
2348 {
2349 gpu_blocks_div += gpu_blocks_div / 100;
2350
2351 gpu_blocks_new = (uint32_t) (gpu_blocks_all * gpu_blocks_div);
2352 }
2353
2354 if (data.quiet == 0)
2355 {
2356 clear_prompt ();
2357
2358 log_info ("");
2359
2360 log_info ("INFO: approaching final keyspace, workload adjusted");
2361
2362 log_info ("");
2363
2364 fprintf (stdout, "%s", PROMPT);
2365
2366 fflush (stdout);
2367 }
2368
2369 if ((gpu_blocks_all * gpu_blocks_div) < 8) return 1;
2370
2371 return gpu_blocks_div;
2372 }
2373
2374 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num)
2375 {
2376 // uint gpu_vector_width = device_param->gpu_vector_width;
2377
2378 // uint num_elements = mydivc32 (num, gpu_vector_width);
2379
2380 uint num_elements = num;
2381
2382 device_param->kernel_params_buf32[30] = data.combs_mode;
2383 device_param->kernel_params_buf32[31] = num;
2384
2385 uint gpu_threads = device_param->gpu_threads;
2386
2387 while (num_elements % gpu_threads) num_elements++;
2388
2389 #ifdef _CUDA
2390 CUfunction function = NULL;
2391
2392 switch (kern_run)
2393 {
2394 case KERN_RUN_1: function = device_param->function1; break;
2395 case KERN_RUN_12: function = device_param->function12; break;
2396 case KERN_RUN_2: function = device_param->function2; break;
2397 case KERN_RUN_23: function = device_param->function23; break;
2398 case KERN_RUN_3: function = device_param->function3; break;
2399 }
2400
2401 num_elements /= gpu_threads;
2402
2403 hc_cuCtxPushCurrent (device_param->context);
2404
2405 hc_cuLaunchKernel (function, num_elements, 1, 1, gpu_threads, 1, 1, 0, device_param->stream, device_param->kernel_params, NULL);
2406
2407 hc_cuStreamSynchronize (device_param->stream);
2408
2409 hc_cuCtxPopCurrent (&device_param->context);
2410
2411 #elif _OCL
2412
2413 cl_kernel kernel = NULL;
2414
2415 switch (kern_run)
2416 {
2417 case KERN_RUN_1: kernel = device_param->kernel1; break;
2418 case KERN_RUN_12: kernel = device_param->kernel12; break;
2419 case KERN_RUN_2: kernel = device_param->kernel2; break;
2420 case KERN_RUN_23: kernel = device_param->kernel23; break;
2421 case KERN_RUN_3: kernel = device_param->kernel3; break;
2422 }
2423
2424 hc_clSetKernelArg (kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2425 hc_clSetKernelArg (kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2426 hc_clSetKernelArg (kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2427 hc_clSetKernelArg (kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2428 hc_clSetKernelArg (kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2429 hc_clSetKernelArg (kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2430 hc_clSetKernelArg (kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2431 hc_clSetKernelArg (kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2432 hc_clSetKernelArg (kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2433 hc_clSetKernelArg (kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2434 hc_clSetKernelArg (kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2435
2436 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2437 {
2438 const size_t global_work_size[3] = { num_elements, 32, 1 };
2439 const size_t local_work_size[3] = { gpu_threads / 32, 32, 1 };
2440
2441 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2442 }
2443 else
2444 {
2445 const size_t global_work_size[3] = { num_elements, 1, 1 };
2446 const size_t local_work_size[3] = { gpu_threads, 1, 1 };
2447
2448 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2449 }
2450
2451 hc_clFlush (device_param->command_queue);
2452
2453 hc_clFinish (device_param->command_queue);
2454
2455 #endif
2456 }
2457
2458 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2459 {
2460 // uint gpu_vector_width = device_param->gpu_vector_width;
2461
2462 // uint num_elements = mydivc32 (num, gpu_vector_width);
2463
2464 uint num_elements = num;
2465
2466 switch (kern_run)
2467 {
2468 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2469 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2470 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2471 }
2472
2473 // causes problems with special threads like in bcrypt
2474 // const uint gpu_threads = device_param->gpu_threads;
2475
2476 #ifdef _CUDA
2477
2478 const uint gpu_threads = GPU_THREADS_NV;
2479
2480 while (num_elements % gpu_threads) num_elements++;
2481
2482 CUfunction function = NULL;
2483
2484 switch (kern_run)
2485 {
2486 case KERN_RUN_MP: function = device_param->function_mp; break;
2487 case KERN_RUN_MP_R: function = device_param->function_mp_r; break;
2488 case KERN_RUN_MP_L: function = device_param->function_mp_l; break;
2489 }
2490
2491 void **kernel_params = NULL;
2492
2493 switch (kern_run)
2494 {
2495 case KERN_RUN_MP: kernel_params = device_param->kernel_params_mp; break;
2496 case KERN_RUN_MP_R: kernel_params = device_param->kernel_params_mp_r; break;
2497 case KERN_RUN_MP_L: kernel_params = device_param->kernel_params_mp_l; break;
2498 }
2499
2500 num_elements /= gpu_threads;
2501
2502 hc_cuCtxPushCurrent (device_param->context);
2503
2504 hc_cuLaunchKernel (function, num_elements, 1, 1, gpu_threads, 1, 1, 0, device_param->stream, kernel_params, NULL);
2505
2506 hc_cuStreamSynchronize (device_param->stream);
2507
2508 hc_cuCtxPopCurrent (&device_param->context);
2509
2510 #elif _OCL
2511
2512 const uint gpu_threads = GPU_THREADS_AMD;
2513
2514 while (num_elements % gpu_threads) num_elements++;
2515
2516 cl_kernel kernel = NULL;
2517
2518 switch (kern_run)
2519 {
2520 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2521 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2522 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2523 }
2524
2525 switch (kern_run)
2526 {
2527 case KERN_RUN_MP: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2528 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2529 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2530 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2531 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2532 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2533 break;
2534 case KERN_RUN_MP_R: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2535 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2536 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2537 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2538 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2539 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2540 break;
2541 case KERN_RUN_MP_L: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2542 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2543 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2544 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2545 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2546 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2547 hc_clSetKernelArg (kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2548 break;
2549 }
2550
2551 const size_t global_work_size[3] = { num_elements, 1, 1 };
2552 const size_t local_work_size[3] = { gpu_threads, 1, 1 };
2553
2554 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2555
2556 hc_clFlush (device_param->command_queue);
2557
2558 hc_clFinish (device_param->command_queue);
2559
2560 #endif
2561 }
2562
2563 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2564 {
2565 uint num_elements = num;
2566
2567 uint gpu_threads = device_param->gpu_threads;
2568
2569 while (num_elements % gpu_threads) num_elements++;
2570
2571 #ifdef _CUDA
2572
2573 CUfunction function = device_param->function_tb;
2574
2575 void **kernel_params = device_param->kernel_params_tb;
2576
2577 hc_cuCtxPushCurrent (device_param->context);
2578
2579 hc_cuLaunchKernel (function, num_elements / gpu_threads, 1, 1, gpu_threads, 1, 1, 0, device_param->stream, kernel_params, NULL);
2580
2581 hc_cuStreamSynchronize (device_param->stream);
2582
2583 hc_cuCtxPopCurrent (&device_param->context);
2584
2585 #elif _OCL
2586
2587 cl_kernel kernel = device_param->kernel_tb;
2588
2589 const size_t global_work_size[3] = { num_elements, 1, 1 };
2590 const size_t local_work_size[3] = { gpu_threads, 1, 1 };
2591
2592 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2593
2594 hc_clFlush (device_param->command_queue);
2595
2596 hc_clFinish (device_param->command_queue);
2597
2598 #endif
2599 }
2600
2601 static void run_kernel_tm (hc_device_param_t *device_param)
2602 {
2603 const uint num_elements = 1024; // fixed
2604
2605 const uint gpu_threads = 32;
2606
2607 #ifdef _CUDA
2608
2609 CUfunction function = device_param->function_tm;
2610
2611 void **kernel_params = device_param->kernel_params_tm;
2612
2613 hc_cuCtxPushCurrent (device_param->context);
2614
2615 hc_cuLaunchKernel (function, num_elements / gpu_threads, 1, 1, gpu_threads, 1, 1, 0, device_param->stream, kernel_params, NULL);
2616
2617 hc_cuStreamSynchronize (device_param->stream);
2618
2619 hc_cuCtxPopCurrent (&device_param->context);
2620
2621 #elif _OCL
2622
2623 cl_kernel kernel = device_param->kernel_tm;
2624
2625 const size_t global_work_size[3] = { num_elements, 1, 1 };
2626 const size_t local_work_size[3] = { gpu_threads, 1, 1 };
2627
2628 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2629
2630 hc_clFlush (device_param->command_queue);
2631
2632 hc_clFinish (device_param->command_queue);
2633
2634 #endif
2635 }
2636
2637 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2638 {
2639 // uint gpu_vector_width = device_param->gpu_vector_width;
2640
2641 // uint num_elements = mydivc32 (num, gpu_vector_width);
2642
2643 uint num_elements = num;
2644
2645 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2646 device_param->kernel_params_amp_buf32[6] = num_elements;
2647
2648 // causes problems with special threads like in bcrypt
2649 // const uint gpu_threads = device_param->gpu_threads;
2650
2651 #ifdef _CUDA
2652
2653 const uint gpu_threads = GPU_THREADS_NV;
2654
2655 while (num_elements % gpu_threads) num_elements++;
2656
2657 CUfunction function = device_param->function_amp;
2658
2659 void **kernel_params = device_param->kernel_params_amp;
2660
2661 num_elements /= gpu_threads;
2662
2663 hc_cuCtxPushCurrent (device_param->context);
2664
2665 hc_cuLaunchKernel (function, num_elements, 1, 1, gpu_threads, 1, 1, 0, device_param->stream, kernel_params, NULL);
2666
2667 hc_cuStreamSynchronize (device_param->stream);
2668
2669 hc_cuCtxPopCurrent (&device_param->context);
2670
2671 #elif _OCL
2672
2673 const uint gpu_threads = GPU_THREADS_AMD;
2674
2675 while (num_elements % gpu_threads) num_elements++;
2676
2677 cl_kernel kernel = device_param->kernel_amp;
2678
2679 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2680 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2681
2682 const size_t global_work_size[3] = { num_elements, 1, 1 };
2683 const size_t local_work_size[3] = { gpu_threads, 1, 1 };
2684
2685 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2686
2687 hc_clFlush (device_param->command_queue);
2688
2689 hc_clFinish (device_param->command_queue);
2690
2691 #endif
2692 }
2693
2694 #ifdef _OCL
2695 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2696 {
2697 const cl_uchar zero = 0;
2698
2699 hc_clEnqueueFillBuffer (device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2700 }
2701 #elif _CUDA
2702 static void run_kernel_bzero (hc_device_param_t *device_param, CUdeviceptr buf, const uint size)
2703 {
2704 hc_cuCtxPushCurrent (device_param->context);
2705
2706 hc_cuMemsetD8 (buf, 0, size);
2707
2708 hc_cuCtxPopCurrent (&device_param->context);
2709 }
2710 #endif
2711
2712 static int run_rule_engine (const int rule_len, const char *rule_buf)
2713 {
2714 if (rule_len == 0)
2715 {
2716 return 0;
2717 }
2718 else if (rule_len == 1)
2719 {
2720 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2721 }
2722
2723 return 1;
2724 }
2725
2726 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2727 {
2728 #ifdef _CUDA
2729 hc_cuCtxPushCurrent (device_param->context);
2730 #endif
2731
2732 // clear some leftovers from previous run (maskfiles, etc)
2733
2734 #ifdef _CUDA
2735 if (device_param->c_bfs != 0) // should be only true in this specific case: if (data.attack_kern == ATTACK_KERN_BF)
2736 {
2737 hc_cuMemsetD8 (device_param->c_bfs, 0, device_param->c_bytes);
2738 }
2739 #endif
2740
2741 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2742 {
2743 #ifdef _CUDA
2744 hc_cuMemcpyHtoD (device_param->d_pws_buf, device_param->pws_buf, pws_cnt * sizeof (pw_t));
2745 #elif _OCL
2746 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);
2747 #endif
2748 }
2749 else if (data.attack_kern == ATTACK_KERN_COMBI)
2750 {
2751 #ifdef _CUDA
2752 hc_cuMemcpyHtoD (device_param->d_pws_buf, device_param->pws_buf, pws_cnt * sizeof (pw_t));
2753 #elif _OCL
2754 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);
2755 #endif
2756 }
2757 else if (data.attack_kern == ATTACK_KERN_BF)
2758 {
2759 const uint64_t off = device_param->words_off;
2760
2761 device_param->kernel_params_mp_l_buf64[3] = off;
2762
2763 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2764 }
2765
2766 #ifdef _CUDA
2767 hc_cuCtxPopCurrent (&device_param->context);
2768 #endif
2769 }
2770
2771 static void run_cracker (hc_device_param_t *device_param, const uint pw_cnt, const uint pws_cnt)
2772 {
2773 const uint gpu_loops = data.gpu_loops;
2774
2775 // init speed timer
2776
2777 uint speed_pos = device_param->speed_pos;
2778
2779 #ifdef _POSIX
2780 if (device_param->timer_speed.tv_sec == 0)
2781 {
2782 hc_timer_set (&device_param->timer_speed);
2783 }
2784 #endif
2785
2786 #ifdef _WIN
2787 if (device_param->timer_speed.QuadPart == 0)
2788 {
2789 hc_timer_set (&device_param->timer_speed);
2790 }
2791 #endif
2792
2793 // find higest password length, this is for optimization stuff
2794
2795 uint highest_pw_len = 0;
2796
2797 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2798 {
2799 }
2800 else if (data.attack_kern == ATTACK_KERN_COMBI)
2801 {
2802 }
2803 else if (data.attack_kern == ATTACK_KERN_BF)
2804 {
2805 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
2806 + device_param->kernel_params_mp_l_buf32[5];
2807 }
2808
2809 // bitslice optimization stuff
2810
2811 if (data.attack_mode == ATTACK_MODE_BF)
2812 {
2813 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2814 {
2815 run_kernel_tb (device_param, pws_cnt);
2816 }
2817 }
2818
2819 // iteration type
2820
2821 uint innerloop_step = 0;
2822 uint innerloop_cnt = 0;
2823
2824 if (data.attack_exec == ATTACK_EXEC_ON_GPU) innerloop_step = gpu_loops;
2825 else innerloop_step = 1;
2826
2827 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.gpu_rules_cnt;
2828 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
2829 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
2830
2831 // loop start: most outer loop = salt iteration, then innerloops (if multi)
2832
2833 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2834 {
2835 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2836
2837 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2838
2839 if (data.devices_status == STATUS_CRACKED) break;
2840 if (data.devices_status == STATUS_ABORTED) break;
2841 if (data.devices_status == STATUS_QUIT) break;
2842 if (data.devices_status == STATUS_BYPASS) break;
2843
2844 if (data.salts_shown[salt_pos] == 1) continue;
2845
2846 salt_t *salt_buf = &data.salts_buf[salt_pos];
2847
2848 device_param->kernel_params_buf32[24] = salt_pos;
2849 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
2850 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
2851
2852 FILE *combs_fp = device_param->combs_fp;
2853
2854 if (data.attack_mode == ATTACK_MODE_COMBI)
2855 {
2856 rewind (combs_fp);
2857 }
2858
2859 // innerloops
2860
2861 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
2862 {
2863 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2864
2865 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2866
2867 if (data.devices_status == STATUS_CRACKED) break;
2868 if (data.devices_status == STATUS_ABORTED) break;
2869 if (data.devices_status == STATUS_QUIT) break;
2870 if (data.devices_status == STATUS_BYPASS) break;
2871
2872 uint innerloop_left = innerloop_cnt - innerloop_pos;
2873
2874 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
2875
2876 device_param->innerloop_pos = innerloop_pos;
2877 device_param->innerloop_left = innerloop_left;
2878
2879 device_param->kernel_params_buf32[27] = innerloop_left;
2880
2881 if (innerloop_left == 0) continue;
2882
2883 // initialize amplifiers
2884
2885 if (data.attack_mode == ATTACK_MODE_COMBI)
2886 {
2887 char line_buf[BUFSIZ];
2888
2889 uint i = 0;
2890
2891 while (i < innerloop_left)
2892 {
2893 if (feof (combs_fp)) break;
2894
2895 int line_len = fgetl (combs_fp, line_buf);
2896
2897 if (line_len >= PW_MAX1) continue;
2898
2899 line_len = convert_from_hex (line_buf, line_len);
2900
2901 char *line_buf_new = line_buf;
2902
2903 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
2904 {
2905 char rule_buf_out[BLOCK_SIZE];
2906
2907 memset (rule_buf_out, 0, sizeof (rule_buf_out));
2908
2909 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
2910
2911 if (rule_len_out < 0)
2912 {
2913 data.words_progress_rejected[salt_pos] += pw_cnt;
2914
2915 continue;
2916 }
2917
2918 line_len = rule_len_out;
2919
2920 line_buf_new = rule_buf_out;
2921 }
2922
2923 line_len = MIN (line_len, PW_DICTMAX);
2924
2925 char *ptr = (char *) device_param->combs_buf[i].i;
2926
2927 memcpy (ptr, line_buf_new, line_len);
2928
2929 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
2930
2931 if (data.opts_type & OPTS_TYPE_PT_UPPER)
2932 {
2933 uppercase (ptr, line_len);
2934 }
2935
2936 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2937 {
2938 if (data.opts_type & OPTS_TYPE_PT_ADD80)
2939 {
2940 ptr[line_len] = 0x80;
2941 }
2942
2943 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2944 {
2945 ptr[line_len] = 0x01;
2946 }
2947 }
2948
2949 device_param->combs_buf[i].pw_len = line_len;
2950
2951 i++;
2952 }
2953
2954 for (uint j = i; j < innerloop_left; j++)
2955 {
2956 device_param->combs_buf[j].i[0] = 0;
2957 device_param->combs_buf[j].i[1] = 0;
2958 device_param->combs_buf[j].i[2] = 0;
2959 device_param->combs_buf[j].i[3] = 0;
2960 device_param->combs_buf[j].i[4] = 0;
2961 device_param->combs_buf[j].i[5] = 0;
2962 device_param->combs_buf[j].i[6] = 0;
2963 device_param->combs_buf[j].i[7] = 0;
2964
2965 device_param->combs_buf[j].pw_len = 0;
2966 }
2967
2968 innerloop_left = i;
2969 }
2970 else if (data.attack_mode == ATTACK_MODE_BF)
2971 {
2972 uint64_t off = innerloop_pos;
2973
2974 device_param->kernel_params_mp_r_buf64[3] = off;
2975
2976 const uint gpu_vector_width = device_param->gpu_vector_width;
2977
2978 const uint innerloop_left_d = mydivc32 (innerloop_left, gpu_vector_width);
2979
2980 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left_d);
2981 }
2982 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2983 {
2984 uint64_t off = innerloop_pos;
2985
2986 device_param->kernel_params_mp_buf64[3] = off;
2987
2988 const uint gpu_vector_width = device_param->gpu_vector_width;
2989
2990 const uint innerloop_left_d = mydivc32 (innerloop_left, gpu_vector_width);
2991
2992 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left_d);
2993 }
2994 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2995 {
2996 uint64_t off = innerloop_pos;
2997
2998 device_param->kernel_params_mp_buf64[3] = off;
2999
3000 const uint gpu_vector_width = device_param->gpu_vector_width;
3001
3002 const uint innerloop_left_d = mydivc32 (innerloop_left, gpu_vector_width);
3003
3004 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left_d);
3005 }
3006
3007 // copy amplifiers
3008
3009 #ifdef _CUDA
3010 hc_cuCtxPushCurrent (device_param->context);
3011
3012 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3013 {
3014 hc_cuMemcpyDtoD (device_param->c_rules, device_param->d_rules + (innerloop_pos * sizeof (gpu_rule_t)), innerloop_left * sizeof (gpu_rule_t));
3015 }
3016 else if (data.attack_mode == ATTACK_MODE_COMBI)
3017 {
3018 hc_cuMemcpyHtoD (device_param->c_combs, device_param->combs_buf, innerloop_left * sizeof (comb_t));
3019 }
3020 else if (data.attack_mode == ATTACK_MODE_BF)
3021 {
3022 hc_cuMemcpyDtoD (device_param->c_bfs, device_param->d_bfs, innerloop_left * sizeof (bf_t));
3023 }
3024 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3025 {
3026 hc_cuMemcpyDtoD (device_param->c_combs, device_param->d_combs, innerloop_left * sizeof (comb_t));
3027 }
3028 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3029 {
3030 hc_cuMemcpyDtoD (device_param->c_combs, device_param->d_combs, innerloop_left * sizeof (comb_t));
3031 }
3032
3033 hc_cuCtxPopCurrent (&device_param->context);
3034
3035 #elif _OCL
3036 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3037 {
3038 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);
3039 }
3040 else if (data.attack_mode == ATTACK_MODE_COMBI)
3041 {
3042 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);
3043 }
3044 else if (data.attack_mode == ATTACK_MODE_BF)
3045 {
3046 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);
3047 }
3048 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3049 {
3050 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);
3051 }
3052 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3053 {
3054 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);
3055 }
3056
3057 #endif
3058
3059 if (data.attack_exec == ATTACK_EXEC_ON_GPU)
3060 {
3061 if (data.attack_mode == ATTACK_MODE_BF)
3062 {
3063 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
3064 {
3065 const uint size_tm = 32 * sizeof (bs_word_t);
3066
3067 #ifdef _CUDA
3068 run_kernel_bzero (device_param, device_param->d_tm, size_tm);
3069 #elif _OCL
3070 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
3071 #endif
3072
3073 run_kernel_tm (device_param);
3074
3075 #ifdef _CUDA
3076 hc_cuCtxPushCurrent (device_param->context);
3077
3078 hc_cuMemcpyDtoD (device_param->c_tm, device_param->d_tm, size_tm);
3079
3080 hc_cuCtxPopCurrent (&device_param->context);
3081 #elif _OCL
3082 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
3083 #endif
3084 }
3085 }
3086
3087 if (highest_pw_len < 16)
3088 {
3089 run_kernel (KERN_RUN_1, device_param, pws_cnt);
3090 }
3091 else if (highest_pw_len < 32)
3092 {
3093 run_kernel (KERN_RUN_2, device_param, pws_cnt);
3094 }
3095 else
3096 {
3097 run_kernel (KERN_RUN_3, device_param, pws_cnt);
3098 }
3099 }
3100 else
3101 {
3102 run_kernel_amp (device_param, pws_cnt);
3103
3104 run_kernel (KERN_RUN_1, device_param, pws_cnt);
3105
3106 if (data.opts_type & OPTS_TYPE_HOOK12)
3107 {
3108 run_kernel (KERN_RUN_12, device_param, pws_cnt);
3109 }
3110
3111 uint iter = salt_buf->salt_iter;
3112
3113 for (uint loop_pos = 0; loop_pos < iter; loop_pos += gpu_loops)
3114 {
3115 uint loop_left = iter - loop_pos;
3116
3117 loop_left = MIN (loop_left, gpu_loops);
3118
3119 device_param->kernel_params_buf32[25] = loop_pos;
3120 device_param->kernel_params_buf32[26] = loop_left;
3121
3122 run_kernel (KERN_RUN_2, device_param, pws_cnt);
3123
3124 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3125
3126 if (data.devices_status == STATUS_CRACKED) break;
3127 if (data.devices_status == STATUS_ABORTED) break;
3128 if (data.devices_status == STATUS_QUIT) break;
3129 }
3130
3131 if (data.opts_type & OPTS_TYPE_HOOK23)
3132 {
3133 run_kernel (KERN_RUN_23, device_param, pws_cnt);
3134
3135 #ifdef _CUDA
3136 hc_cuCtxPushCurrent (device_param->context);
3137
3138 hc_cuMemcpyDtoH (device_param->hooks_buf, device_param->d_hooks, device_param->size_hooks);
3139
3140 hc_cuCtxPopCurrent (&device_param->context);
3141 #elif _OCL
3142 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
3143 #endif
3144
3145 // do something with data
3146
3147
3148 #ifdef _CUDA
3149 hc_cuCtxPushCurrent (device_param->context);
3150
3151 hc_cuMemcpyHtoD (device_param->d_hooks, device_param->hooks_buf, device_param->size_hooks);
3152
3153 hc_cuCtxPopCurrent (&device_param->context);
3154 #elif _OCL
3155 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
3156 #endif
3157 }
3158
3159 run_kernel (KERN_RUN_3, device_param, pws_cnt);
3160 }
3161
3162 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3163
3164 if (data.devices_status == STATUS_CRACKED) break;
3165 if (data.devices_status == STATUS_ABORTED) break;
3166 if (data.devices_status == STATUS_QUIT) break;
3167
3168 /**
3169 * result
3170 */
3171
3172 hc_thread_mutex_lock (mux_display);
3173
3174 check_cracked (device_param, salt_pos);
3175
3176 hc_thread_mutex_unlock (mux_display);
3177
3178 /**
3179 * progress
3180 */
3181
3182 uint64_t perf_sum_all = (uint64_t) pw_cnt * (uint64_t) innerloop_left;
3183
3184 hc_thread_mutex_lock (mux_counter);
3185
3186 data.words_progress_done[salt_pos] += perf_sum_all;
3187
3188 hc_thread_mutex_unlock (mux_counter);
3189
3190 /**
3191 * speed
3192 */
3193
3194 float speed_ms;
3195
3196 hc_timer_get (device_param->timer_speed, speed_ms);
3197
3198 hc_timer_set (&device_param->timer_speed);
3199
3200 hc_thread_mutex_lock (mux_display);
3201
3202 device_param->speed_cnt[speed_pos] = perf_sum_all;
3203
3204 device_param->speed_ms[speed_pos] = speed_ms;
3205
3206 device_param->speed_rec[speed_pos] = device_param->timer_speed;
3207
3208 hc_thread_mutex_unlock (mux_display);
3209
3210 speed_pos++;
3211
3212 if (speed_pos == SPEED_CACHE)
3213 {
3214 speed_pos = 0;
3215 }
3216 }
3217 }
3218
3219 device_param->speed_pos = speed_pos;
3220 }
3221
3222 static void load_segment (wl_data_t *wl_data, FILE *fd)
3223 {
3224 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3225
3226 wl_data->pos = 0;
3227
3228 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3229
3230 wl_data->buf[wl_data->cnt] = 0;
3231
3232 if (wl_data->cnt == 0) return;
3233
3234 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3235
3236 while (!feof (fd))
3237 {
3238 if (wl_data->cnt == wl_data->avail)
3239 {
3240 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3241
3242 wl_data->avail += wl_data->incr;
3243 }
3244
3245 const int c = fgetc (fd);
3246
3247 if (c == EOF) break;
3248
3249 wl_data->buf[wl_data->cnt] = (char) c;
3250
3251 wl_data->cnt++;
3252
3253 if (c == '\n') break;
3254 }
3255
3256 // ensure stream ends with a newline
3257
3258 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3259 {
3260 wl_data->cnt++;
3261
3262 wl_data->buf[wl_data->cnt - 1] = '\n';
3263 }
3264
3265 return;
3266 }
3267
3268 static void get_next_word_lm (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
3269 {
3270 char *ptr = buf;
3271
3272 for (uint32_t i = 0; i < sz; i++, ptr++)
3273 {
3274 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3275
3276 if (i == 7)
3277 {
3278 *off = i;
3279 *len = i;
3280
3281 return;
3282 }
3283
3284 if (*ptr != '\n') continue;
3285
3286 *off = i + 1;
3287
3288 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3289
3290 *len = i;
3291
3292 return;
3293 }
3294
3295 *off = sz;
3296 *len = sz;
3297 }
3298
3299 static void get_next_word_uc (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
3300 {
3301 char *ptr = buf;
3302
3303 for (uint32_t i = 0; i < sz; i++, ptr++)
3304 {
3305 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3306
3307 if (*ptr != '\n') continue;
3308
3309 *off = i + 1;
3310
3311 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3312
3313 *len = i;
3314
3315 return;
3316 }
3317
3318 *off = sz;
3319 *len = sz;
3320 }
3321
3322 static void get_next_word_std (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
3323 {
3324 char *ptr = buf;
3325
3326 for (uint32_t i = 0; i < sz; i++, ptr++)
3327 {
3328 if (*ptr != '\n') continue;
3329
3330 *off = i + 1;
3331
3332 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3333
3334 *len = i;
3335
3336 return;
3337 }
3338
3339 *off = sz;
3340 *len = sz;
3341 }
3342
3343 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3344 {
3345 while (wl_data->pos < wl_data->cnt)
3346 {
3347 uint off;
3348 uint len;
3349
3350 char *ptr = wl_data->buf + wl_data->pos;
3351
3352 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3353
3354 wl_data->pos += off;
3355
3356 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3357 {
3358 char rule_buf_out[BLOCK_SIZE];
3359
3360 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3361
3362 int rule_len_out = -1;
3363
3364 if (len < BLOCK_SIZE)
3365 {
3366 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3367 }
3368
3369 if (rule_len_out < 0)
3370 {
3371 continue;
3372 }
3373
3374 if (rule_len_out > PW_MAX)
3375 {
3376 continue;
3377 }
3378 }
3379 else
3380 {
3381 if (len > PW_MAX)
3382 {
3383 continue;
3384 }
3385 }
3386
3387 *out_buf = ptr;
3388 *out_len = len;
3389
3390 return;
3391 }
3392
3393 if (feof (fd))
3394 {
3395 fprintf (stderr, "bug!!\n");
3396
3397 return;
3398 }
3399
3400 load_segment (wl_data, fd);
3401
3402 get_next_word (wl_data, fd, out_buf, out_len);
3403 }
3404
3405 #ifdef _POSIX
3406 static uint64_t count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3407 #endif
3408
3409 #ifdef _WIN
3410 static uint64_t count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3411 #endif
3412 {
3413 hc_signal (NULL);
3414
3415 dictstat_t d;
3416
3417 d.cnt = 0;
3418
3419 #ifdef _POSIX
3420 fstat (fileno (fd), &d.stat);
3421 #endif
3422
3423 #ifdef _WIN
3424 _fstat64 (fileno (fd), &d.stat);
3425 #endif
3426
3427 d.stat.st_mode = 0;
3428 d.stat.st_nlink = 0;
3429 d.stat.st_uid = 0;
3430 d.stat.st_gid = 0;
3431 d.stat.st_rdev = 0;
3432 d.stat.st_atime = 0;
3433
3434 #ifdef _POSIX
3435 d.stat.st_blksize = 0;
3436 d.stat.st_blocks = 0;
3437 #endif
3438
3439 if (d.stat.st_size == 0) return 0;
3440
3441 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3442
3443 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3444 {
3445 if (d_cache)
3446 {
3447 uint64_t cnt = d_cache->cnt;
3448
3449 uint64_t keyspace = cnt;
3450
3451 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3452 {
3453 keyspace *= data.gpu_rules_cnt;
3454 }
3455 else if (data.attack_kern == ATTACK_KERN_COMBI)
3456 {
3457 keyspace *= data.combs_cnt;
3458 }
3459
3460 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);
3461 if (data.quiet == 0) log_info ("");
3462
3463 hc_signal (sigHandler_default);
3464
3465 return (keyspace);
3466 }
3467 }
3468
3469 time_t now = 0;
3470 time_t prev = 0;
3471
3472 uint64_t comp = 0;
3473 uint64_t cnt = 0;
3474 uint64_t cnt2 = 0;
3475
3476 while (!feof (fd))
3477 {
3478 load_segment (wl_data, fd);
3479
3480 comp += wl_data->cnt;
3481
3482 uint32_t i = 0;
3483
3484 while (i < wl_data->cnt)
3485 {
3486 uint32_t len;
3487 uint32_t off;
3488
3489 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3490
3491 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3492 {
3493 char rule_buf_out[BLOCK_SIZE];
3494
3495 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3496
3497 int rule_len_out = -1;
3498
3499 if (len < BLOCK_SIZE)
3500 {
3501 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3502 }
3503
3504 if (rule_len_out < 0)
3505 {
3506 len = PW_MAX1;
3507 }
3508 else
3509 {
3510 len = rule_len_out;
3511 }
3512 }
3513
3514 if (len < PW_MAX1)
3515 {
3516 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3517 {
3518 cnt += data.gpu_rules_cnt;
3519 }
3520 else if (data.attack_kern == ATTACK_KERN_COMBI)
3521 {
3522 cnt += data.combs_cnt;
3523 }
3524
3525 d.cnt++;
3526 }
3527
3528 i += off;
3529
3530 cnt2++;
3531 }
3532
3533 time (&now);
3534
3535 if ((now - prev) == 0) continue;
3536
3537 float percent = (float) comp / (float) d.stat.st_size;
3538
3539 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);
3540
3541 time (&prev);
3542 }
3543
3544 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);
3545 if (data.quiet == 0) log_info ("");
3546
3547 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3548
3549 hc_signal (sigHandler_default);
3550
3551 return (cnt);
3552 }
3553
3554 static uint get_gpu_vector_width (const uint hash_mode, const uint attack_mode, const uint attack_exec, const uint opti_type, const uint vliw)
3555 {
3556 uint gpu_vector_width = 0;
3557
3558 if ((attack_mode == ATTACK_MODE_BF) && (attack_exec == ATTACK_EXEC_ON_GPU) && (opti_type & OPTI_TYPE_SCALAR_MODE))
3559 {
3560 return VECT_SIZE_1;
3561 }
3562
3563 #ifdef _CUDA
3564 if ((attack_mode == ATTACK_MODE_STRAIGHT) && (attack_exec == ATTACK_EXEC_ON_GPU))
3565 {
3566 return VECT_SIZE_1;
3567 }
3568
3569 if (vliw == 1)
3570 {
3571 switch (hash_mode)
3572 {
3573 default: gpu_vector_width = VECT_SIZE_1; break;
3574 }
3575 }
3576 else if (vliw == 2)
3577 {
3578 switch (hash_mode)
3579 {
3580 case 0: gpu_vector_width = VECT_SIZE_4; break;
3581 case 10: gpu_vector_width = VECT_SIZE_4; break;
3582 case 11: gpu_vector_width = VECT_SIZE_4; break;
3583 case 12: gpu_vector_width = VECT_SIZE_4; break;
3584 case 20: gpu_vector_width = VECT_SIZE_4; break;
3585 case 21: gpu_vector_width = VECT_SIZE_4; break;
3586 case 22: gpu_vector_width = VECT_SIZE_4; break;
3587 case 23: gpu_vector_width = VECT_SIZE_4; break;
3588 case 30: gpu_vector_width = VECT_SIZE_4; break;
3589 case 40: gpu_vector_width = VECT_SIZE_4; break;
3590 case 50: gpu_vector_width = VECT_SIZE_4; break;
3591 case 60: gpu_vector_width = VECT_SIZE_4; break;
3592 case 100: gpu_vector_width = VECT_SIZE_4; break;
3593 case 101: gpu_vector_width = VECT_SIZE_4; break;
3594 case 110: gpu_vector_width = VECT_SIZE_4; break;
3595 case 111: gpu_vector_width = VECT_SIZE_4; break;
3596 case 112: gpu_vector_width = VECT_SIZE_4; break;
3597 case 120: gpu_vector_width = VECT_SIZE_4; break;
3598 case 121: gpu_vector_width = VECT_SIZE_4; break;
3599 case 122: gpu_vector_width = VECT_SIZE_4; break;
3600 case 124: gpu_vector_width = VECT_SIZE_4; break;
3601 case 130: gpu_vector_width = VECT_SIZE_4; break;
3602 case 131: gpu_vector_width = VECT_SIZE_4; break;
3603 case 132: gpu_vector_width = VECT_SIZE_4; break;
3604 case 133: gpu_vector_width = VECT_SIZE_4; break;
3605 case 140: gpu_vector_width = VECT_SIZE_4; break;
3606 case 141: gpu_vector_width = VECT_SIZE_4; break;
3607 case 150: gpu_vector_width = VECT_SIZE_4; break;
3608 case 160: gpu_vector_width = VECT_SIZE_4; break;
3609 case 190: gpu_vector_width = VECT_SIZE_4; break;
3610 case 200: gpu_vector_width = VECT_SIZE_4; break;
3611 case 400: gpu_vector_width = VECT_SIZE_2; break;
3612 case 500: gpu_vector_width = VECT_SIZE_2; break;
3613 case 501: gpu_vector_width = VECT_SIZE_2; break;
3614 case 900: gpu_vector_width = VECT_SIZE_4; break;
3615 case 1000: gpu_vector_width = VECT_SIZE_4; break;
3616 case 1100: gpu_vector_width = VECT_SIZE_4; break;
3617 case 2400: gpu_vector_width = VECT_SIZE_4; break;
3618 case 2410: gpu_vector_width = VECT_SIZE_4; break;
3619 case 2600: gpu_vector_width = VECT_SIZE_4; break;
3620 case 2611: gpu_vector_width = VECT_SIZE_4; break;
3621 case 2612: gpu_vector_width = VECT_SIZE_4; break;
3622 case 2711: gpu_vector_width = VECT_SIZE_4; break;
3623 case 2811: gpu_vector_width = VECT_SIZE_4; break;
3624 case 3710: gpu_vector_width = VECT_SIZE_4; break;
3625 case 3800: gpu_vector_width = VECT_SIZE_4; break;
3626 case 3711: gpu_vector_width = VECT_SIZE_4; break;
3627 case 4300: gpu_vector_width = VECT_SIZE_4; break;
3628 case 4800: gpu_vector_width = VECT_SIZE_4; break;
3629 case 4900: gpu_vector_width = VECT_SIZE_4; break;
3630 case 5100: gpu_vector_width = VECT_SIZE_4; break;
3631 case 9900: gpu_vector_width = VECT_SIZE_4; break;
3632 case 10200: gpu_vector_width = VECT_SIZE_4; break;
3633 case 11000: gpu_vector_width = VECT_SIZE_4; break;
3634 case 11500: gpu_vector_width = VECT_SIZE_4; break;
3635
3636 default: gpu_vector_width = VECT_SIZE_1; break;
3637 }
3638 }
3639 #endif
3640
3641 #ifdef _OCL
3642 if (vliw == 1)
3643 {
3644 switch (hash_mode)
3645 {
3646 default: gpu_vector_width = VECT_SIZE_1; break;
3647 }
3648 }
3649 else if (vliw == 4)
3650 {
3651 switch (hash_mode)
3652 {
3653 case 150: gpu_vector_width = VECT_SIZE_2; break;
3654 case 160: gpu_vector_width = VECT_SIZE_2; break;
3655 case 300: gpu_vector_width = VECT_SIZE_2; break;
3656 case 1400: gpu_vector_width = VECT_SIZE_2; break;
3657 case 1410: gpu_vector_width = VECT_SIZE_2; break;
3658 case 1420: gpu_vector_width = VECT_SIZE_2; break;
3659 case 1421: gpu_vector_width = VECT_SIZE_2; break;
3660 case 1430: gpu_vector_width = VECT_SIZE_2; break;
3661 case 1440: gpu_vector_width = VECT_SIZE_2; break;
3662 case 1441: gpu_vector_width = VECT_SIZE_2; break;
3663 case 1450: gpu_vector_width = VECT_SIZE_1; break;
3664 case 1460: gpu_vector_width = VECT_SIZE_2; break;
3665 case 1500: gpu_vector_width = VECT_SIZE_1; break;
3666 case 1700: gpu_vector_width = VECT_SIZE_1; break;
3667 case 1710: gpu_vector_width = VECT_SIZE_1; break;
3668 case 1711: gpu_vector_width = VECT_SIZE_1; break;
3669 case 1720: gpu_vector_width = VECT_SIZE_1; break;
3670 case 1722: gpu_vector_width = VECT_SIZE_1; break;
3671 case 1730: gpu_vector_width = VECT_SIZE_1; break;
3672 case 1731: gpu_vector_width = VECT_SIZE_1; break;
3673 case 1740: gpu_vector_width = VECT_SIZE_1; break;
3674 case 1750: gpu_vector_width = VECT_SIZE_1; break;
3675 case 1760: gpu_vector_width = VECT_SIZE_1; break;
3676 case 1800: gpu_vector_width = VECT_SIZE_1; break;
3677 case 2100: gpu_vector_width = VECT_SIZE_2; break;
3678 case 2500: gpu_vector_width = VECT_SIZE_2; break;
3679 case 3000: gpu_vector_width = VECT_SIZE_1; break;
3680 case 3100: gpu_vector_width = VECT_SIZE_2; break;
3681 case 3200: gpu_vector_width = VECT_SIZE_1; break;
3682 case 5000: gpu_vector_width = VECT_SIZE_1; break;
3683 case 5200: gpu_vector_width = VECT_SIZE_2; break;
3684 case 5600: gpu_vector_width = VECT_SIZE_2; break;
3685 case 5700: gpu_vector_width = VECT_SIZE_2; break;
3686 case 6100: gpu_vector_width = VECT_SIZE_2; break;
3687 case 6211:
3688 case 6212:
3689 case 6213:
3690 case 6221:
3691 case 6222:
3692 case 6223:
3693 case 6231:
3694 case 6232:
3695 case 6233:
3696 case 6241:
3697 case 6242:
3698 case 6243: gpu_vector_width = VECT_SIZE_1; break;
3699 case 6400: gpu_vector_width = VECT_SIZE_1; break;
3700 case 6500: gpu_vector_width = VECT_SIZE_1; break;
3701 case 6600: gpu_vector_width = VECT_SIZE_1; break;
3702 case 6700: gpu_vector_width = VECT_SIZE_2; break;
3703 case 6800: gpu_vector_width = VECT_SIZE_1; break;
3704 case 6900: gpu_vector_width = VECT_SIZE_1; break;
3705 case 7100: gpu_vector_width = VECT_SIZE_1; break;
3706 case 7200: gpu_vector_width = VECT_SIZE_1; break;
3707 case 7300: gpu_vector_width = VECT_SIZE_1; break;
3708 case 7400: gpu_vector_width = VECT_SIZE_1; break;
3709 case 7500: gpu_vector_width = VECT_SIZE_1; break;
3710 case 7700: gpu_vector_width = VECT_SIZE_1; break;
3711 case 7800: gpu_vector_width = VECT_SIZE_1; break;
3712 case 7900: gpu_vector_width = VECT_SIZE_1; break;
3713 case 8000: gpu_vector_width = VECT_SIZE_2; break;
3714 case 8200: gpu_vector_width = VECT_SIZE_1; break;
3715 case 8500: gpu_vector_width = VECT_SIZE_2; break;
3716 case 8700: gpu_vector_width = VECT_SIZE_2; break;
3717 case 8800: gpu_vector_width = VECT_SIZE_1; break;
3718 case 8900: gpu_vector_width = VECT_SIZE_1; break;
3719 case 9000: gpu_vector_width = VECT_SIZE_1; break;
3720 case 9100: gpu_vector_width = VECT_SIZE_1; break;
3721 case 9200: gpu_vector_width = VECT_SIZE_1; break;
3722 case 9300: gpu_vector_width = VECT_SIZE_1; break;
3723 case 9400: gpu_vector_width = VECT_SIZE_1; break;
3724 case 9500: gpu_vector_width = VECT_SIZE_1; break;
3725 case 9600: gpu_vector_width = VECT_SIZE_1; break;
3726 case 9700: gpu_vector_width = VECT_SIZE_1; break;
3727 case 9710: gpu_vector_width = VECT_SIZE_1; break;
3728 case 9720: gpu_vector_width = VECT_SIZE_2; break;
3729 case 9800: gpu_vector_width = VECT_SIZE_1; break;
3730 case 9810: gpu_vector_width = VECT_SIZE_1; break;
3731 case 9820: gpu_vector_width = VECT_SIZE_2; break;
3732 case 10000: gpu_vector_width = VECT_SIZE_1; break;
3733 case 10100: gpu_vector_width = VECT_SIZE_1; break;
3734 case 10400: gpu_vector_width = VECT_SIZE_1; break;
3735 case 10410: gpu_vector_width = VECT_SIZE_1; break;
3736 case 10420: gpu_vector_width = VECT_SIZE_2; break;
3737 case 10500: gpu_vector_width = VECT_SIZE_1; break;
3738 case 10600: gpu_vector_width = VECT_SIZE_2; break;
3739 case 10700: gpu_vector_width = VECT_SIZE_1; break;
3740 case 10800: gpu_vector_width = VECT_SIZE_1; break;
3741 case 10900: gpu_vector_width = VECT_SIZE_1; break;
3742 case 11100: gpu_vector_width = VECT_SIZE_2; break;
3743 case 11200: gpu_vector_width = VECT_SIZE_2; break;
3744 case 11300: gpu_vector_width = VECT_SIZE_1; break;
3745 case 11400: gpu_vector_width = VECT_SIZE_1; break;
3746 case 11600: gpu_vector_width = VECT_SIZE_1; break;
3747 case 11700: gpu_vector_width = VECT_SIZE_1; break;
3748 case 11800: gpu_vector_width = VECT_SIZE_1; break;
3749 case 11900: gpu_vector_width = VECT_SIZE_1; break;
3750 case 12000: gpu_vector_width = VECT_SIZE_1; break;
3751 case 12100: gpu_vector_width = VECT_SIZE_1; break;
3752 case 12200: gpu_vector_width = VECT_SIZE_1; break;
3753 case 12300: gpu_vector_width = VECT_SIZE_1; break;
3754 case 12500: gpu_vector_width = VECT_SIZE_1; break;
3755 case 12700: gpu_vector_width = VECT_SIZE_1; break;
3756 case 12800: gpu_vector_width = VECT_SIZE_1; break;
3757
3758 default: gpu_vector_width = VECT_SIZE_4; break;
3759 }
3760 }
3761 else if (vliw == 5)
3762 {
3763 switch (hash_mode)
3764 {
3765 case 150: gpu_vector_width = VECT_SIZE_2; break;
3766 case 160: gpu_vector_width = VECT_SIZE_2; break;
3767 case 300: gpu_vector_width = VECT_SIZE_2; break;
3768 case 1400: gpu_vector_width = VECT_SIZE_2; break;
3769 case 1410: gpu_vector_width = VECT_SIZE_2; break;
3770 case 1420: gpu_vector_width = VECT_SIZE_2; break;
3771 case 1421: gpu_vector_width = VECT_SIZE_2; break;
3772 case 1430: gpu_vector_width = VECT_SIZE_2; break;
3773 case 1440: gpu_vector_width = VECT_SIZE_2; break;
3774 case 1441: gpu_vector_width = VECT_SIZE_2; break;
3775 case 1450: gpu_vector_width = VECT_SIZE_1; break;
3776 case 1460: gpu_vector_width = VECT_SIZE_2; break;
3777 case 1500: gpu_vector_width = VECT_SIZE_1; break;
3778 case 1700: gpu_vector_width = VECT_SIZE_1; break;
3779 case 1710: gpu_vector_width = VECT_SIZE_1; break;
3780 case 1711: gpu_vector_width = VECT_SIZE_1; break;
3781 case 1720: gpu_vector_width = VECT_SIZE_1; break;
3782 case 1722: gpu_vector_width = VECT_SIZE_1; break;
3783 case 1730: gpu_vector_width = VECT_SIZE_1; break;
3784 case 1731: gpu_vector_width = VECT_SIZE_1; break;
3785 case 1740: gpu_vector_width = VECT_SIZE_1; break;
3786 case 1750: gpu_vector_width = VECT_SIZE_1; break;
3787 case 1760: gpu_vector_width = VECT_SIZE_1; break;
3788 case 1800: gpu_vector_width = VECT_SIZE_1; break;
3789 case 2100: gpu_vector_width = VECT_SIZE_2; break;
3790 case 2500: gpu_vector_width = VECT_SIZE_2; break;
3791 case 3000: gpu_vector_width = VECT_SIZE_1; break;
3792 case 3100: gpu_vector_width = VECT_SIZE_2; break;
3793 case 3200: gpu_vector_width = VECT_SIZE_1; break;
3794 case 5000: gpu_vector_width = VECT_SIZE_1; break;
3795 case 5200: gpu_vector_width = VECT_SIZE_2; break;
3796 case 5400: gpu_vector_width = VECT_SIZE_2; break;
3797 case 5600: gpu_vector_width = VECT_SIZE_2; break;
3798 case 5700: gpu_vector_width = VECT_SIZE_2; break;
3799 case 6100: gpu_vector_width = VECT_SIZE_2; break;
3800 case 6211:
3801 case 6212:
3802 case 6213:
3803 case 6221:
3804 case 6222:
3805 case 6223:
3806 case 6231:
3807 case 6232:
3808 case 6233:
3809 case 6241:
3810 case 6242:
3811 case 6243: gpu_vector_width = VECT_SIZE_1; break;
3812 case 6400: gpu_vector_width = VECT_SIZE_1; break;
3813 case 6500: gpu_vector_width = VECT_SIZE_1; break;
3814 case 6600: gpu_vector_width = VECT_SIZE_1; break;
3815 case 6700: gpu_vector_width = VECT_SIZE_2; break;
3816 case 6800: gpu_vector_width = VECT_SIZE_1; break;
3817 case 6900: gpu_vector_width = VECT_SIZE_1; break;
3818 case 7100: gpu_vector_width = VECT_SIZE_1; break;
3819 case 7200: gpu_vector_width = VECT_SIZE_1; break;
3820 case 7300: gpu_vector_width = VECT_SIZE_1; break;
3821 case 7400: gpu_vector_width = VECT_SIZE_1; break;
3822 case 7500: gpu_vector_width = VECT_SIZE_1; break;
3823 case 7700: gpu_vector_width = VECT_SIZE_1; break;
3824 case 7800: gpu_vector_width = VECT_SIZE_1; break;
3825 case 7900: gpu_vector_width = VECT_SIZE_1; break;
3826 case 8000: gpu_vector_width = VECT_SIZE_2; break;
3827 case 8200: gpu_vector_width = VECT_SIZE_1; break;
3828 case 8300: gpu_vector_width = VECT_SIZE_2; break;
3829 case 8400: gpu_vector_width = VECT_SIZE_2; break;
3830 case 8500: gpu_vector_width = VECT_SIZE_2; break;
3831 case 8700: gpu_vector_width = VECT_SIZE_2; break;
3832 case 8800: gpu_vector_width = VECT_SIZE_1; break;
3833 case 8900: gpu_vector_width = VECT_SIZE_1; break;
3834 case 9000: gpu_vector_width = VECT_SIZE_1; break;
3835 case 9100: gpu_vector_width = VECT_SIZE_1; break;
3836 case 9200: gpu_vector_width = VECT_SIZE_1; break;
3837 case 9300: gpu_vector_width = VECT_SIZE_1; break;
3838 case 9400: gpu_vector_width = VECT_SIZE_1; break;
3839 case 9500: gpu_vector_width = VECT_SIZE_1; break;
3840 case 9600: gpu_vector_width = VECT_SIZE_1; break;
3841 case 9700: gpu_vector_width = VECT_SIZE_1; break;
3842 case 9710: gpu_vector_width = VECT_SIZE_1; break;
3843 case 9720: gpu_vector_width = VECT_SIZE_2; break;
3844 case 9800: gpu_vector_width = VECT_SIZE_1; break;
3845 case 9810: gpu_vector_width = VECT_SIZE_1; break;
3846 case 9820: gpu_vector_width = VECT_SIZE_2; break;
3847 case 10000: gpu_vector_width = VECT_SIZE_1; break;
3848 case 10100: gpu_vector_width = VECT_SIZE_1; break;
3849 case 10400: gpu_vector_width = VECT_SIZE_1; break;
3850 case 10410: gpu_vector_width = VECT_SIZE_1; break;
3851 case 10420: gpu_vector_width = VECT_SIZE_2; break;
3852 case 10500: gpu_vector_width = VECT_SIZE_1; break;
3853 case 10600: gpu_vector_width = VECT_SIZE_2; break;
3854 case 10700: gpu_vector_width = VECT_SIZE_1; break;
3855 case 10800: gpu_vector_width = VECT_SIZE_1; break;
3856 case 10900: gpu_vector_width = VECT_SIZE_1; break;
3857 case 11100: gpu_vector_width = VECT_SIZE_2; break;
3858 case 11200: gpu_vector_width = VECT_SIZE_2; break;
3859 case 11300: gpu_vector_width = VECT_SIZE_1; break;
3860 case 11400: gpu_vector_width = VECT_SIZE_1; break;
3861 case 11600: gpu_vector_width = VECT_SIZE_1; break;
3862 case 11700: gpu_vector_width = VECT_SIZE_1; break;
3863 case 11800: gpu_vector_width = VECT_SIZE_1; break;
3864 case 11900: gpu_vector_width = VECT_SIZE_1; break;
3865 case 12000: gpu_vector_width = VECT_SIZE_1; break;
3866 case 12100: gpu_vector_width = VECT_SIZE_1; break;
3867 case 12200: gpu_vector_width = VECT_SIZE_1; break;
3868 case 12300: gpu_vector_width = VECT_SIZE_1; break;
3869 case 12500: gpu_vector_width = VECT_SIZE_1; break;
3870 case 12700: gpu_vector_width = VECT_SIZE_1; break;
3871 case 12800: gpu_vector_width = VECT_SIZE_1; break;
3872
3873 default: gpu_vector_width = VECT_SIZE_4; break;
3874 }
3875 }
3876 #endif
3877
3878 return gpu_vector_width;
3879 }
3880
3881 static void pw_transpose_to_hi1 (const pw_t *p1, pw_t *p2)
3882 {
3883 memcpy (p2->hi1, p1->hi1, 64 * sizeof (uint));
3884 }
3885
3886 static void pw_transpose_to_hi2 (const pw_t *p1, pw_t *p2)
3887 {
3888 p2->hi2[0][ 0] = p1->hi2[0][ 0];
3889 p2->hi2[0][ 2] = p1->hi2[0][ 1];
3890 p2->hi2[0][ 4] = p1->hi2[0][ 2];
3891 p2->hi2[0][ 6] = p1->hi2[0][ 3];
3892 p2->hi2[0][ 8] = p1->hi2[0][ 4];
3893 p2->hi2[0][10] = p1->hi2[0][ 5];
3894 p2->hi2[0][12] = p1->hi2[0][ 6];
3895 p2->hi2[0][14] = p1->hi2[0][ 7];
3896 p2->hi2[0][16] = p1->hi2[0][ 8];
3897 p2->hi2[0][18] = p1->hi2[0][ 9];
3898 p2->hi2[0][20] = p1->hi2[0][10];
3899 p2->hi2[0][22] = p1->hi2[0][11];
3900 p2->hi2[0][24] = p1->hi2[0][12];
3901 p2->hi2[0][26] = p1->hi2[0][13];
3902 p2->hi2[0][28] = p1->hi2[0][14];
3903 p2->hi2[0][30] = p1->hi2[0][15];
3904 p2->hi2[1][ 0] = p1->hi2[0][16];
3905 p2->hi2[1][ 2] = p1->hi2[0][17];
3906 p2->hi2[1][ 4] = p1->hi2[0][18];
3907 p2->hi2[1][ 6] = p1->hi2[0][19];
3908 p2->hi2[1][ 8] = p1->hi2[0][20];
3909 p2->hi2[1][10] = p1->hi2[0][21];
3910 p2->hi2[1][12] = p1->hi2[0][22];
3911 p2->hi2[1][14] = p1->hi2[0][23];
3912 p2->hi2[1][16] = p1->hi2[0][24];
3913 p2->hi2[1][18] = p1->hi2[0][25];
3914 p2->hi2[1][20] = p1->hi2[0][26];
3915 p2->hi2[1][22] = p1->hi2[0][27];
3916 p2->hi2[1][24] = p1->hi2[0][28];
3917 p2->hi2[1][26] = p1->hi2[0][29];
3918 p2->hi2[1][28] = p1->hi2[0][30];
3919 p2->hi2[1][30] = p1->hi2[0][31];
3920
3921 p2->hi2[0][ 1] = p1->hi2[1][ 0];
3922 p2->hi2[0][ 3] = p1->hi2[1][ 1];
3923 p2->hi2[0][ 5] = p1->hi2[1][ 2];
3924 p2->hi2[0][ 7] = p1->hi2[1][ 3];
3925 p2->hi2[0][ 9] = p1->hi2[1][ 4];
3926 p2->hi2[0][11] = p1->hi2[1][ 5];
3927 p2->hi2[0][13] = p1->hi2[1][ 6];
3928 p2->hi2[0][15] = p1->hi2[1][ 7];
3929 p2->hi2[0][17] = p1->hi2[1][ 8];
3930 p2->hi2[0][19] = p1->hi2[1][ 9];
3931 p2->hi2[0][21] = p1->hi2[1][10];
3932 p2->hi2[0][23] = p1->hi2[1][11];
3933 p2->hi2[0][25] = p1->hi2[1][12];
3934 p2->hi2[0][27] = p1->hi2[1][13];
3935 p2->hi2[0][29] = p1->hi2[1][14];
3936 p2->hi2[0][31] = p1->hi2[1][15];
3937 p2->hi2[1][ 1] = p1->hi2[1][16];
3938 p2->hi2[1][ 3] = p1->hi2[1][17];
3939 p2->hi2[1][ 5] = p1->hi2[1][18];
3940 p2->hi2[1][ 7] = p1->hi2[1][19];
3941 p2->hi2[1][ 9] = p1->hi2[1][20];
3942 p2->hi2[1][11] = p1->hi2[1][21];
3943 p2->hi2[1][13] = p1->hi2[1][22];
3944 p2->hi2[1][15] = p1->hi2[1][23];
3945 p2->hi2[1][17] = p1->hi2[1][24];
3946 p2->hi2[1][19] = p1->hi2[1][25];
3947 p2->hi2[1][21] = p1->hi2[1][26];
3948 p2->hi2[1][23] = p1->hi2[1][27];
3949 p2->hi2[1][25] = p1->hi2[1][28];
3950 p2->hi2[1][27] = p1->hi2[1][29];
3951 p2->hi2[1][29] = p1->hi2[1][30];
3952 p2->hi2[1][31] = p1->hi2[1][31];
3953 }
3954
3955 static void pw_transpose_to_hi4 (const pw_t *p1, pw_t *p2)
3956 {
3957 p2->hi4[0][ 0] = p1->hi4[0][ 0];
3958 p2->hi4[0][ 4] = p1->hi4[0][ 1];
3959 p2->hi4[0][ 8] = p1->hi4[0][ 2];
3960 p2->hi4[0][12] = p1->hi4[0][ 3];
3961 p2->hi4[1][ 0] = p1->hi4[0][ 4];
3962 p2->hi4[1][ 4] = p1->hi4[0][ 5];
3963 p2->hi4[1][ 8] = p1->hi4[0][ 6];
3964 p2->hi4[1][12] = p1->hi4[0][ 7];
3965 p2->hi4[2][ 0] = p1->hi4[0][ 8];
3966 p2->hi4[2][ 4] = p1->hi4[0][ 9];
3967 p2->hi4[2][ 8] = p1->hi4[0][10];
3968 p2->hi4[2][12] = p1->hi4[0][11];
3969 p2->hi4[3][ 0] = p1->hi4[0][12];
3970 p2->hi4[3][ 4] = p1->hi4[0][13];
3971 p2->hi4[3][ 8] = p1->hi4[0][14];
3972 p2->hi4[3][12] = p1->hi4[0][15];
3973
3974 p2->hi4[0][ 1] = p1->hi4[1][ 0];
3975 p2->hi4[0][ 5] = p1->hi4[1][ 1];
3976 p2->hi4[0][ 9] = p1->hi4[1][ 2];
3977 p2->hi4[0][13] = p1->hi4[1][ 3];
3978 p2->hi4[1][ 1] = p1->hi4[1][ 4];
3979 p2->hi4[1][ 5] = p1->hi4[1][ 5];
3980 p2->hi4[1][ 9] = p1->hi4[1][ 6];
3981 p2->hi4[1][13] = p1->hi4[1][ 7];
3982 p2->hi4[2][ 1] = p1->hi4[1][ 8];
3983 p2->hi4[2][ 5] = p1->hi4[1][ 9];
3984 p2->hi4[2][ 9] = p1->hi4[1][10];
3985 p2->hi4[2][13] = p1->hi4[1][11];
3986 p2->hi4[3][ 1] = p1->hi4[1][12];
3987 p2->hi4[3][ 5] = p1->hi4[1][13];
3988 p2->hi4[3][ 9] = p1->hi4[1][14];
3989 p2->hi4[3][13] = p1->hi4[1][15];
3990
3991 p2->hi4[0][ 2] = p1->hi4[2][ 0];
3992 p2->hi4[0][ 6] = p1->hi4[2][ 1];
3993 p2->hi4[0][10] = p1->hi4[2][ 2];
3994 p2->hi4[0][14] = p1->hi4[2][ 3];
3995 p2->hi4[1][ 2] = p1->hi4[2][ 4];
3996 p2->hi4[1][ 6] = p1->hi4[2][ 5];
3997 p2->hi4[1][10] = p1->hi4[2][ 6];
3998 p2->hi4[1][14] = p1->hi4[2][ 7];
3999 p2->hi4[2][ 2] = p1->hi4[2][ 8];
4000 p2->hi4[2][ 6] = p1->hi4[2][ 9];
4001 p2->hi4[2][10] = p1->hi4[2][10];
4002 p2->hi4[2][14] = p1->hi4[2][11];
4003 p2->hi4[3][ 2] = p1->hi4[2][12];
4004 p2->hi4[3][ 6] = p1->hi4[2][13];
4005 p2->hi4[3][10] = p1->hi4[2][14];
4006 p2->hi4[3][14] = p1->hi4[2][15];
4007
4008 p2->hi4[0][ 3] = p1->hi4[3][ 0];
4009 p2->hi4[0][ 7] = p1->hi4[3][ 1];
4010 p2->hi4[0][11] = p1->hi4[3][ 2];
4011 p2->hi4[0][15] = p1->hi4[3][ 3];
4012 p2->hi4[1][ 3] = p1->hi4[3][ 4];
4013 p2->hi4[1][ 7] = p1->hi4[3][ 5];
4014 p2->hi4[1][11] = p1->hi4[3][ 6];
4015 p2->hi4[1][15] = p1->hi4[3][ 7];
4016 p2->hi4[2][ 3] = p1->hi4[3][ 8];
4017 p2->hi4[2][ 7] = p1->hi4[3][ 9];
4018 p2->hi4[2][11] = p1->hi4[3][10];
4019 p2->hi4[2][15] = p1->hi4[3][11];
4020 p2->hi4[3][ 3] = p1->hi4[3][12];
4021 p2->hi4[3][ 7] = p1->hi4[3][13];
4022 p2->hi4[3][11] = p1->hi4[3][14];
4023 p2->hi4[3][15] = p1->hi4[3][15];
4024 }
4025
4026 static uint pw_add_to_hc1 (hc_device_param_t *device_param, const uint8_t *pw_buf, const uint pw_len)
4027 {
4028 if (data.devices_status == STATUS_BYPASS) return 0;
4029
4030 pw_cache_t *pw_cache = device_param->pw_caches + pw_len;
4031
4032 uint cache_cnt = pw_cache->cnt;
4033
4034 uint8_t *pw_hc1 = pw_cache->pw_buf.hc1[cache_cnt];
4035
4036 memcpy (pw_hc1, pw_buf, pw_len);
4037
4038 memset (pw_hc1 + pw_len, 0, 256 - pw_len);
4039
4040 uint pws_cnt = device_param->pws_cnt;
4041
4042 cache_cnt++;
4043
4044 if (cache_cnt == VECT_SIZE_1)
4045 {
4046 pw_t *pw = device_param->pws_buf + pws_cnt;
4047
4048 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4049
4050 pw->pw_len = pw_len;
4051
4052 pws_cnt++;
4053
4054 device_param->pws_cnt = pws_cnt;
4055 device_param->pw_cnt = pws_cnt * 1;
4056
4057 cache_cnt = 0;
4058 }
4059
4060 pw_cache->cnt = cache_cnt;
4061
4062 return pws_cnt;
4063 }
4064
4065 static uint pw_add_to_hc2 (hc_device_param_t *device_param, const uint8_t *pw_buf, const uint pw_len)
4066 {
4067 if (data.devices_status == STATUS_BYPASS) return 0;
4068
4069 pw_cache_t *pw_cache = device_param->pw_caches + pw_len;
4070
4071 uint cache_cnt = pw_cache->cnt;
4072
4073 uint8_t *pw_hc2 = pw_cache->pw_buf.hc2[cache_cnt];
4074
4075 memcpy (pw_hc2, pw_buf, pw_len);
4076
4077 memset (pw_hc2 + pw_len, 0, 128 - pw_len);
4078
4079 uint pws_cnt = device_param->pws_cnt;
4080
4081 cache_cnt++;
4082
4083 if (cache_cnt == VECT_SIZE_2)
4084 {
4085 pw_t *pw = device_param->pws_buf + pws_cnt;
4086
4087 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4088
4089 pw->pw_len = pw_len;
4090
4091 pws_cnt++;
4092
4093 device_param->pws_cnt = pws_cnt;
4094 device_param->pw_cnt = pws_cnt * 2;
4095
4096 cache_cnt = 0;
4097 }
4098
4099 pw_cache->cnt = cache_cnt;
4100
4101 return pws_cnt;
4102 }
4103
4104 static uint pw_add_to_hc4 (hc_device_param_t *device_param, const uint8_t *pw_buf, const uint pw_len)
4105 {
4106 if (data.devices_status == STATUS_BYPASS) return 0;
4107
4108 pw_cache_t *pw_cache = device_param->pw_caches + pw_len;
4109
4110 uint cache_cnt = pw_cache->cnt;
4111
4112 uint8_t *pw_hc4 = pw_cache->pw_buf.hc4[cache_cnt];
4113
4114 memcpy (pw_hc4, pw_buf, pw_len);
4115
4116 memset (pw_hc4 + pw_len, 0, 64 - pw_len);
4117
4118 uint pws_cnt = device_param->pws_cnt;
4119
4120 cache_cnt++;
4121
4122 if (cache_cnt == VECT_SIZE_4)
4123 {
4124 pw_t *pw = device_param->pws_buf + pws_cnt;
4125
4126 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4127
4128 pw->pw_len = pw_len;
4129
4130 pws_cnt++;
4131
4132 device_param->pws_cnt = pws_cnt;
4133 device_param->pw_cnt = pws_cnt * 4;
4134
4135 cache_cnt = 0;
4136 }
4137
4138 pw_cache->cnt = cache_cnt;
4139
4140 return pws_cnt;
4141 }
4142
4143 static void *thread_monitor (void *p)
4144 {
4145 uint runtime_check = 0;
4146 uint remove_check = 0;
4147 uint status_check = 0;
4148 uint hwmon_check = 0;
4149 uint restore_check = 0;
4150
4151 uint restore_left = data.restore_timer;
4152 uint remove_left = data.remove_timer;
4153 uint status_left = data.status_timer;
4154
4155 #ifdef _OCL
4156 #ifndef OSX
4157
4158 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
4159
4160 // temperature controller "loopback" values
4161
4162 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
4163 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
4164
4165 int temp_threshold = 1; // degrees celcius
4166
4167 int fan_speed_min = 15; // in percentage
4168 int fan_speed_max = 100;
4169
4170 time_t last_temp_check_time;
4171
4172 #endif
4173 #endif
4174
4175 uint sleep_time = 1;
4176
4177 if (data.runtime)
4178 runtime_check = 1;
4179
4180 if (data.restore_timer)
4181 restore_check = 1;
4182
4183 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
4184 remove_check = 1;
4185
4186 if (data.status == 1)
4187 status_check = 1;
4188
4189 if (data.gpu_temp_disable == 0)
4190 {
4191 #ifdef _OCL
4192 #ifndef OSX
4193 time (&last_temp_check_time);
4194 #endif
4195 #endif
4196
4197 hwmon_check = 1;
4198 }
4199
4200 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (hwmon_check == 0) && (restore_check == 0))
4201 {
4202 return (p);
4203 }
4204
4205 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4206 {
4207 hc_sleep (sleep_time);
4208
4209 if (data.devices_status != STATUS_RUNNING) continue;
4210
4211 if (hwmon_check == 1)
4212 {
4213 hc_thread_mutex_lock (mux_adl);
4214
4215 #ifdef _OCL
4216 #ifndef OSX
4217
4218 time_t temp_check_time;
4219
4220 time (&temp_check_time);
4221
4222 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
4223
4224 if (Ta == 0) Ta = 1;
4225
4226 #endif
4227 #endif
4228
4229 for (uint i = 0; i < data.devices_cnt; i++)
4230 {
4231 const int temperature = hm_get_temperature_with_device_id (i);
4232
4233 if (temperature > (int) data.gpu_temp_abort)
4234 {
4235 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", i + 1);
4236
4237 if (data.devices_status != STATUS_QUIT) myabort ();
4238
4239 break;
4240 }
4241
4242 #ifdef _OCL
4243 #ifndef OSX
4244
4245 const int gpu_temp_retain = data.gpu_temp_retain;
4246
4247 if (gpu_temp_retain)
4248 {
4249 if (data.hm_device[i].fan_supported == 1)
4250 {
4251 int temp_cur = temperature;
4252
4253 int temp_diff_new = gpu_temp_retain - temp_cur;
4254
4255 temp_diff_sum[i] = temp_diff_sum[i] + temp_diff_new;
4256
4257 // calculate Ta value (time difference in seconds between the last check and this check)
4258
4259 last_temp_check_time = temp_check_time;
4260
4261 float Kp = 1.8;
4262 float Ki = 0.005;
4263 float Kd = 6;
4264
4265 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
4266
4267 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);
4268
4269 if (abs (fan_diff_required) >= temp_threshold)
4270 {
4271 const int fan_speed_cur = hm_get_fanspeed_with_device_id (i);
4272
4273 int fan_speed_level = fan_speed_cur;
4274
4275 if (fan_speed_chgd[i] == 0) fan_speed_level = temp_cur;
4276
4277 int fan_speed_new = fan_speed_level - fan_diff_required;
4278
4279 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
4280 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
4281
4282 if (fan_speed_new != fan_speed_cur)
4283 {
4284 int freely_change_fan_speed = (fan_speed_chgd[i] == 1);
4285 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
4286
4287 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
4288 {
4289 hm_set_fanspeed_with_device_id (i, fan_speed_new);
4290
4291 fan_speed_chgd[i] = 1;
4292 }
4293
4294 temp_diff_old[i] = temp_diff_new;
4295 }
4296 }
4297 }
4298 }
4299
4300 #endif
4301 #endif
4302 }
4303
4304 hc_thread_mutex_unlock (mux_adl);
4305 }
4306
4307 if (restore_check == 1)
4308 {
4309 restore_left--;
4310
4311 if (restore_left == 0)
4312 {
4313 if (data.restore_disable == 0) cycle_restore ();
4314
4315 restore_left = data.restore_timer;
4316 }
4317 }
4318
4319 if ((runtime_check == 1) && (data.runtime_start > 0))
4320 {
4321 time_t runtime_cur;
4322
4323 time (&runtime_cur);
4324
4325 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
4326
4327 if (runtime_left <= 0)
4328 {
4329 if (data.benchmark == 0)
4330 {
4331 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
4332 }
4333
4334 if (data.devices_status != STATUS_QUIT) myabort ();
4335 }
4336 }
4337
4338 if (remove_check == 1)
4339 {
4340 remove_left--;
4341
4342 if (remove_left == 0)
4343 {
4344 if (data.digests_saved != data.digests_done)
4345 {
4346 data.digests_saved = data.digests_done;
4347
4348 save_hash ();
4349 }
4350
4351 remove_left = data.remove_timer;
4352 }
4353 }
4354
4355 if (status_check == 1)
4356 {
4357 status_left--;
4358
4359 if (status_left == 0)
4360 {
4361 hc_thread_mutex_lock (mux_display);
4362
4363 if (data.quiet == 0) clear_prompt ();
4364
4365 if (data.quiet == 0) log_info ("");
4366
4367 status_display ();
4368
4369 if (data.quiet == 0) log_info ("");
4370
4371 hc_thread_mutex_unlock (mux_display);
4372
4373 status_left = data.status_timer;
4374 }
4375 }
4376 }
4377
4378 #ifdef _OCL
4379 #ifndef OSX
4380 myfree (fan_speed_chgd);
4381
4382 myfree (temp_diff_old);
4383 myfree (temp_diff_sum);
4384 #endif
4385 #endif
4386
4387 p = NULL;
4388
4389 return (p);
4390 }
4391
4392 static void *thread_outfile_remove (void *p)
4393 {
4394 // some hash-dependent constants
4395 char *outfile_dir = data.outfile_check_directory;
4396 uint dgst_size = data.dgst_size;
4397 uint isSalted = data.isSalted;
4398 uint esalt_size = data.esalt_size;
4399 uint hash_mode = data.hash_mode;
4400
4401 uint outfile_check_timer = data.outfile_check_timer;
4402
4403 char separator = data.separator;
4404
4405 // some hash-dependent functions
4406 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4407 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4408
4409 // buffers
4410 hash_t hash_buf;
4411
4412 memset (&hash_buf, 0, sizeof (hash_buf));
4413
4414 hash_buf.digest = mymalloc (dgst_size);
4415
4416 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4417
4418 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4419
4420 uint digest_buf[64];
4421
4422 outfile_data_t *out_info = NULL;
4423
4424 char **out_files = NULL;
4425
4426 time_t folder_mtime = 0;
4427
4428 int out_cnt = 0;
4429
4430 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4431
4432 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4433 {
4434 hc_sleep (1);
4435
4436 if (data.devices_status != STATUS_RUNNING) continue;
4437
4438 check_left--;
4439
4440 if (check_left == 0)
4441 {
4442 struct stat outfile_check_stat;
4443
4444 if (stat (outfile_dir, &outfile_check_stat) == 0)
4445 {
4446 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4447
4448 if (is_dir == 1)
4449 {
4450 if (outfile_check_stat.st_mtime > folder_mtime)
4451 {
4452 char **out_files_new = scan_directory (outfile_dir);
4453
4454 int out_cnt_new = count_dictionaries (out_files_new);
4455
4456 outfile_data_t *out_info_new = NULL;
4457
4458 if (out_cnt_new > 0)
4459 {
4460 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4461
4462 for (int i = 0; i < out_cnt_new; i++)
4463 {
4464 out_info_new[i].file_name = out_files_new[i];
4465
4466 // check if there are files that we have seen/checked before (and not changed)
4467
4468 for (int j = 0; j < out_cnt; j++)
4469 {
4470 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4471 {
4472 struct stat outfile_stat;
4473
4474 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4475 {
4476 if (outfile_stat.st_ctime == out_info[j].ctime)
4477 {
4478 out_info_new[i].ctime = out_info[j].ctime;
4479 out_info_new[i].seek = out_info[j].seek;
4480 }
4481 }
4482 }
4483 }
4484 }
4485 }
4486
4487 local_free (out_info);
4488 local_free (out_files);
4489
4490 out_files = out_files_new;
4491 out_cnt = out_cnt_new;
4492 out_info = out_info_new;
4493
4494 folder_mtime = outfile_check_stat.st_mtime;
4495 }
4496
4497 for (int j = 0; j < out_cnt; j++)
4498 {
4499 FILE *fp = fopen (out_info[j].file_name, "rb");
4500
4501 if (fp != NULL)
4502 {
4503 //hc_thread_mutex_lock (mux_display);
4504
4505 #ifdef _POSIX
4506 struct stat outfile_stat;
4507
4508 fstat (fileno (fp), &outfile_stat);
4509 #endif
4510
4511 #ifdef _WIN
4512 struct stat64 outfile_stat;
4513
4514 _fstat64 (fileno (fp), &outfile_stat);
4515 #endif
4516
4517 if (outfile_stat.st_ctime > out_info[j].ctime)
4518 {
4519 out_info[j].ctime = outfile_stat.st_ctime;
4520 out_info[j].seek = 0;
4521 }
4522
4523 fseek (fp, out_info[j].seek, SEEK_SET);
4524
4525 while (!feof (fp))
4526 {
4527 char line_buf[BUFSIZ];
4528
4529 memset (line_buf, 0, BUFSIZ);
4530
4531 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
4532
4533 if (ptr == NULL) break;
4534
4535 int line_len = strlen (line_buf);
4536
4537 if (line_len <= 0) continue;
4538
4539 int iter = MAX_CUT_TRIES;
4540
4541 for (uint i = line_len - 1; i && iter; i--, line_len--)
4542 {
4543 if (line_buf[i] != separator) continue;
4544
4545 int parser_status = PARSER_OK;
4546
4547 if ((hash_mode != 2500) && (hash_mode != 6800))
4548 {
4549 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4550 }
4551
4552 uint found = 0;
4553
4554 if (parser_status == PARSER_OK)
4555 {
4556 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4557 {
4558 if (data.salts_shown[salt_pos] == 1) continue;
4559
4560 salt_t *salt_buf = &data.salts_buf[salt_pos];
4561
4562 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4563 {
4564 uint idx = salt_buf->digests_offset + digest_pos;
4565
4566 if (data.digests_shown[idx] == 1) continue;
4567
4568 uint cracked = 0;
4569
4570 if (hash_mode == 6800)
4571 {
4572 if (i == salt_buf->salt_len)
4573 {
4574 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4575 }
4576 }
4577 else if (hash_mode == 2500)
4578 {
4579 // BSSID : MAC1 : MAC2 (:plain)
4580 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4581 {
4582 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4583
4584 if (!cracked) continue;
4585
4586 // now compare MAC1 and MAC2 too, since we have this additional info
4587 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4588 char *mac2_pos = mac1_pos + 12 + 1;
4589
4590 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4591 wpa_t *wpa = &wpas[salt_pos];
4592
4593 uint pke[25];
4594
4595 char *pke_ptr = (char *) pke;
4596
4597 for (uint i = 0; i < 25; i++)
4598 {
4599 pke[i] = byte_swap_32 (wpa->pke[i]);
4600 }
4601
4602 unsigned char mac1[6];
4603 unsigned char mac2[6];
4604
4605 memcpy (mac1, pke_ptr + 23, 6);
4606 memcpy (mac2, pke_ptr + 29, 6);
4607
4608 // compare hex string(s) vs binary MAC address(es)
4609
4610 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4611 {
4612 if (mac1[i] != (unsigned char) hex_to_char (&mac1_pos[j]))
4613 {
4614 cracked = 0;
4615 break;
4616 }
4617 }
4618
4619 // early skip ;)
4620 if (!cracked) continue;
4621
4622 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4623 {
4624 if (mac2[i] != (unsigned char) hex_to_char (&mac2_pos[j]))
4625 {
4626 cracked = 0;
4627 break;
4628 }
4629 }
4630 }
4631 }
4632 else
4633 {
4634 char *digests_buf_ptr = (char *) data.digests_buf;
4635
4636 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4637
4638 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4639 }
4640
4641 if (cracked == 1)
4642 {
4643 found = 1;
4644
4645 data.digests_shown[idx] = 1;
4646
4647 data.digests_done++;
4648
4649 salt_buf->digests_done++;
4650
4651 if (salt_buf->digests_done == salt_buf->digests_cnt)
4652 {
4653 data.salts_shown[salt_pos] = 1;
4654
4655 data.salts_done++;
4656
4657 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4658 }
4659 }
4660 }
4661
4662 if (data.devices_status == STATUS_CRACKED) break;
4663 }
4664 }
4665
4666 if (found) break;
4667
4668 if (data.devices_status == STATUS_CRACKED) break;
4669
4670 iter--;
4671 }
4672
4673 if (data.devices_status == STATUS_CRACKED) break;
4674 }
4675
4676 out_info[j].seek = ftell (fp);
4677
4678 //hc_thread_mutex_unlock (mux_display);
4679
4680 fclose (fp);
4681 }
4682 }
4683 }
4684 }
4685
4686 check_left = outfile_check_timer;
4687 }
4688 }
4689
4690 if (esalt_size) local_free (hash_buf.esalt);
4691
4692 if (isSalted) local_free (hash_buf.salt);
4693
4694 local_free (hash_buf.digest);
4695
4696 local_free (out_info);
4697
4698 local_free (out_files);
4699
4700 p = NULL;
4701
4702 return (p);
4703 }
4704
4705 static uint get_work (hc_device_param_t *device_param, const uint64_t max)
4706 {
4707 hc_thread_mutex_lock (mux_dispatcher);
4708
4709 const uint64_t words_cur = data.words_cur;
4710 const uint64_t words_base = (data.limit == 0) ? data.words_base : data.limit;
4711
4712 device_param->words_off = words_cur;
4713
4714 const uint64_t words_left = words_base - words_cur;
4715
4716 if (data.gpu_blocks_all > words_left)
4717 {
4718 if (data.gpu_blocks_div == 0)
4719 {
4720 data.gpu_blocks_div = find_gpu_blocks_div (words_left, data.gpu_blocks_all);
4721 }
4722 }
4723
4724 if (data.gpu_blocks_div)
4725 {
4726 if (device_param->gpu_blocks == device_param->gpu_blocks_user)
4727 {
4728 const uint32_t gpu_blocks_new = (float) device_param->gpu_blocks * data.gpu_blocks_div;
4729 const uint32_t gpu_power_new = gpu_blocks_new / device_param->gpu_vector_width;
4730
4731 if (gpu_blocks_new < device_param->gpu_blocks)
4732 {
4733 device_param->gpu_blocks = gpu_blocks_new;
4734 device_param->gpu_power = gpu_power_new;
4735 }
4736 }
4737 }
4738
4739 const uint gpu_blocks = device_param->gpu_blocks;
4740
4741 uint work = MIN (words_left, gpu_blocks);
4742
4743 work = MIN (work, max);
4744
4745 data.words_cur += work;
4746
4747 hc_thread_mutex_unlock (mux_dispatcher);
4748
4749 return work;
4750 }
4751
4752 static void *thread_calc_stdin (void *p)
4753 {
4754 hc_device_param_t *device_param = (hc_device_param_t *) p;
4755
4756 const uint attack_kern = data.attack_kern;
4757
4758 const uint gpu_blocks = device_param->gpu_blocks;
4759
4760 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4761 {
4762 hc_thread_mutex_lock (mux_dispatcher);
4763
4764 if (feof (stdin) != 0)
4765 {
4766 hc_thread_mutex_unlock (mux_dispatcher);
4767
4768 break;
4769 }
4770
4771 uint words_cur = 0;
4772
4773 while (words_cur < gpu_blocks)
4774 {
4775 char buf[BUFSIZ];
4776
4777 char *line_buf = fgets (buf, sizeof (buf), stdin);
4778
4779 if (line_buf == NULL) break;
4780
4781 uint line_len = in_superchop (line_buf);
4782
4783 line_len = convert_from_hex (line_buf, line_len);
4784
4785 // post-process rule engine
4786
4787 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4788 {
4789 char rule_buf_out[BLOCK_SIZE];
4790
4791 memset (rule_buf_out, 0, sizeof (rule_buf_out));
4792
4793 int rule_len_out = -1;
4794
4795 if (line_len < BLOCK_SIZE)
4796 {
4797 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4798 }
4799
4800 if (rule_len_out < 0) continue;
4801
4802 line_buf = rule_buf_out;
4803 line_len = rule_len_out;
4804 }
4805
4806 if (line_len > PW_MAX)
4807 {
4808 continue;
4809 }
4810
4811 if (attack_kern == ATTACK_KERN_STRAIGHT)
4812 {
4813 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4814 {
4815 hc_thread_mutex_lock (mux_counter);
4816
4817 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4818 {
4819 data.words_progress_rejected[salt_pos] += data.gpu_rules_cnt;
4820 }
4821
4822 hc_thread_mutex_unlock (mux_counter);
4823
4824 continue;
4825 }
4826 }
4827 else if (attack_kern == ATTACK_KERN_COMBI)
4828 {
4829 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4830 // since we still need to combine the plains
4831
4832 if (line_len > data.pw_max)
4833 {
4834 hc_thread_mutex_lock (mux_counter);
4835
4836 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4837 {
4838 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4839 }
4840
4841 hc_thread_mutex_unlock (mux_counter);
4842
4843 continue;
4844 }
4845 }
4846
4847 device_param->pw_add (device_param, (uint8_t *) line_buf, line_len);
4848
4849 words_cur++;
4850
4851 if (data.devices_status == STATUS_CRACKED) break;
4852 if (data.devices_status == STATUS_ABORTED) break;
4853 if (data.devices_status == STATUS_QUIT) break;
4854 if (data.devices_status == STATUS_BYPASS) break;
4855 }
4856
4857 hc_thread_mutex_unlock (mux_dispatcher);
4858
4859 if (data.devices_status == STATUS_CRACKED) break;
4860 if (data.devices_status == STATUS_ABORTED) break;
4861 if (data.devices_status == STATUS_QUIT) break;
4862 if (data.devices_status == STATUS_BYPASS) break;
4863
4864 // we need 2 flushing because we have two independant caches and it can occur
4865 // that one buffer is already at threshold plus for that length also exists
4866 // more data in the 2nd buffer so it would overflow
4867
4868 // flush session 1
4869
4870 {
4871 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4872 {
4873 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4874
4875 const uint pw_cache_cnt = pw_cache->cnt;
4876
4877 if (pw_cache_cnt == 0) continue;
4878
4879 pw_cache->cnt = 0;
4880
4881 uint pws_cnt = device_param->pws_cnt;
4882
4883 pw_t *pw = device_param->pws_buf + pws_cnt;
4884
4885 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4886
4887 pw->pw_len = pw_len;
4888
4889 uint pw_cnt = device_param->pw_cnt;
4890
4891 pw_cnt += pw_cache_cnt;
4892
4893 device_param->pw_cnt = pw_cnt;
4894
4895 pws_cnt++;
4896
4897 device_param->pws_cnt = pws_cnt;
4898
4899 if (pws_cnt == device_param->gpu_power_user) break;
4900 }
4901
4902 const uint pw_cnt = device_param->pw_cnt;
4903 const uint pws_cnt = device_param->pws_cnt;
4904
4905 if (pws_cnt)
4906 {
4907 run_copy (device_param, pws_cnt);
4908
4909 run_cracker (device_param, pw_cnt, pws_cnt);
4910
4911 device_param->pw_cnt = 0;
4912 device_param->pws_cnt = 0;
4913 }
4914 }
4915
4916 // flush session 2
4917
4918 {
4919 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4920 {
4921 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4922
4923 const uint pw_cache_cnt = pw_cache->cnt;
4924
4925 if (pw_cache_cnt == 0) continue;
4926
4927 pw_cache->cnt = 0;
4928
4929 uint pws_cnt = device_param->pws_cnt;
4930
4931 pw_t *pw = device_param->pws_buf + pws_cnt;
4932
4933 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4934
4935 pw->pw_len = pw_len;
4936
4937 uint pw_cnt = device_param->pw_cnt;
4938
4939 pw_cnt += pw_cache_cnt;
4940
4941 device_param->pw_cnt = pw_cnt;
4942
4943 pws_cnt++;
4944
4945 device_param->pws_cnt = pws_cnt;
4946 }
4947
4948 const uint pw_cnt = device_param->pw_cnt;
4949 const uint pws_cnt = device_param->pws_cnt;
4950
4951 if (pws_cnt)
4952 {
4953 run_copy (device_param, pws_cnt);
4954
4955 run_cracker (device_param, pw_cnt, pws_cnt);
4956
4957 device_param->pw_cnt = 0;
4958 device_param->pws_cnt = 0;
4959 }
4960 }
4961 }
4962
4963 return NULL;
4964 }
4965
4966 static void *thread_calc (void *p)
4967 {
4968 hc_device_param_t *device_param = (hc_device_param_t *) p;
4969
4970 const uint attack_mode = data.attack_mode;
4971 const uint attack_kern = data.attack_kern;
4972
4973 if (attack_mode == ATTACK_MODE_BF)
4974 {
4975 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4976 {
4977 const uint work = get_work (device_param, -1);
4978
4979 if (work == 0) break;
4980
4981 const uint64_t words_off = device_param->words_off;
4982 const uint64_t words_fin = words_off + work;
4983
4984 const uint gpu_vector_width = device_param->gpu_vector_width;
4985
4986 const uint pw_cnt = work;
4987 const uint pws_cnt = mydivc32 (work, gpu_vector_width);
4988
4989 device_param->pw_cnt = pw_cnt;
4990 device_param->pws_cnt = pws_cnt;
4991
4992 if (pws_cnt)
4993 {
4994 run_copy (device_param, pws_cnt);
4995
4996 run_cracker (device_param, pw_cnt, pws_cnt);
4997
4998 device_param->pw_cnt = 0;
4999 device_param->pws_cnt = 0;
5000 }
5001
5002 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5003
5004 if (data.devices_status == STATUS_CRACKED) break;
5005 if (data.devices_status == STATUS_ABORTED) break;
5006 if (data.devices_status == STATUS_QUIT) break;
5007 if (data.devices_status == STATUS_BYPASS) break;
5008
5009 device_param->words_done = words_fin;
5010 }
5011 }
5012 else
5013 {
5014 const uint segment_size = data.segment_size;
5015
5016 char *dictfile = data.dictfile;
5017
5018 if (attack_mode == ATTACK_MODE_COMBI)
5019 {
5020 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
5021 {
5022 dictfile = data.dictfile2;
5023 }
5024 }
5025
5026 FILE *fd = fopen (dictfile, "rb");
5027
5028 if (fd == NULL)
5029 {
5030 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
5031
5032 return NULL;
5033 }
5034
5035 if (attack_mode == ATTACK_MODE_COMBI)
5036 {
5037 const uint combs_mode = data.combs_mode;
5038
5039 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
5040 {
5041 const char *dictfilec = data.dictfile2;
5042
5043 FILE *combs_fp = fopen (dictfilec, "rb");
5044
5045 if (combs_fp == NULL)
5046 {
5047 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
5048
5049 fclose (fd);
5050
5051 return NULL;
5052 }
5053
5054 device_param->combs_fp = combs_fp;
5055 }
5056 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
5057 {
5058 const char *dictfilec = data.dictfile;
5059
5060 FILE *combs_fp = fopen (dictfilec, "rb");
5061
5062 if (combs_fp == NULL)
5063 {
5064 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
5065
5066 fclose (fd);
5067
5068 return NULL;
5069 }
5070
5071 device_param->combs_fp = combs_fp;
5072 }
5073 }
5074
5075 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
5076
5077 wl_data->buf = (char *) mymalloc (segment_size);
5078 wl_data->avail = segment_size;
5079 wl_data->incr = segment_size;
5080 wl_data->cnt = 0;
5081 wl_data->pos = 0;
5082
5083 uint64_t words_cur = 0;
5084
5085 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
5086 {
5087 uint64_t words_off = 0;
5088 uint64_t words_fin = 0;
5089
5090 uint64_t max = -1;
5091
5092 while (max)
5093 {
5094 const uint work = get_work (device_param, max);
5095
5096 if (work == 0) break;
5097
5098 words_off = device_param->words_off;
5099 words_fin = words_off + work;
5100
5101 char *line_buf;
5102 uint line_len;
5103
5104 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
5105
5106 max = 0;
5107
5108 for ( ; words_cur < words_fin; words_cur++)
5109 {
5110 get_next_word (wl_data, fd, &line_buf, &line_len);
5111
5112 line_len = convert_from_hex (line_buf, line_len);
5113
5114 // post-process rule engine
5115
5116 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
5117 {
5118 char rule_buf_out[BLOCK_SIZE];
5119
5120 memset (rule_buf_out, 0, sizeof (rule_buf_out));
5121
5122 int rule_len_out = -1;
5123
5124 if (line_len < BLOCK_SIZE)
5125 {
5126 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
5127 }
5128
5129 if (rule_len_out < 0) continue;
5130
5131 line_buf = rule_buf_out;
5132 line_len = rule_len_out;
5133 }
5134
5135 if (attack_kern == ATTACK_KERN_STRAIGHT)
5136 {
5137 if ((line_len < data.pw_min) || (line_len > data.pw_max))
5138 {
5139 max++;
5140
5141 hc_thread_mutex_lock (mux_counter);
5142
5143 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5144 {
5145 data.words_progress_rejected[salt_pos] += data.gpu_rules_cnt;
5146 }
5147
5148 hc_thread_mutex_unlock (mux_counter);
5149
5150 continue;
5151 }
5152 }
5153 else if (attack_kern == ATTACK_KERN_COMBI)
5154 {
5155 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
5156 // since we still need to combine the plains
5157
5158 if (line_len > data.pw_max)
5159 {
5160 max++;
5161
5162 hc_thread_mutex_lock (mux_counter);
5163
5164 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5165 {
5166 data.words_progress_rejected[salt_pos] += data.combs_cnt;
5167 }
5168
5169 hc_thread_mutex_unlock (mux_counter);
5170
5171 continue;
5172 }
5173 }
5174
5175 device_param->pw_add (device_param, (uint8_t *) line_buf, line_len);
5176
5177 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5178
5179 if (data.devices_status == STATUS_CRACKED) break;
5180 if (data.devices_status == STATUS_ABORTED) break;
5181 if (data.devices_status == STATUS_QUIT) break;
5182 if (data.devices_status == STATUS_BYPASS) break;
5183 }
5184
5185 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5186
5187 if (data.devices_status == STATUS_CRACKED) break;
5188 if (data.devices_status == STATUS_ABORTED) break;
5189 if (data.devices_status == STATUS_QUIT) break;
5190 if (data.devices_status == STATUS_BYPASS) break;
5191 }
5192
5193 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5194
5195 if (data.devices_status == STATUS_CRACKED) break;
5196 if (data.devices_status == STATUS_ABORTED) break;
5197 if (data.devices_status == STATUS_QUIT) break;
5198 if (data.devices_status == STATUS_BYPASS) break;
5199
5200 // we need 2 flushing because we have two independant caches and it can occur
5201 // that one buffer is already at threshold plus for that length also exists
5202 // more data in the 2nd buffer so it would overflow
5203
5204 //
5205 // flush session 1
5206 //
5207
5208 {
5209 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
5210 {
5211 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
5212
5213 const uint pw_cache_cnt = pw_cache->cnt;
5214
5215 if (pw_cache_cnt == 0) continue;
5216
5217 pw_cache->cnt = 0;
5218
5219 uint pws_cnt = device_param->pws_cnt;
5220
5221 pw_t *pw = device_param->pws_buf + pws_cnt;
5222
5223 device_param->pw_transpose (&pw_cache->pw_buf, pw);
5224
5225 pw->pw_len = pw_len;
5226
5227 uint pw_cnt = device_param->pw_cnt;
5228
5229 pw_cnt += pw_cache_cnt;
5230
5231 device_param->pw_cnt = pw_cnt;
5232
5233 pws_cnt++;
5234
5235 device_param->pws_cnt = pws_cnt;
5236
5237 if (pws_cnt == device_param->gpu_power_user) break;
5238 }
5239
5240 const uint pw_cnt = device_param->pw_cnt;
5241 const uint pws_cnt = device_param->pws_cnt;
5242
5243 if (pws_cnt)
5244 {
5245 run_copy (device_param, pws_cnt);
5246
5247 run_cracker (device_param, pw_cnt, pws_cnt);
5248
5249 device_param->pw_cnt = 0;
5250 device_param->pws_cnt = 0;
5251 }
5252
5253 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5254
5255 if (data.devices_status == STATUS_CRACKED) break;
5256 if (data.devices_status == STATUS_ABORTED) break;
5257 if (data.devices_status == STATUS_QUIT) break;
5258 if (data.devices_status == STATUS_BYPASS) break;
5259 }
5260
5261 //
5262 // flush session 2
5263 //
5264
5265 {
5266 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
5267 {
5268 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
5269
5270 const uint pw_cache_cnt = pw_cache->cnt;
5271
5272 if (pw_cache_cnt == 0) continue;
5273
5274 pw_cache->cnt = 0;
5275
5276 uint pws_cnt = device_param->pws_cnt;
5277
5278 pw_t *pw = device_param->pws_buf + pws_cnt;
5279
5280 device_param->pw_transpose (&pw_cache->pw_buf, pw);
5281
5282 pw->pw_len = pw_len;
5283
5284 uint pw_cnt = device_param->pw_cnt;
5285
5286 pw_cnt += pw_cache_cnt;
5287
5288 device_param->pw_cnt = pw_cnt;
5289
5290 pws_cnt++;
5291
5292 device_param->pws_cnt = pws_cnt;
5293 }
5294
5295 const uint pw_cnt = device_param->pw_cnt;
5296 const uint pws_cnt = device_param->pws_cnt;
5297
5298 if (pws_cnt)
5299 {
5300 run_copy (device_param, pws_cnt);
5301
5302 run_cracker (device_param, pw_cnt, pws_cnt);
5303
5304 device_param->pw_cnt = 0;
5305 device_param->pws_cnt = 0;
5306 }
5307
5308 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5309
5310 if (data.devices_status == STATUS_CRACKED) break;
5311 if (data.devices_status == STATUS_ABORTED) break;
5312 if (data.devices_status == STATUS_QUIT) break;
5313 if (data.devices_status == STATUS_BYPASS) break;
5314 }
5315
5316 if (words_fin == 0) break;
5317
5318 device_param->words_done = words_fin;
5319 }
5320
5321 if (attack_mode == ATTACK_MODE_COMBI)
5322 {
5323 fclose (device_param->combs_fp);
5324 }
5325
5326 free (wl_data->buf);
5327 free (wl_data);
5328
5329 fclose (fd);
5330 }
5331
5332 return NULL;
5333 }
5334
5335 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos, const uint gpu_loops)
5336 {
5337 #ifdef _CUDA
5338 hc_cuCtxPushCurrent (device_param->context);
5339 #endif
5340
5341 salt_t *salt_buf = &data.salts_buf[salt_pos];
5342
5343 device_param->kernel_params_buf32[24] = salt_pos;
5344 device_param->kernel_params_buf32[27] = 1;
5345 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
5346 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
5347 device_param->kernel_params_buf32[30] = 0;
5348 device_param->kernel_params_buf32[31] = 1;
5349
5350 char *dictfile_old = data.dictfile;
5351 char *dictfile2_old = data.dictfile2;
5352 char *mask_old = data.mask;
5353
5354 const char *weak_hash_check = "weak-hash-check";
5355
5356 data.dictfile = (char *) weak_hash_check;
5357 data.dictfile2 = (char *) weak_hash_check;
5358 data.mask = (char *) weak_hash_check;
5359
5360 /**
5361 * run the kernel
5362 */
5363
5364 if (data.attack_exec == ATTACK_EXEC_ON_GPU)
5365 {
5366 run_kernel (KERN_RUN_1, device_param, 1);
5367 }
5368 else
5369 {
5370 run_kernel (KERN_RUN_1, device_param, 1);
5371
5372 const uint iter = salt_buf->salt_iter;
5373
5374 for (uint loop_pos = 0; loop_pos < iter; loop_pos += gpu_loops)
5375 {
5376 uint loop_left = iter - loop_pos;
5377
5378 loop_left = MIN (loop_left, gpu_loops);
5379
5380 device_param->kernel_params_buf32[25] = loop_pos;
5381 device_param->kernel_params_buf32[26] = loop_left;
5382
5383 run_kernel (KERN_RUN_2, device_param, 1);
5384 }
5385
5386 run_kernel (KERN_RUN_3, device_param, 1);
5387 }
5388
5389 /**
5390 * result
5391 */
5392
5393 check_cracked (device_param, salt_pos);
5394
5395 /**
5396 * cleanup
5397 */
5398
5399 device_param->kernel_params_buf32[24] = 0;
5400 device_param->kernel_params_buf32[25] = 0;
5401 device_param->kernel_params_buf32[26] = 0;
5402 device_param->kernel_params_buf32[27] = 0;
5403 device_param->kernel_params_buf32[28] = 0;
5404 device_param->kernel_params_buf32[29] = 0;
5405 device_param->kernel_params_buf32[30] = 0;
5406 device_param->kernel_params_buf32[31] = 0;
5407
5408 data.dictfile = dictfile_old;
5409 data.dictfile2 = dictfile2_old;
5410 data.mask = mask_old;
5411
5412 #ifdef _CUDA
5413 hc_cuCtxPopCurrent (&device_param->context);
5414 #endif
5415 }
5416
5417 // hlfmt hashcat
5418
5419 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5420 {
5421 if (data.username == 0)
5422 {
5423 *hashbuf_pos = line_buf;
5424 *hashbuf_len = line_len;
5425 }
5426 else
5427 {
5428 char *pos = line_buf;
5429 int len = line_len;
5430
5431 for (int i = 0; i < line_len; i++, pos++, len--)
5432 {
5433 if (line_buf[i] == data.separator)
5434 {
5435 pos++;
5436
5437 len--;
5438
5439 break;
5440 }
5441 }
5442
5443 *hashbuf_pos = pos;
5444 *hashbuf_len = len;
5445 }
5446 }
5447
5448 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5449 {
5450 char *pos = NULL;
5451 int len = 0;
5452
5453 int sep_cnt = 0;
5454
5455 for (int i = 0; i < line_len; i++)
5456 {
5457 if (line_buf[i] == data.separator)
5458 {
5459 sep_cnt++;
5460
5461 continue;
5462 }
5463
5464 if (sep_cnt == 0)
5465 {
5466 if (pos == NULL) pos = line_buf + i;
5467
5468 len++;
5469 }
5470 }
5471
5472 *userbuf_pos = pos;
5473 *userbuf_len = len;
5474 }
5475
5476 // hlfmt pwdump
5477
5478 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
5479 {
5480 int sep_cnt = 0;
5481
5482 int sep2_len = 0;
5483 int sep3_len = 0;
5484
5485 for (int i = 0; i < line_len; i++)
5486 {
5487 if (line_buf[i] == ':')
5488 {
5489 sep_cnt++;
5490
5491 continue;
5492 }
5493
5494 if (sep_cnt == 2) sep2_len++;
5495 if (sep_cnt == 3) sep3_len++;
5496 }
5497
5498 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5499
5500 return 0;
5501 }
5502
5503 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5504 {
5505 char *pos = NULL;
5506 int len = 0;
5507
5508 int sep_cnt = 0;
5509
5510 for (int i = 0; i < line_len; i++)
5511 {
5512 if (line_buf[i] == ':')
5513 {
5514 sep_cnt++;
5515
5516 continue;
5517 }
5518
5519 if (data.hash_mode == 1000)
5520 {
5521 if (sep_cnt == 3)
5522 {
5523 if (pos == NULL) pos = line_buf + i;
5524
5525 len++;
5526 }
5527 }
5528 else if (data.hash_mode == 3000)
5529 {
5530 if (sep_cnt == 2)
5531 {
5532 if (pos == NULL) pos = line_buf + i;
5533
5534 len++;
5535 }
5536 }
5537 }
5538
5539 *hashbuf_pos = pos;
5540 *hashbuf_len = len;
5541 }
5542
5543 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5544 {
5545 char *pos = NULL;
5546 int len = 0;
5547
5548 int sep_cnt = 0;
5549
5550 for (int i = 0; i < line_len; i++)
5551 {
5552 if (line_buf[i] == ':')
5553 {
5554 sep_cnt++;
5555
5556 continue;
5557 }
5558
5559 if (sep_cnt == 0)
5560 {
5561 if (pos == NULL) pos = line_buf + i;
5562
5563 len++;
5564 }
5565 }
5566
5567 *userbuf_pos = pos;
5568 *userbuf_len = len;
5569 }
5570
5571 // hlfmt passwd
5572
5573 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
5574 {
5575 int sep_cnt = 0;
5576
5577 char sep5_first = 0;
5578 char sep6_first = 0;
5579
5580 for (int i = 0; i < line_len; i++)
5581 {
5582 if (line_buf[i] == ':')
5583 {
5584 sep_cnt++;
5585
5586 continue;
5587 }
5588
5589 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5590 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5591 }
5592
5593 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5594
5595 return 0;
5596 }
5597
5598 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5599 {
5600 char *pos = NULL;
5601 int len = 0;
5602
5603 int sep_cnt = 0;
5604
5605 for (int i = 0; i < line_len; i++)
5606 {
5607 if (line_buf[i] == ':')
5608 {
5609 sep_cnt++;
5610
5611 continue;
5612 }
5613
5614 if (sep_cnt == 1)
5615 {
5616 if (pos == NULL) pos = line_buf + i;
5617
5618 len++;
5619 }
5620 }
5621
5622 *hashbuf_pos = pos;
5623 *hashbuf_len = len;
5624 }
5625
5626 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5627 {
5628 char *pos = NULL;
5629 int len = 0;
5630
5631 int sep_cnt = 0;
5632
5633 for (int i = 0; i < line_len; i++)
5634 {
5635 if (line_buf[i] == ':')
5636 {
5637 sep_cnt++;
5638
5639 continue;
5640 }
5641
5642 if (sep_cnt == 0)
5643 {
5644 if (pos == NULL) pos = line_buf + i;
5645
5646 len++;
5647 }
5648 }
5649
5650 *userbuf_pos = pos;
5651 *userbuf_len = len;
5652 }
5653
5654 // hlfmt shadow
5655
5656 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
5657 {
5658 int sep_cnt = 0;
5659
5660 for (int i = 0; i < line_len; i++)
5661 {
5662 if (line_buf[i] == ':') sep_cnt++;
5663 }
5664
5665 if (sep_cnt == 8) return 1;
5666
5667 return 0;
5668 }
5669
5670 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5671 {
5672 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5673 }
5674
5675 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5676 {
5677 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5678 }
5679
5680 // hlfmt main
5681
5682 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5683 {
5684 switch (hashfile_format)
5685 {
5686 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5687 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5688 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5689 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5690 }
5691 }
5692
5693 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5694 {
5695 switch (hashfile_format)
5696 {
5697 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5698 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5699 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5700 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5701 }
5702 }
5703
5704 static uint hlfmt_detect (FILE *fp, uint max_check)
5705 {
5706 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5707
5708 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5709 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5710
5711 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5712
5713 uint num_check = 0;
5714
5715 while (!feof (fp))
5716 {
5717 char line_buf[BUFSIZ];
5718
5719 int line_len = fgetl (fp, line_buf);
5720
5721 if (line_len == 0) continue;
5722
5723 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5724 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5725 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5726
5727 if (num_check == max_check) break;
5728
5729 num_check++;
5730 }
5731
5732 uint hashlist_format = HLFMT_HASHCAT;
5733
5734 for (int i = 1; i < HLFMTS_CNT; i++)
5735 {
5736 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5737
5738 hashlist_format = i;
5739 }
5740
5741 free (formats_cnt);
5742
5743 return hashlist_format;
5744 }
5745
5746 /**
5747 * main
5748 */
5749
5750 #ifdef _OCL
5751 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5752 {
5753 return mymalloc (iSize);
5754 }
5755 #endif
5756
5757 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)
5758 {
5759 uint64_t collisions = 0;
5760
5761 const uint dgst_pos0 = data.dgst_pos0;
5762 const uint dgst_pos1 = data.dgst_pos1;
5763 const uint dgst_pos2 = data.dgst_pos2;
5764 const uint dgst_pos3 = data.dgst_pos3;
5765
5766 memset (bitmap_a, 0, bitmap_size);
5767 memset (bitmap_b, 0, bitmap_size);
5768 memset (bitmap_c, 0, bitmap_size);
5769 memset (bitmap_d, 0, bitmap_size);
5770
5771 for (uint i = 0; i < digests_cnt; i++)
5772 {
5773 uint *digest_ptr = (uint *) digests_buf_ptr;
5774
5775 digests_buf_ptr += dgst_size;
5776
5777 const uint val0 = 1 << (digest_ptr[dgst_pos0] & 0x1f);
5778 const uint val1 = 1 << (digest_ptr[dgst_pos1] & 0x1f);
5779 const uint val2 = 1 << (digest_ptr[dgst_pos2] & 0x1f);
5780 const uint val3 = 1 << (digest_ptr[dgst_pos3] & 0x1f);
5781
5782 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5783 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5784 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5785 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5786
5787 if (bitmap_a[idx0] & val0) collisions++;
5788 if (bitmap_b[idx1] & val1) collisions++;
5789 if (bitmap_c[idx2] & val2) collisions++;
5790 if (bitmap_d[idx3] & val3) collisions++;
5791
5792 bitmap_a[idx0] |= val0;
5793 bitmap_b[idx1] |= val1;
5794 bitmap_c[idx2] |= val2;
5795 bitmap_d[idx3] |= val3;
5796
5797 if (collisions >= collisions_max) return 0x7fffffff;
5798 }
5799
5800 return collisions;
5801 }
5802
5803 int main (int argc, char **argv)
5804 {
5805 /**
5806 * To help users a bit
5807 */
5808
5809 char *compute = getenv ("COMPUTE");
5810
5811 if (compute)
5812 {
5813 char display[100];
5814
5815 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5816
5817 putenv (display);
5818 }
5819 else
5820 {
5821 if (getenv ("DISPLAY") == NULL)
5822 putenv ((char *) "DISPLAY=:0");
5823 }
5824
5825 /*
5826 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5827 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5828
5829 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5830 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5831 */
5832
5833 /**
5834 * Real init
5835 */
5836
5837 memset (&data, 0, sizeof (hc_global_data_t));
5838
5839 time_t proc_start;
5840
5841 time (&proc_start);
5842
5843 data.proc_start = proc_start;
5844
5845 int myargc = argc;
5846 char **myargv = argv;
5847
5848 hc_thread_mutex_init (mux_dispatcher);
5849 hc_thread_mutex_init (mux_counter);
5850 hc_thread_mutex_init (mux_display);
5851 hc_thread_mutex_init (mux_adl);
5852
5853 /**
5854 * commandline parameters
5855 */
5856
5857 uint usage = USAGE;
5858 uint version = VERSION;
5859 uint quiet = QUIET;
5860 uint benchmark = BENCHMARK;
5861 uint benchmark_mode = BENCHMARK_MODE;
5862 uint show = SHOW;
5863 uint left = LEFT;
5864 uint username = USERNAME;
5865 uint remove = REMOVE;
5866 uint remove_timer = REMOVE_TIMER;
5867 uint64_t skip = SKIP;
5868 uint64_t limit = LIMIT;
5869 uint keyspace = KEYSPACE;
5870 uint potfile_disable = POTFILE_DISABLE;
5871 uint debug_mode = DEBUG_MODE;
5872 char *debug_file = NULL;
5873 char *induction_dir = NULL;
5874 char *outfile_check_dir = NULL;
5875 uint force = FORCE;
5876 uint runtime = RUNTIME;
5877 uint hash_mode = HASH_MODE;
5878 uint attack_mode = ATTACK_MODE;
5879 uint markov_disable = MARKOV_DISABLE;
5880 uint markov_classic = MARKOV_CLASSIC;
5881 uint markov_threshold = MARKOV_THRESHOLD;
5882 char *markov_hcstat = NULL;
5883 char *outfile = NULL;
5884 uint outfile_format = OUTFILE_FORMAT;
5885 uint outfile_autohex = OUTFILE_AUTOHEX;
5886 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5887 uint restore = RESTORE;
5888 uint restore_timer = RESTORE_TIMER;
5889 uint restore_disable = RESTORE_DISABLE;
5890 uint status = STATUS;
5891 uint status_timer = STATUS_TIMER;
5892 uint status_automat = STATUS_AUTOMAT;
5893 uint loopback = LOOPBACK;
5894 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5895 char *session = NULL;
5896 uint hex_charset = HEX_CHARSET;
5897 uint hex_salt = HEX_SALT;
5898 uint hex_wordlist = HEX_WORDLIST;
5899 uint rp_gen = RP_GEN;
5900 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5901 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5902 uint rp_gen_seed = RP_GEN_SEED;
5903 char *rule_buf_l = (char *) RULE_BUF_L;
5904 char *rule_buf_r = (char *) RULE_BUF_R;
5905 uint increment = INCREMENT;
5906 uint increment_min = INCREMENT_MIN;
5907 uint increment_max = INCREMENT_MAX;
5908 char *cpu_affinity = NULL;
5909 uint gpu_async = GPU_ASYNC;
5910 char *gpu_devices = NULL;
5911 char *truecrypt_keyfiles = NULL;
5912 uint workload_profile = WORKLOAD_PROFILE;
5913 uint gpu_accel = GPU_ACCEL;
5914 uint gpu_loops = GPU_LOOPS;
5915 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5916 uint gpu_temp_abort = GPU_TEMP_ABORT;
5917 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5918 uint powertune_enable = POWERTUNE_ENABLE;
5919 uint logfile_disable = LOGFILE_DISABLE;
5920 uint segment_size = SEGMENT_SIZE;
5921 uint scrypt_tmto = SCRYPT_TMTO;
5922 char separator = SEPARATOR;
5923 uint bitmap_min = BITMAP_MIN;
5924 uint bitmap_max = BITMAP_MAX;
5925 char *custom_charset_1 = NULL;
5926 char *custom_charset_2 = NULL;
5927 char *custom_charset_3 = NULL;
5928 char *custom_charset_4 = NULL;
5929
5930 #define IDX_HELP 'h'
5931 #define IDX_VERSION 'V'
5932 #define IDX_VERSION_LOWER 'v'
5933 #define IDX_QUIET 0xff02
5934 #define IDX_SHOW 0xff03
5935 #define IDX_LEFT 0xff04
5936 #define IDX_REMOVE 0xff05
5937 #define IDX_REMOVE_TIMER 0xff37
5938 #define IDX_SKIP 's'
5939 #define IDX_LIMIT 'l'
5940 #define IDX_KEYSPACE 0xff35
5941 #define IDX_POTFILE_DISABLE 0xff06
5942 #define IDX_DEBUG_MODE 0xff43
5943 #define IDX_DEBUG_FILE 0xff44
5944 #define IDX_INDUCTION_DIR 0xff46
5945 #define IDX_OUTFILE_CHECK_DIR 0xff47
5946 #define IDX_USERNAME 0xff07
5947 #define IDX_FORCE 0xff08
5948 #define IDX_RUNTIME 0xff09
5949 #define IDX_BENCHMARK 'b'
5950 #define IDX_BENCHMARK_MODE 0xff32
5951 #define IDX_HASH_MODE 'm'
5952 #define IDX_ATTACK_MODE 'a'
5953 #define IDX_RP_FILE 'r'
5954 #define IDX_RP_GEN 'g'
5955 #define IDX_RP_GEN_FUNC_MIN 0xff10
5956 #define IDX_RP_GEN_FUNC_MAX 0xff11
5957 #define IDX_RP_GEN_SEED 0xff34
5958 #define IDX_RULE_BUF_L 'j'
5959 #define IDX_RULE_BUF_R 'k'
5960 #define IDX_INCREMENT 'i'
5961 #define IDX_INCREMENT_MIN 0xff12
5962 #define IDX_INCREMENT_MAX 0xff13
5963 #define IDX_OUTFILE 'o'
5964 #define IDX_OUTFILE_FORMAT 0xff14
5965 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5966 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5967 #define IDX_RESTORE 0xff15
5968 #define IDX_RESTORE_DISABLE 0xff27
5969 #define IDX_STATUS 0xff17
5970 #define IDX_STATUS_TIMER 0xff18
5971 #define IDX_STATUS_AUTOMAT 0xff50
5972 #define IDX_LOOPBACK 0xff38
5973 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5974 #define IDX_SESSION 0xff19
5975 #define IDX_HEX_CHARSET 0xff20
5976 #define IDX_HEX_SALT 0xff21
5977 #define IDX_HEX_WORDLIST 0xff40
5978 #define IDX_MARKOV_DISABLE 0xff22
5979 #define IDX_MARKOV_CLASSIC 0xff23
5980 #define IDX_MARKOV_THRESHOLD 't'
5981 #define IDX_MARKOV_HCSTAT 0xff24
5982 #define IDX_CPU_AFFINITY 0xff25
5983 #define IDX_GPU_ASYNC 0xff26
5984 #define IDX_GPU_DEVICES 'd'
5985 #define IDX_WORKLOAD_PROFILE 'w'
5986 #define IDX_GPU_ACCEL 'n'
5987 #define IDX_GPU_LOOPS 'u'
5988 #define IDX_GPU_TEMP_DISABLE 0xff29
5989 #define IDX_GPU_TEMP_ABORT 0xff30
5990 #define IDX_GPU_TEMP_RETAIN 0xff31
5991 #define IDX_POWERTUNE_ENABLE 0xff41
5992 #define IDX_LOGFILE_DISABLE 0xff51
5993 #define IDX_TRUECRYPT_KEYFILES 0xff52
5994 #define IDX_SCRYPT_TMTO 0xff61
5995 #define IDX_SEGMENT_SIZE 'c'
5996 #define IDX_SEPARATOR 'p'
5997 #define IDX_BITMAP_MIN 0xff70
5998 #define IDX_BITMAP_MAX 0xff71
5999 #define IDX_CUSTOM_CHARSET_1 '1'
6000 #define IDX_CUSTOM_CHARSET_2 '2'
6001 #define IDX_CUSTOM_CHARSET_3 '3'
6002 #define IDX_CUSTOM_CHARSET_4 '4'
6003
6004 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
6005
6006 struct option long_options[] =
6007 {
6008 {"help", no_argument, 0, IDX_HELP},
6009 {"version", no_argument, 0, IDX_VERSION},
6010 {"quiet", no_argument, 0, IDX_QUIET},
6011 {"show", no_argument, 0, IDX_SHOW},
6012 {"left", no_argument, 0, IDX_LEFT},
6013 {"username", no_argument, 0, IDX_USERNAME},
6014 {"remove", no_argument, 0, IDX_REMOVE},
6015 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
6016 {"skip", required_argument, 0, IDX_SKIP},
6017 {"limit", required_argument, 0, IDX_LIMIT},
6018 {"keyspace", no_argument, 0, IDX_KEYSPACE},
6019 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
6020 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
6021 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
6022 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
6023 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
6024 {"force", no_argument, 0, IDX_FORCE},
6025 {"benchmark", no_argument, 0, IDX_BENCHMARK},
6026 {"benchmark-mode", required_argument, 0, IDX_BENCHMARK_MODE},
6027 {"restore", no_argument, 0, IDX_RESTORE},
6028 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
6029 {"status", no_argument, 0, IDX_STATUS},
6030 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
6031 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
6032 {"loopback", no_argument, 0, IDX_LOOPBACK},
6033 {"weak-hash-threshold",
6034 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
6035 {"session", required_argument, 0, IDX_SESSION},
6036 {"runtime", required_argument, 0, IDX_RUNTIME},
6037 {"generate-rules", required_argument, 0, IDX_RP_GEN},
6038 {"generate-rules-func-min",
6039 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
6040 {"generate-rules-func-max",
6041 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
6042 {"generate-rules-seed",
6043 required_argument, 0, IDX_RP_GEN_SEED},
6044 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
6045 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
6046 {"hash-type", required_argument, 0, IDX_HASH_MODE},
6047 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
6048 {"rules-file", required_argument, 0, IDX_RP_FILE},
6049 {"outfile", required_argument, 0, IDX_OUTFILE},
6050 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
6051 {"outfile-autohex-disable",
6052 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
6053 {"outfile-check-timer",
6054 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
6055 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
6056 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
6057 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
6058 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
6059 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
6060 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
6061 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
6062 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
6063 {"gpu-async", no_argument, 0, IDX_GPU_ASYNC},
6064 {"gpu-devices", required_argument, 0, IDX_GPU_DEVICES},
6065 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
6066 {"gpu-accel", required_argument, 0, IDX_GPU_ACCEL},
6067 {"gpu-loops", required_argument, 0, IDX_GPU_LOOPS},
6068 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
6069 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
6070 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
6071 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
6072 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
6073 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
6074 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
6075 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
6076 // deprecated
6077 {"seperator", required_argument, 0, IDX_SEPARATOR},
6078 {"separator", required_argument, 0, IDX_SEPARATOR},
6079 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
6080 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
6081 {"increment", no_argument, 0, IDX_INCREMENT},
6082 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
6083 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
6084 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
6085 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
6086 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
6087 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
6088
6089 {0, 0, 0, 0}
6090 };
6091
6092 uint rp_files_cnt = 0;
6093
6094 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
6095
6096 int option_index;
6097 int c;
6098
6099 optind = 1;
6100 optopt = 0;
6101 option_index = 0;
6102
6103 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6104 {
6105 switch (c)
6106 {
6107 case IDX_HELP: usage = 1; break;
6108 case IDX_VERSION:
6109 case IDX_VERSION_LOWER: version = 1; break;
6110 case IDX_RESTORE: restore = 1; break;
6111 case IDX_SESSION: session = optarg; break;
6112 case IDX_SHOW: show = 1; break;
6113 case IDX_LEFT: left = 1; break;
6114 case '?': return (-1);
6115 }
6116 }
6117
6118 if (optopt != 0)
6119 {
6120 log_error ("ERROR: Invalid argument specified");
6121
6122 return (-1);
6123 }
6124
6125 /**
6126 * exit functions
6127 */
6128
6129 if (version)
6130 {
6131 log_info (VERSION_TXT);
6132
6133 return (0);
6134 }
6135
6136 if (usage)
6137 {
6138 usage_big_print (PROGNAME);
6139
6140 return (0);
6141 }
6142
6143 /**
6144 * session
6145 */
6146
6147 if (session == NULL) session = (char *) PROGNAME;
6148
6149 size_t session_size = strlen (session) + 32;
6150
6151 data.session = session;
6152
6153 char *eff_restore_file = (char *) mymalloc (session_size);
6154 char *new_restore_file = (char *) mymalloc (session_size);
6155
6156 snprintf (eff_restore_file, session_size - 1, "%s.restore", session);
6157 snprintf (new_restore_file, session_size - 1, "%s.restore.new", session);
6158
6159 data.eff_restore_file = eff_restore_file;
6160 data.new_restore_file = new_restore_file;
6161
6162 if (((show == 1) || (left == 1)) && (restore == 1))
6163 {
6164 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
6165 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
6166
6167 return (-1);
6168 }
6169
6170 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
6171 if ((show == 1) || (left == 1))
6172 {
6173 restore_disable = 1;
6174
6175 restore = 0;
6176 }
6177
6178 data.restore_disable = restore_disable;
6179
6180 restore_data_t *rd = init_restore (argc, argv);
6181
6182 data.rd = rd;
6183
6184 /**
6185 * restore file
6186 */
6187
6188 if (restore == 1)
6189 {
6190 read_restore (eff_restore_file, rd);
6191
6192 if (rd->version_bin < RESTORE_MIN)
6193 {
6194 log_error ("ERROR: Incompatible restore-file version");
6195
6196 return (-1);
6197 }
6198
6199 myargc = rd->argc;
6200 myargv = rd->argv;
6201
6202 #ifdef _POSIX
6203 rd->pid = getpid ();
6204 #elif _WIN
6205 rd->pid = GetCurrentProcessId ();
6206 #endif
6207 }
6208
6209 uint hash_mode_chgd = 0;
6210 uint runtime_chgd = 0;
6211 uint gpu_loops_chgd = 0;
6212 uint gpu_accel_chgd = 0;
6213 uint attack_mode_chgd = 0;
6214 uint outfile_format_chgd = 0;
6215 uint rp_gen_seed_chgd = 0;
6216 uint remove_timer_chgd = 0;
6217 uint increment_min_chgd = 0;
6218 uint increment_max_chgd = 0;
6219
6220 #if _OCL
6221 uint gpu_temp_abort_chgd = 0;
6222 uint gpu_temp_retain_chgd = 0;
6223 #endif
6224
6225 optind = 1;
6226 optopt = 0;
6227 option_index = 0;
6228
6229 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6230 {
6231 switch (c)
6232 {
6233 //case IDX_HELP: usage = 1; break;
6234 //case IDX_VERSION: version = 1; break;
6235 //case IDX_RESTORE: restore = 1; break;
6236 case IDX_QUIET: quiet = 1; break;
6237 //case IDX_SHOW: show = 1; break;
6238 case IDX_SHOW: break;
6239 //case IDX_LEFT: left = 1; break;
6240 case IDX_LEFT: break;
6241 case IDX_USERNAME: username = 1; break;
6242 case IDX_REMOVE: remove = 1; break;
6243 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
6244 remove_timer_chgd = 1; break;
6245 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
6246 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
6247 case IDX_DEBUG_FILE: debug_file = optarg; break;
6248 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
6249 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
6250 case IDX_FORCE: force = 1; break;
6251 case IDX_SKIP: skip = atoll (optarg); break;
6252 case IDX_LIMIT: limit = atoll (optarg); break;
6253 case IDX_KEYSPACE: keyspace = 1; break;
6254 case IDX_BENCHMARK: benchmark = 1; break;
6255 case IDX_BENCHMARK_MODE: benchmark_mode = atoi (optarg); break;
6256 case IDX_RESTORE: break;
6257 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
6258 case IDX_STATUS: status = 1; break;
6259 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
6260 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
6261 case IDX_LOOPBACK: loopback = 1; break;
6262 case IDX_WEAK_HASH_THRESHOLD:
6263 weak_hash_threshold = atoi (optarg); break;
6264 //case IDX_SESSION: session = optarg; break;
6265 case IDX_SESSION: break;
6266 case IDX_HASH_MODE: hash_mode = atoi (optarg);
6267 hash_mode_chgd = 1; break;
6268 case IDX_RUNTIME: runtime = atoi (optarg);
6269 runtime_chgd = 1; break;
6270 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
6271 attack_mode_chgd = 1; break;
6272 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
6273 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
6274 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
6275 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
6276 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
6277 rp_gen_seed_chgd = 1; break;
6278 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
6279 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
6280 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
6281 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
6282 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
6283 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
6284 case IDX_OUTFILE: outfile = optarg; break;
6285 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
6286 outfile_format_chgd = 1; break;
6287 case IDX_OUTFILE_AUTOHEX_DISABLE:
6288 outfile_autohex = 0; break;
6289 case IDX_OUTFILE_CHECK_TIMER:
6290 outfile_check_timer = atoi (optarg); break;
6291 case IDX_HEX_CHARSET: hex_charset = 1; break;
6292 case IDX_HEX_SALT: hex_salt = 1; break;
6293 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
6294 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
6295 case IDX_GPU_ASYNC: gpu_async = 1; break;
6296 case IDX_GPU_DEVICES: gpu_devices = optarg; break;
6297 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg); break;
6298 case IDX_GPU_ACCEL: gpu_accel = atoi (optarg);
6299 gpu_accel_chgd = 1; break;
6300 case IDX_GPU_LOOPS: gpu_loops = atoi (optarg);
6301 gpu_loops_chgd = 1; break;
6302 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6303 case IDX_GPU_TEMP_ABORT:
6304 #if _OCL
6305 gpu_temp_abort_chgd = 1;
6306 #endif
6307 gpu_temp_abort = atoi (optarg); break;
6308 case IDX_GPU_TEMP_RETAIN:
6309 #if _OCL
6310 gpu_temp_retain_chgd = 1;
6311 #endif
6312 gpu_temp_retain = atoi (optarg); break;
6313 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6314 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6315 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6316 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6317 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6318 case IDX_SEPARATOR: separator = optarg[0]; break;
6319 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6320 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6321 case IDX_INCREMENT: increment = 1; break;
6322 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6323 increment_min_chgd = 1; break;
6324 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6325 increment_max_chgd = 1; break;
6326 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6327 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6328 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6329 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6330
6331 default:
6332 log_error ("ERROR: Invalid argument specified");
6333 return (-1);
6334 }
6335 }
6336
6337 if (optopt != 0)
6338 {
6339 log_error ("ERROR: Invalid argument specified");
6340
6341 return (-1);
6342 }
6343
6344 /**
6345 * Inform user things getting started,
6346 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6347 * - we do not need to check algorithm_pos
6348 */
6349
6350 if (quiet == 0)
6351 {
6352 if (benchmark == 1)
6353 {
6354 log_info ("%s v%.2f starting in benchmark-mode...", PROGNAME, (float) VERSION_BIN / 100);
6355
6356 log_info ("");
6357 }
6358 else if (restore == 1)
6359 {
6360 log_info ("%s v%.2f starting in restore-mode...", PROGNAME, (float) VERSION_BIN / 100);
6361
6362 log_info ("");
6363 }
6364 else
6365 {
6366 log_info ("%s v%.2f starting...", PROGNAME, (float) VERSION_BIN / 100);
6367
6368 log_info ("");
6369 }
6370 }
6371
6372 /**
6373 * sanity check
6374 */
6375
6376 if (attack_mode > 7)
6377 {
6378 log_error ("ERROR: Invalid attack-mode specified");
6379
6380 return (-1);
6381 }
6382
6383 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6384 {
6385 log_error ("ERROR: Invalid runtime specified");
6386
6387 return (-1);
6388 }
6389
6390 if (hash_mode_chgd && hash_mode > 12800) // just added to remove compiler warnings for hash_mode_chgd
6391 {
6392 log_error ("ERROR: Invalid hash-type specified");
6393
6394 return (-1);
6395 }
6396
6397 // renamed hash modes
6398
6399 if (hash_mode_chgd)
6400 {
6401 int n = -1;
6402
6403 switch (hash_mode)
6404 {
6405 case 123: n = 124;
6406 break;
6407 }
6408
6409 if (n >= 0)
6410 {
6411 log_error ("Old -m specified, use -m %d instead", n);
6412
6413 return (-1);
6414 }
6415 }
6416
6417 if (username == 1)
6418 {
6419 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
6420 {
6421 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6422
6423 return (-1);
6424 }
6425 }
6426
6427 if (outfile_format > 16)
6428 {
6429 log_error ("ERROR: Invalid outfile-format specified");
6430
6431 return (-1);
6432 }
6433
6434 if (left == 1)
6435 {
6436 if (outfile_format_chgd == 1)
6437 {
6438 if (outfile_format > 1)
6439 {
6440 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6441
6442 return (-1);
6443 }
6444 }
6445 else
6446 {
6447 outfile_format = OUTFILE_FMT_HASH;
6448 }
6449 }
6450
6451 if (show == 1)
6452 {
6453 if (outfile_format_chgd == 1)
6454 {
6455 if ((outfile_format > 7) && (outfile_format < 16))
6456 {
6457 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6458
6459 return (-1);
6460 }
6461 }
6462 }
6463
6464 if (increment_min < INCREMENT_MIN)
6465 {
6466 log_error ("ERROR: Invalid increment-min specified");
6467
6468 return (-1);
6469 }
6470
6471 if (increment_max > INCREMENT_MAX)
6472 {
6473 log_error ("ERROR: Invalid increment-max specified");
6474
6475 return (-1);
6476 }
6477
6478 if (increment_min > increment_max)
6479 {
6480 log_error ("ERROR: Invalid increment-min specified");
6481
6482 return (-1);
6483 }
6484
6485 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6486 {
6487 log_error ("ERROR: increment is not allowed in attack-mode 0");
6488
6489 return (-1);
6490 }
6491
6492 if ((increment == 0) && (increment_min_chgd == 1))
6493 {
6494 log_error ("ERROR: increment-min is only supported together with increment switch");
6495
6496 return (-1);
6497 }
6498
6499 if ((increment == 0) && (increment_max_chgd == 1))
6500 {
6501 log_error ("ERROR: increment-max is only supported together with increment switch");
6502
6503 return (-1);
6504 }
6505
6506 if (rp_files_cnt && rp_gen)
6507 {
6508 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6509
6510 return (-1);
6511 }
6512
6513 if (rp_files_cnt || rp_gen)
6514 {
6515 if (attack_mode != ATTACK_MODE_STRAIGHT)
6516 {
6517 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6518
6519 return (-1);
6520 }
6521 }
6522
6523 if (rp_gen_func_min > rp_gen_func_max)
6524 {
6525 log_error ("ERROR: Invalid rp-gen-func-min specified");
6526
6527 return (-1);
6528 }
6529
6530 if (gpu_accel_chgd == 1)
6531 {
6532 if (workload_profile != WORKLOAD_PROFILE)
6533 {
6534 log_error ("ERROR: gpu-accel parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
6535
6536 return (-1);
6537 }
6538
6539 if (gpu_accel < 1)
6540 {
6541 log_error ("ERROR: Invalid gpu-accel specified");
6542
6543 return (-1);
6544 }
6545
6546 if (gpu_accel > 800)
6547 {
6548 log_error ("ERROR: Invalid gpu-accel specified");
6549
6550 return (-1);
6551 }
6552 }
6553
6554 if (gpu_loops_chgd == 1)
6555 {
6556 if (workload_profile != WORKLOAD_PROFILE)
6557 {
6558 log_error ("ERROR: gpu-loops parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
6559
6560 return (-1);
6561 }
6562
6563 if (gpu_loops < 1)
6564 {
6565 log_error ("ERROR: Invalid gpu-loops specified");
6566
6567 return (-1);
6568 }
6569
6570 if (gpu_loops > 1024)
6571 {
6572 log_error ("ERROR: Invalid gpu-loops specified");
6573
6574 return (-1);
6575 }
6576 }
6577
6578 if (benchmark == 1)
6579 {
6580 if (workload_profile != WORKLOAD_PROFILE)
6581 {
6582 log_error ("ERROR: Using the workload-profile in benchmark mode is not allowed");
6583
6584 return (-1);
6585 }
6586 }
6587
6588 if ((workload_profile < 1) || (workload_profile > 3))
6589 {
6590 log_error ("ERROR: workload-profile %i not available", workload_profile);
6591
6592 return (-1);
6593 }
6594
6595 if (show == 1 || left == 1)
6596 {
6597 attack_mode = ATTACK_MODE_NONE;
6598
6599 if (remove == 1)
6600 {
6601 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6602
6603 return (-1);
6604 }
6605
6606 if (potfile_disable == 1)
6607 {
6608 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6609
6610 return (-1);
6611 }
6612 }
6613
6614 uint attack_kern = ATTACK_KERN_NONE;
6615
6616 switch (attack_mode)
6617 {
6618 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6619 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6620 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6621 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6622 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6623 }
6624
6625 if (benchmark == 0)
6626 {
6627 if (keyspace == 1)
6628 {
6629 int num_additional_params = 1;
6630
6631 if (attack_kern == ATTACK_KERN_COMBI)
6632 {
6633 num_additional_params = 2;
6634 }
6635
6636 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6637
6638 if (keyspace_wordlist_specified == 0) optind--;
6639 }
6640
6641 if (attack_kern == ATTACK_KERN_NONE)
6642 {
6643 if ((optind + 1) != myargc)
6644 {
6645 usage_mini_print (myargv[0]);
6646
6647 return (-1);
6648 }
6649 }
6650 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6651 {
6652 if ((optind + 1) > myargc)
6653 {
6654 usage_mini_print (myargv[0]);
6655
6656 return (-1);
6657 }
6658 }
6659 else if (attack_kern == ATTACK_KERN_COMBI)
6660 {
6661 if ((optind + 3) != myargc)
6662 {
6663 usage_mini_print (myargv[0]);
6664
6665 return (-1);
6666 }
6667 }
6668 else if (attack_kern == ATTACK_KERN_BF)
6669 {
6670 if ((optind + 1) > myargc)
6671 {
6672 usage_mini_print (myargv[0]);
6673
6674 return (-1);
6675 }
6676 }
6677 else
6678 {
6679 usage_mini_print (myargv[0]);
6680
6681 return (-1);
6682 }
6683 }
6684 else
6685 {
6686 if (myargv[optind] != 0)
6687 {
6688 log_error ("ERROR: Invalid argument for benchmark mode specified");
6689
6690 return (-1);
6691 }
6692
6693 if (attack_mode_chgd == 1)
6694 {
6695 if (attack_mode != ATTACK_MODE_BF)
6696 {
6697 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6698
6699 return (-1);
6700 }
6701 }
6702
6703 if (benchmark_mode == 0)
6704 {
6705 // nothing to do
6706 }
6707 else if (benchmark_mode == 1)
6708 {
6709 if (gpu_accel_chgd == 1 || gpu_loops_chgd == 1)
6710 {
6711 log_error ("ERROR: Benchmark-mode 1 does not allow gpu-accel or gpu-loops changed");
6712
6713 return (-1);
6714 }
6715 }
6716 else
6717 {
6718 log_error ("ERROR: Benchmark-mode must be 0 or 1");
6719
6720 return (-1);
6721 }
6722 }
6723
6724 if (skip != 0 && limit != 0)
6725 {
6726 limit += skip;
6727 }
6728
6729 if (keyspace == 1)
6730 {
6731 if (show == 1)
6732 {
6733 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6734
6735 return (-1);
6736 }
6737 else if (left == 1)
6738 {
6739 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6740
6741 return (-1);
6742 }
6743
6744 potfile_disable = 1;
6745
6746 restore_disable = 1;
6747
6748 restore = 0;
6749
6750 weak_hash_threshold = 0;
6751
6752 quiet = 1;
6753 }
6754
6755 if (remove_timer_chgd == 1)
6756 {
6757 if (remove == 0)
6758 {
6759 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6760
6761 return (-1);
6762 }
6763
6764 if (remove_timer < 1)
6765 {
6766 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6767
6768 return (-1);
6769 }
6770 }
6771
6772 if (loopback == 1)
6773 {
6774 if (attack_mode == ATTACK_MODE_BF)
6775 {
6776 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6777
6778 return (-1);
6779 }
6780 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6781 {
6782 if ((rp_files_cnt == 0) && (rp_gen == 0))
6783 {
6784 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6785
6786 return (-1);
6787 }
6788 }
6789 }
6790
6791 if (debug_mode > 0)
6792 {
6793 if (attack_mode != ATTACK_MODE_STRAIGHT)
6794 {
6795 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6796
6797 return (-1);
6798 }
6799
6800 if ((rp_files_cnt == 0) && (rp_gen == 0))
6801 {
6802 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6803
6804 return (-1);
6805 }
6806 }
6807
6808 if (debug_mode > 4)
6809 {
6810 log_error ("ERROR: Invalid debug-mode specified");
6811
6812 return (-1);
6813 }
6814
6815 if (debug_file != NULL)
6816 {
6817 if (debug_mode < 1)
6818 {
6819 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6820
6821 return (-1);
6822 }
6823 }
6824
6825 if (induction_dir != NULL)
6826 {
6827 if (attack_mode == ATTACK_MODE_BF)
6828 {
6829 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6830
6831 return (-1);
6832 }
6833 }
6834
6835 /**
6836 * induction directory
6837 */
6838
6839 char *induction_directory = NULL;
6840
6841 if (attack_mode != ATTACK_MODE_BF)
6842 {
6843 if (induction_dir == NULL)
6844 {
6845 induction_directory = (char *) mymalloc (session_size);
6846
6847 snprintf (induction_directory, session_size - 1, "%s.%s", session, INDUCT_DIR);
6848
6849 // create induction folder if it does not already exist
6850
6851 if (keyspace == 0)
6852 {
6853 if (rmdir (induction_directory) == -1)
6854 {
6855 if (errno == ENOENT)
6856 {
6857 // good, we can ignore
6858 }
6859 else if (errno == ENOTEMPTY)
6860 {
6861 char *induction_directory_mv = (char *) mymalloc (session_size);
6862
6863 snprintf (induction_directory_mv, session_size - 1, "%s.induct.%d", session, (int) proc_start);
6864
6865 if (rename (induction_directory, induction_directory_mv) != 0)
6866 {
6867 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6868
6869 return (-1);
6870 }
6871 }
6872 else
6873 {
6874 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6875
6876 return (-1);
6877 }
6878 }
6879
6880 #ifdef _WIN
6881 #define mkdir(name,mode) mkdir (name)
6882 #endif
6883
6884 if (mkdir (induction_directory, 0700) == -1)
6885 {
6886 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6887
6888 return (-1);
6889 }
6890 }
6891 }
6892 else
6893 {
6894 induction_directory = induction_dir;
6895 }
6896 }
6897
6898 data.induction_directory = induction_directory;
6899
6900 /**
6901 * loopback
6902 */
6903
6904 size_t loopback_size = session_size + strlen (LOOPBACK_FILE) + 12;
6905
6906 char *loopback_file = (char *) mymalloc (loopback_size);
6907
6908 /**
6909 * outfile-check directory
6910 */
6911
6912 char *outfile_check_directory = NULL;
6913
6914 if (outfile_check_dir == NULL)
6915 {
6916 outfile_check_directory = (char *) mymalloc (session_size);
6917
6918 snprintf (outfile_check_directory, session_size - 1, "%s.%s", session, OUTFILES_DIR);
6919 }
6920 else
6921 {
6922 outfile_check_directory = outfile_check_dir;
6923 }
6924
6925 data.outfile_check_directory = outfile_check_directory;
6926
6927 if (keyspace == 0)
6928 {
6929 struct stat outfile_check_stat;
6930
6931 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6932 {
6933 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6934
6935 if (is_dir == 0)
6936 {
6937 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6938
6939 return (-1);
6940 }
6941 }
6942 else if (outfile_check_dir == NULL)
6943 {
6944 #ifdef _WIN
6945 #define mkdir(name,mode) mkdir (name)
6946 #endif
6947
6948 if (mkdir (outfile_check_directory, 0700) == -1)
6949 {
6950 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6951
6952 return (-1);
6953 }
6954 }
6955 }
6956
6957 /**
6958 * special other stuff
6959 */
6960
6961 if (hash_mode == 9710)
6962 {
6963 outfile_format = 5;
6964 outfile_format_chgd = 1;
6965 }
6966
6967 if (hash_mode == 9810)
6968 {
6969 outfile_format = 5;
6970 outfile_format_chgd = 1;
6971 }
6972
6973 if (hash_mode == 10410)
6974 {
6975 outfile_format = 5;
6976 outfile_format_chgd = 1;
6977 }
6978
6979 /**
6980 * store stuff
6981 */
6982
6983 data.hash_mode = hash_mode;
6984 data.restore = restore;
6985 data.restore_timer = restore_timer;
6986 data.restore_disable = restore_disable;
6987 data.status = status;
6988 data.status_timer = status_timer;
6989 data.status_automat = status_automat;
6990 data.loopback = loopback;
6991 data.runtime = runtime;
6992 data.remove = remove;
6993 data.remove_timer = remove_timer;
6994 data.debug_mode = debug_mode;
6995 data.debug_file = debug_file;
6996 data.username = username;
6997 data.quiet = quiet;
6998 data.outfile = outfile;
6999 data.outfile_format = outfile_format;
7000 data.outfile_autohex = outfile_autohex;
7001 data.hex_charset = hex_charset;
7002 data.hex_salt = hex_salt;
7003 data.hex_wordlist = hex_wordlist;
7004 data.separator = separator;
7005 data.rp_files = rp_files;
7006 data.rp_files_cnt = rp_files_cnt;
7007 data.rp_gen = rp_gen;
7008 data.rp_gen_seed = rp_gen_seed;
7009 data.force = force;
7010 data.benchmark = benchmark;
7011 data.skip = skip;
7012 data.limit = limit;
7013 data.powertune_enable = powertune_enable;
7014 data.logfile_disable = logfile_disable;
7015 data.truecrypt_keyfiles = truecrypt_keyfiles;
7016 data.scrypt_tmto = scrypt_tmto;
7017
7018 /**
7019 * install_dir
7020 */
7021
7022 char *install_dir = get_install_dir (myargv[0]);
7023
7024 data.install_dir = install_dir;
7025
7026 /**
7027 * cpu affinity
7028 */
7029
7030 if (cpu_affinity)
7031 {
7032 set_cpu_affinity (cpu_affinity);
7033 }
7034
7035 if (rp_gen_seed_chgd == 0)
7036 {
7037 srand (proc_start);
7038 }
7039 else
7040 {
7041 srand (rp_gen_seed);
7042 }
7043
7044 /**
7045 * logfile init
7046 */
7047
7048 if (logfile_disable == 0)
7049 {
7050 size_t logfile_size = strlen (session) + 32;
7051
7052 char *logfile = (char *) mymalloc (logfile_size);
7053
7054 snprintf (logfile, logfile_size - 1, "%s.log", session);
7055
7056 data.logfile = logfile;
7057
7058 char *topid = logfile_generate_topid ();
7059
7060 data.topid = topid;
7061 }
7062
7063 // logfile_append() checks for logfile_disable internally to make it easier from here
7064
7065 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
7066 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
7067 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
7068 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
7069 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
7070 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
7071 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
7072 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
7073 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
7074 #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));
7075
7076 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
7077 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
7078 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
7079 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
7080 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
7081 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
7082 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
7083 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
7084
7085 logfile_top_msg ("START");
7086
7087 logfile_top_uint (attack_mode);
7088 logfile_top_uint (attack_kern);
7089 logfile_top_uint (benchmark);
7090 logfile_top_uint (benchmark_mode);
7091 logfile_top_uint (bitmap_min);
7092 logfile_top_uint (bitmap_max);
7093 logfile_top_uint (debug_mode);
7094 logfile_top_uint (force);
7095 logfile_top_uint (gpu_accel);
7096 logfile_top_uint (gpu_async);
7097 logfile_top_uint (gpu_loops);
7098 logfile_top_uint (gpu_temp_abort);
7099 logfile_top_uint (gpu_temp_disable);
7100 logfile_top_uint (gpu_temp_retain);
7101 logfile_top_uint (hash_mode);
7102 logfile_top_uint (hex_charset);
7103 logfile_top_uint (hex_salt);
7104 logfile_top_uint (hex_wordlist);
7105 logfile_top_uint (increment);
7106 logfile_top_uint (increment_max);
7107 logfile_top_uint (increment_min);
7108 logfile_top_uint (keyspace);
7109 logfile_top_uint (left);
7110 logfile_top_uint (logfile_disable);
7111 logfile_top_uint (loopback);
7112 logfile_top_uint (markov_classic);
7113 logfile_top_uint (markov_disable);
7114 logfile_top_uint (markov_threshold);
7115 logfile_top_uint (outfile_autohex);
7116 logfile_top_uint (outfile_check_timer);
7117 logfile_top_uint (outfile_format);
7118 logfile_top_uint (potfile_disable);
7119 logfile_top_uint (powertune_enable);
7120 logfile_top_uint (scrypt_tmto);
7121 logfile_top_uint (quiet);
7122 logfile_top_uint (remove);
7123 logfile_top_uint (remove_timer);
7124 logfile_top_uint (restore);
7125 logfile_top_uint (restore_disable);
7126 logfile_top_uint (restore_timer);
7127 logfile_top_uint (rp_gen);
7128 logfile_top_uint (rp_gen_func_max);
7129 logfile_top_uint (rp_gen_func_min);
7130 logfile_top_uint (rp_gen_seed);
7131 logfile_top_uint (runtime);
7132 logfile_top_uint (segment_size);
7133 logfile_top_uint (show);
7134 logfile_top_uint (status);
7135 logfile_top_uint (status_automat);
7136 logfile_top_uint (status_timer);
7137 logfile_top_uint (usage);
7138 logfile_top_uint (username);
7139 logfile_top_uint (version);
7140 logfile_top_uint (weak_hash_threshold);
7141 logfile_top_uint (workload_profile);
7142 logfile_top_uint64 (limit);
7143 logfile_top_uint64 (skip);
7144 logfile_top_char (separator);
7145 logfile_top_string (cpu_affinity);
7146 logfile_top_string (custom_charset_1);
7147 logfile_top_string (custom_charset_2);
7148 logfile_top_string (custom_charset_3);
7149 logfile_top_string (custom_charset_4);
7150 logfile_top_string (debug_file);
7151 logfile_top_string (gpu_devices);
7152 logfile_top_string (induction_dir);
7153 logfile_top_string (markov_hcstat);
7154 logfile_top_string (outfile);
7155 logfile_top_string (outfile_check_dir);
7156 logfile_top_string (rule_buf_l);
7157 logfile_top_string (rule_buf_r);
7158 logfile_top_string (session);
7159 logfile_top_string (truecrypt_keyfiles);
7160
7161 /**
7162 * devices
7163 */
7164
7165 uint gpu_devicemask = devices_to_devicemask (gpu_devices);
7166
7167 /**
7168 * benchmark
7169 */
7170
7171 if (benchmark == 1)
7172 {
7173 /**
7174 * disable useless stuff for benchmark
7175 */
7176
7177 restore_timer = 0;
7178 status_timer = 0;
7179 restore_disable = 1;
7180 potfile_disable = 1;
7181 weak_hash_threshold = 0;
7182
7183 data.restore_timer = restore_timer;
7184 data.status_timer = status_timer;
7185 data.restore_disable = restore_disable;
7186
7187 if (benchmark_mode == 1)
7188 {
7189 markov_disable = 1;
7190 }
7191
7192 /**
7193 * force attack mode to be bruteforce
7194 */
7195
7196 attack_mode = ATTACK_MODE_BF;
7197 attack_kern = ATTACK_KERN_BF;
7198
7199 if (runtime_chgd == 0)
7200 {
7201 runtime = 4;
7202
7203 if (benchmark_mode == 1) runtime = 17;
7204
7205 data.runtime = runtime;
7206 }
7207 }
7208
7209 /**
7210 * config
7211 */
7212
7213 uint hash_type = 0;
7214 uint salt_type = 0;
7215 uint attack_exec = 0;
7216 uint opts_type = 0;
7217 uint kern_type = 0;
7218 uint dgst_size = 0;
7219 uint esalt_size = 0;
7220 uint opti_type = 0;
7221 uint dgst_pos0 = -1;
7222 uint dgst_pos1 = -1;
7223 uint dgst_pos2 = -1;
7224 uint dgst_pos3 = -1;
7225
7226 int (*parse_func) (char *, uint, hash_t *);
7227 int (*sort_by_digest) (const void *, const void *);
7228
7229 uint algorithm_pos = 0;
7230 uint algorithm_max = 1;
7231
7232 uint *algorithms = default_benchmark_algorithms;
7233
7234 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
7235
7236 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
7237 {
7238 /*
7239 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
7240 * the following algos are skipped entirely
7241 */
7242
7243 if (algorithm_pos > 0)
7244 {
7245 local_free (rd);
7246
7247 rd = init_restore (argc, argv);
7248
7249 data.rd = rd;
7250 }
7251
7252 /**
7253 * update hash_mode in case of multihash benchmark
7254 */
7255
7256 if (benchmark == 1)
7257 {
7258 if (hash_mode_chgd == 0)
7259 {
7260 hash_mode = algorithms[algorithm_pos];
7261
7262 data.hash_mode = hash_mode;
7263 }
7264
7265 quiet = 1;
7266
7267 data.quiet = quiet;
7268 }
7269
7270 switch (hash_mode)
7271 {
7272 case 0: hash_type = HASH_TYPE_MD5;
7273 salt_type = SALT_TYPE_NONE;
7274 attack_exec = ATTACK_EXEC_ON_GPU;
7275 opts_type = OPTS_TYPE_PT_GENERATE_LE
7276 | OPTS_TYPE_PT_ADD80
7277 | OPTS_TYPE_PT_ADDBITS14;
7278 kern_type = KERN_TYPE_MD5;
7279 dgst_size = DGST_SIZE_4_4;
7280 parse_func = md5_parse_hash;
7281 sort_by_digest = sort_by_digest_4_4;
7282 opti_type = OPTI_TYPE_ZERO_BYTE
7283 | OPTI_TYPE_PRECOMPUTE_INIT
7284 | OPTI_TYPE_PRECOMPUTE_MERKLE
7285 | OPTI_TYPE_SCALAR_MODE
7286 | OPTI_TYPE_MEET_IN_MIDDLE
7287 | OPTI_TYPE_EARLY_SKIP
7288 | OPTI_TYPE_NOT_ITERATED
7289 | OPTI_TYPE_NOT_SALTED
7290 | OPTI_TYPE_RAW_HASH;
7291 dgst_pos0 = 0;
7292 dgst_pos1 = 3;
7293 dgst_pos2 = 2;
7294 dgst_pos3 = 1;
7295 break;
7296
7297 case 10: hash_type = HASH_TYPE_MD5;
7298 salt_type = SALT_TYPE_INTERN;
7299 attack_exec = ATTACK_EXEC_ON_GPU;
7300 opts_type = OPTS_TYPE_PT_GENERATE_LE
7301 | OPTS_TYPE_ST_ADD80
7302 | OPTS_TYPE_ST_ADDBITS14;
7303 kern_type = KERN_TYPE_MD5_PWSLT;
7304 dgst_size = DGST_SIZE_4_4;
7305 parse_func = md5s_parse_hash;
7306 sort_by_digest = sort_by_digest_4_4;
7307 opti_type = OPTI_TYPE_ZERO_BYTE
7308 | OPTI_TYPE_PRECOMPUTE_INIT
7309 | OPTI_TYPE_PRECOMPUTE_MERKLE
7310 | OPTI_TYPE_SCALAR_MODE
7311 | OPTI_TYPE_MEET_IN_MIDDLE
7312 | OPTI_TYPE_EARLY_SKIP
7313 | OPTI_TYPE_NOT_ITERATED
7314 | OPTI_TYPE_APPENDED_SALT
7315 | OPTI_TYPE_RAW_HASH;
7316 dgst_pos0 = 0;
7317 dgst_pos1 = 3;
7318 dgst_pos2 = 2;
7319 dgst_pos3 = 1;
7320 break;
7321
7322 case 11: hash_type = HASH_TYPE_MD5;
7323 salt_type = SALT_TYPE_INTERN;
7324 attack_exec = ATTACK_EXEC_ON_GPU;
7325 opts_type = OPTS_TYPE_PT_GENERATE_LE
7326 | OPTS_TYPE_ST_ADD80
7327 | OPTS_TYPE_ST_ADDBITS14;
7328 kern_type = KERN_TYPE_MD5_PWSLT;
7329 dgst_size = DGST_SIZE_4_4;
7330 parse_func = joomla_parse_hash;
7331 sort_by_digest = sort_by_digest_4_4;
7332 opti_type = OPTI_TYPE_ZERO_BYTE
7333 | OPTI_TYPE_PRECOMPUTE_INIT
7334 | OPTI_TYPE_PRECOMPUTE_MERKLE
7335 | OPTI_TYPE_SCALAR_MODE
7336 | OPTI_TYPE_MEET_IN_MIDDLE
7337 | OPTI_TYPE_EARLY_SKIP
7338 | OPTI_TYPE_NOT_ITERATED
7339 | OPTI_TYPE_APPENDED_SALT
7340 | OPTI_TYPE_RAW_HASH;
7341 dgst_pos0 = 0;
7342 dgst_pos1 = 3;
7343 dgst_pos2 = 2;
7344 dgst_pos3 = 1;
7345 break;
7346
7347 case 12: hash_type = HASH_TYPE_MD5;
7348 salt_type = SALT_TYPE_INTERN;
7349 attack_exec = ATTACK_EXEC_ON_GPU;
7350 opts_type = OPTS_TYPE_PT_GENERATE_LE
7351 | OPTS_TYPE_ST_ADD80
7352 | OPTS_TYPE_ST_ADDBITS14;
7353 kern_type = KERN_TYPE_MD5_PWSLT;
7354 dgst_size = DGST_SIZE_4_4;
7355 parse_func = postgresql_parse_hash;
7356 sort_by_digest = sort_by_digest_4_4;
7357 opti_type = OPTI_TYPE_ZERO_BYTE
7358 | OPTI_TYPE_PRECOMPUTE_INIT
7359 | OPTI_TYPE_PRECOMPUTE_MERKLE
7360 | OPTI_TYPE_SCALAR_MODE
7361 | OPTI_TYPE_MEET_IN_MIDDLE
7362 | OPTI_TYPE_EARLY_SKIP
7363 | OPTI_TYPE_NOT_ITERATED
7364 | OPTI_TYPE_APPENDED_SALT
7365 | OPTI_TYPE_RAW_HASH;
7366 dgst_pos0 = 0;
7367 dgst_pos1 = 3;
7368 dgst_pos2 = 2;
7369 dgst_pos3 = 1;
7370 break;
7371
7372 case 20: hash_type = HASH_TYPE_MD5;
7373 salt_type = SALT_TYPE_INTERN;
7374 attack_exec = ATTACK_EXEC_ON_GPU;
7375 opts_type = OPTS_TYPE_PT_GENERATE_LE
7376 | OPTS_TYPE_PT_ADD80
7377 | OPTS_TYPE_PT_ADDBITS14;
7378 kern_type = KERN_TYPE_MD5_SLTPW;
7379 dgst_size = DGST_SIZE_4_4;
7380 parse_func = md5s_parse_hash;
7381 sort_by_digest = sort_by_digest_4_4;
7382 opti_type = OPTI_TYPE_ZERO_BYTE
7383 | OPTI_TYPE_PRECOMPUTE_INIT
7384 | OPTI_TYPE_PRECOMPUTE_MERKLE
7385 | OPTI_TYPE_EARLY_SKIP
7386 | OPTI_TYPE_NOT_ITERATED
7387 | OPTI_TYPE_PREPENDED_SALT
7388 | OPTI_TYPE_RAW_HASH;
7389 dgst_pos0 = 0;
7390 dgst_pos1 = 3;
7391 dgst_pos2 = 2;
7392 dgst_pos3 = 1;
7393 break;
7394
7395 case 21: hash_type = HASH_TYPE_MD5;
7396 salt_type = SALT_TYPE_INTERN;
7397 attack_exec = ATTACK_EXEC_ON_GPU;
7398 opts_type = OPTS_TYPE_PT_GENERATE_LE
7399 | OPTS_TYPE_PT_ADD80
7400 | OPTS_TYPE_PT_ADDBITS14;
7401 kern_type = KERN_TYPE_MD5_SLTPW;
7402 dgst_size = DGST_SIZE_4_4;
7403 parse_func = osc_parse_hash;
7404 sort_by_digest = sort_by_digest_4_4;
7405 opti_type = OPTI_TYPE_ZERO_BYTE
7406 | OPTI_TYPE_PRECOMPUTE_INIT
7407 | OPTI_TYPE_PRECOMPUTE_MERKLE
7408 | OPTI_TYPE_EARLY_SKIP
7409 | OPTI_TYPE_NOT_ITERATED
7410 | OPTI_TYPE_PREPENDED_SALT
7411 | OPTI_TYPE_RAW_HASH;
7412 dgst_pos0 = 0;
7413 dgst_pos1 = 3;
7414 dgst_pos2 = 2;
7415 dgst_pos3 = 1;
7416 break;
7417
7418 case 22: hash_type = HASH_TYPE_MD5;
7419 salt_type = SALT_TYPE_EMBEDDED;
7420 attack_exec = ATTACK_EXEC_ON_GPU;
7421 opts_type = OPTS_TYPE_PT_GENERATE_LE
7422 | OPTS_TYPE_PT_ADD80
7423 | OPTS_TYPE_PT_ADDBITS14;
7424 kern_type = KERN_TYPE_MD5_SLTPW;
7425 dgst_size = DGST_SIZE_4_4;
7426 parse_func = netscreen_parse_hash;
7427 sort_by_digest = sort_by_digest_4_4;
7428 opti_type = OPTI_TYPE_ZERO_BYTE
7429 | OPTI_TYPE_PRECOMPUTE_INIT
7430 | OPTI_TYPE_PRECOMPUTE_MERKLE
7431 | OPTI_TYPE_EARLY_SKIP
7432 | OPTI_TYPE_NOT_ITERATED
7433 | OPTI_TYPE_PREPENDED_SALT
7434 | OPTI_TYPE_RAW_HASH;
7435 dgst_pos0 = 0;
7436 dgst_pos1 = 3;
7437 dgst_pos2 = 2;
7438 dgst_pos3 = 1;
7439 break;
7440
7441 case 23: hash_type = HASH_TYPE_MD5;
7442 salt_type = SALT_TYPE_EMBEDDED;
7443 attack_exec = ATTACK_EXEC_ON_GPU;
7444 opts_type = OPTS_TYPE_PT_GENERATE_LE
7445 | OPTS_TYPE_PT_ADD80
7446 | OPTS_TYPE_PT_ADDBITS14;
7447 kern_type = KERN_TYPE_MD5_SLTPW;
7448 dgst_size = DGST_SIZE_4_4;
7449 parse_func = skype_parse_hash;
7450 sort_by_digest = sort_by_digest_4_4;
7451 opti_type = OPTI_TYPE_ZERO_BYTE
7452 | OPTI_TYPE_PRECOMPUTE_INIT
7453 | OPTI_TYPE_PRECOMPUTE_MERKLE
7454 | OPTI_TYPE_EARLY_SKIP
7455 | OPTI_TYPE_NOT_ITERATED
7456 | OPTI_TYPE_PREPENDED_SALT
7457 | OPTI_TYPE_RAW_HASH;
7458 dgst_pos0 = 0;
7459 dgst_pos1 = 3;
7460 dgst_pos2 = 2;
7461 dgst_pos3 = 1;
7462 break;
7463
7464 case 30: hash_type = HASH_TYPE_MD5;
7465 salt_type = SALT_TYPE_INTERN;
7466 attack_exec = ATTACK_EXEC_ON_GPU;
7467 opts_type = OPTS_TYPE_PT_GENERATE_LE
7468 | OPTS_TYPE_PT_UNICODE
7469 | OPTS_TYPE_ST_ADD80
7470 | OPTS_TYPE_ST_ADDBITS14;
7471 kern_type = KERN_TYPE_MD5_PWUSLT;
7472 dgst_size = DGST_SIZE_4_4;
7473 parse_func = md5s_parse_hash;
7474 sort_by_digest = sort_by_digest_4_4;
7475 opti_type = OPTI_TYPE_ZERO_BYTE
7476 | OPTI_TYPE_PRECOMPUTE_INIT
7477 | OPTI_TYPE_PRECOMPUTE_MERKLE
7478 | OPTI_TYPE_SCALAR_MODE
7479 | OPTI_TYPE_MEET_IN_MIDDLE
7480 | OPTI_TYPE_EARLY_SKIP
7481 | OPTI_TYPE_NOT_ITERATED
7482 | OPTI_TYPE_APPENDED_SALT
7483 | OPTI_TYPE_RAW_HASH;
7484 dgst_pos0 = 0;
7485 dgst_pos1 = 3;
7486 dgst_pos2 = 2;
7487 dgst_pos3 = 1;
7488 break;
7489
7490 case 40: hash_type = HASH_TYPE_MD5;
7491 salt_type = SALT_TYPE_INTERN;
7492 attack_exec = ATTACK_EXEC_ON_GPU;
7493 opts_type = OPTS_TYPE_PT_GENERATE_LE
7494 | OPTS_TYPE_PT_ADD80
7495 | OPTS_TYPE_PT_ADDBITS14
7496 | OPTS_TYPE_PT_UNICODE;
7497 kern_type = KERN_TYPE_MD5_SLTPWU;
7498 dgst_size = DGST_SIZE_4_4;
7499 parse_func = md5s_parse_hash;
7500 sort_by_digest = sort_by_digest_4_4;
7501 opti_type = OPTI_TYPE_ZERO_BYTE
7502 | OPTI_TYPE_PRECOMPUTE_INIT
7503 | OPTI_TYPE_PRECOMPUTE_MERKLE
7504 | OPTI_TYPE_EARLY_SKIP
7505 | OPTI_TYPE_NOT_ITERATED
7506 | OPTI_TYPE_PREPENDED_SALT
7507 | OPTI_TYPE_RAW_HASH;
7508 dgst_pos0 = 0;
7509 dgst_pos1 = 3;
7510 dgst_pos2 = 2;
7511 dgst_pos3 = 1;
7512 break;
7513
7514 case 50: hash_type = HASH_TYPE_MD5;
7515 salt_type = SALT_TYPE_INTERN;
7516 attack_exec = ATTACK_EXEC_ON_GPU;
7517 opts_type = OPTS_TYPE_PT_GENERATE_LE
7518 | OPTS_TYPE_ST_ADD80
7519 | OPTS_TYPE_ST_ADDBITS14;
7520 kern_type = KERN_TYPE_HMACMD5_PW;
7521 dgst_size = DGST_SIZE_4_4;
7522 parse_func = hmacmd5_parse_hash;
7523 sort_by_digest = sort_by_digest_4_4;
7524 opti_type = OPTI_TYPE_ZERO_BYTE
7525 | OPTI_TYPE_NOT_ITERATED;
7526 dgst_pos0 = 0;
7527 dgst_pos1 = 3;
7528 dgst_pos2 = 2;
7529 dgst_pos3 = 1;
7530 break;
7531
7532 case 60: hash_type = HASH_TYPE_MD5;
7533 salt_type = SALT_TYPE_INTERN;
7534 attack_exec = ATTACK_EXEC_ON_GPU;
7535 opts_type = OPTS_TYPE_PT_GENERATE_LE
7536 | OPTS_TYPE_PT_ADD80
7537 | OPTS_TYPE_PT_ADDBITS14;
7538 kern_type = KERN_TYPE_HMACMD5_SLT;
7539 dgst_size = DGST_SIZE_4_4;
7540 parse_func = hmacmd5_parse_hash;
7541 sort_by_digest = sort_by_digest_4_4;
7542 opti_type = OPTI_TYPE_ZERO_BYTE
7543 | OPTI_TYPE_NOT_ITERATED;
7544 dgst_pos0 = 0;
7545 dgst_pos1 = 3;
7546 dgst_pos2 = 2;
7547 dgst_pos3 = 1;
7548 break;
7549
7550 case 100: hash_type = HASH_TYPE_SHA1;
7551 salt_type = SALT_TYPE_NONE;
7552 attack_exec = ATTACK_EXEC_ON_GPU;
7553 opts_type = OPTS_TYPE_PT_GENERATE_BE
7554 | OPTS_TYPE_PT_ADD80
7555 | OPTS_TYPE_PT_ADDBITS15;
7556 kern_type = KERN_TYPE_SHA1;
7557 dgst_size = DGST_SIZE_4_5;
7558 parse_func = sha1_parse_hash;
7559 sort_by_digest = sort_by_digest_4_5;
7560 opti_type = OPTI_TYPE_ZERO_BYTE
7561 | OPTI_TYPE_PRECOMPUTE_INIT
7562 | OPTI_TYPE_PRECOMPUTE_MERKLE
7563 | OPTI_TYPE_SCALAR_MODE
7564 | OPTI_TYPE_EARLY_SKIP
7565 | OPTI_TYPE_NOT_ITERATED
7566 | OPTI_TYPE_NOT_SALTED
7567 | OPTI_TYPE_RAW_HASH;
7568 dgst_pos0 = 3;
7569 dgst_pos1 = 4;
7570 dgst_pos2 = 2;
7571 dgst_pos3 = 1;
7572 break;
7573
7574 case 101: hash_type = HASH_TYPE_SHA1;
7575 salt_type = SALT_TYPE_NONE;
7576 attack_exec = ATTACK_EXEC_ON_GPU;
7577 opts_type = OPTS_TYPE_PT_GENERATE_BE
7578 | OPTS_TYPE_PT_ADD80
7579 | OPTS_TYPE_PT_ADDBITS15;
7580 kern_type = KERN_TYPE_SHA1;
7581 dgst_size = DGST_SIZE_4_5;
7582 parse_func = sha1b64_parse_hash;
7583 sort_by_digest = sort_by_digest_4_5;
7584 opti_type = OPTI_TYPE_ZERO_BYTE
7585 | OPTI_TYPE_PRECOMPUTE_INIT
7586 | OPTI_TYPE_PRECOMPUTE_MERKLE
7587 | OPTI_TYPE_SCALAR_MODE
7588 | OPTI_TYPE_EARLY_SKIP
7589 | OPTI_TYPE_NOT_ITERATED
7590 | OPTI_TYPE_NOT_SALTED
7591 | OPTI_TYPE_RAW_HASH;
7592 dgst_pos0 = 3;
7593 dgst_pos1 = 4;
7594 dgst_pos2 = 2;
7595 dgst_pos3 = 1;
7596 break;
7597
7598 case 110: hash_type = HASH_TYPE_SHA1;
7599 salt_type = SALT_TYPE_INTERN;
7600 attack_exec = ATTACK_EXEC_ON_GPU;
7601 opts_type = OPTS_TYPE_PT_GENERATE_BE
7602 | OPTS_TYPE_ST_ADD80
7603 | OPTS_TYPE_ST_ADDBITS15;
7604 kern_type = KERN_TYPE_SHA1_PWSLT;
7605 dgst_size = DGST_SIZE_4_5;
7606 parse_func = sha1s_parse_hash;
7607 sort_by_digest = sort_by_digest_4_5;
7608 opti_type = OPTI_TYPE_ZERO_BYTE
7609 | OPTI_TYPE_PRECOMPUTE_INIT
7610 | OPTI_TYPE_PRECOMPUTE_MERKLE
7611 | OPTI_TYPE_SCALAR_MODE
7612 | OPTI_TYPE_EARLY_SKIP
7613 | OPTI_TYPE_NOT_ITERATED
7614 | OPTI_TYPE_APPENDED_SALT
7615 | OPTI_TYPE_RAW_HASH;
7616 dgst_pos0 = 3;
7617 dgst_pos1 = 4;
7618 dgst_pos2 = 2;
7619 dgst_pos3 = 1;
7620 break;
7621
7622 case 111: hash_type = HASH_TYPE_SHA1;
7623 salt_type = SALT_TYPE_EMBEDDED;
7624 attack_exec = ATTACK_EXEC_ON_GPU;
7625 opts_type = OPTS_TYPE_PT_GENERATE_BE
7626 | OPTS_TYPE_ST_ADD80
7627 | OPTS_TYPE_ST_ADDBITS15;
7628 kern_type = KERN_TYPE_SHA1_PWSLT;
7629 dgst_size = DGST_SIZE_4_5;
7630 parse_func = sha1b64s_parse_hash;
7631 sort_by_digest = sort_by_digest_4_5;
7632 opti_type = OPTI_TYPE_ZERO_BYTE
7633 | OPTI_TYPE_PRECOMPUTE_INIT
7634 | OPTI_TYPE_PRECOMPUTE_MERKLE
7635 | OPTI_TYPE_SCALAR_MODE
7636 | OPTI_TYPE_EARLY_SKIP
7637 | OPTI_TYPE_NOT_ITERATED
7638 | OPTI_TYPE_APPENDED_SALT
7639 | OPTI_TYPE_RAW_HASH;
7640 dgst_pos0 = 3;
7641 dgst_pos1 = 4;
7642 dgst_pos2 = 2;
7643 dgst_pos3 = 1;
7644 break;
7645
7646 case 112: hash_type = HASH_TYPE_SHA1;
7647 salt_type = SALT_TYPE_INTERN;
7648 attack_exec = ATTACK_EXEC_ON_GPU;
7649 opts_type = OPTS_TYPE_PT_GENERATE_BE
7650 | OPTS_TYPE_ST_ADD80
7651 | OPTS_TYPE_ST_ADDBITS15
7652 | OPTS_TYPE_ST_HEX;
7653 kern_type = KERN_TYPE_SHA1_PWSLT;
7654 dgst_size = DGST_SIZE_4_5;
7655 parse_func = oracles_parse_hash;
7656 sort_by_digest = sort_by_digest_4_5;
7657 opti_type = OPTI_TYPE_ZERO_BYTE
7658 | OPTI_TYPE_PRECOMPUTE_INIT
7659 | OPTI_TYPE_PRECOMPUTE_MERKLE
7660 | OPTI_TYPE_SCALAR_MODE
7661 | OPTI_TYPE_EARLY_SKIP
7662 | OPTI_TYPE_NOT_ITERATED
7663 | OPTI_TYPE_APPENDED_SALT
7664 | OPTI_TYPE_RAW_HASH;
7665 dgst_pos0 = 3;
7666 dgst_pos1 = 4;
7667 dgst_pos2 = 2;
7668 dgst_pos3 = 1;
7669 break;
7670
7671 case 120: hash_type = HASH_TYPE_SHA1;
7672 salt_type = SALT_TYPE_INTERN;
7673 attack_exec = ATTACK_EXEC_ON_GPU;
7674 opts_type = OPTS_TYPE_PT_GENERATE_BE
7675 | OPTS_TYPE_PT_ADD80
7676 | OPTS_TYPE_PT_ADDBITS15;
7677 kern_type = KERN_TYPE_SHA1_SLTPW;
7678 dgst_size = DGST_SIZE_4_5;
7679 parse_func = sha1s_parse_hash;
7680 sort_by_digest = sort_by_digest_4_5;
7681 opti_type = OPTI_TYPE_ZERO_BYTE
7682 | OPTI_TYPE_PRECOMPUTE_INIT
7683 | OPTI_TYPE_PRECOMPUTE_MERKLE
7684 | OPTI_TYPE_EARLY_SKIP
7685 | OPTI_TYPE_NOT_ITERATED
7686 | OPTI_TYPE_PREPENDED_SALT
7687 | OPTI_TYPE_RAW_HASH;
7688 dgst_pos0 = 3;
7689 dgst_pos1 = 4;
7690 dgst_pos2 = 2;
7691 dgst_pos3 = 1;
7692 break;
7693
7694 case 121: hash_type = HASH_TYPE_SHA1;
7695 salt_type = SALT_TYPE_INTERN;
7696 attack_exec = ATTACK_EXEC_ON_GPU;
7697 opts_type = OPTS_TYPE_PT_GENERATE_BE
7698 | OPTS_TYPE_PT_ADD80
7699 | OPTS_TYPE_PT_ADDBITS15
7700 | OPTS_TYPE_ST_LOWER;
7701 kern_type = KERN_TYPE_SHA1_SLTPW;
7702 dgst_size = DGST_SIZE_4_5;
7703 parse_func = smf_parse_hash;
7704 sort_by_digest = sort_by_digest_4_5;
7705 opti_type = OPTI_TYPE_ZERO_BYTE
7706 | OPTI_TYPE_PRECOMPUTE_INIT
7707 | OPTI_TYPE_PRECOMPUTE_MERKLE
7708 | OPTI_TYPE_EARLY_SKIP
7709 | OPTI_TYPE_NOT_ITERATED
7710 | OPTI_TYPE_PREPENDED_SALT
7711 | OPTI_TYPE_RAW_HASH;
7712 dgst_pos0 = 3;
7713 dgst_pos1 = 4;
7714 dgst_pos2 = 2;
7715 dgst_pos3 = 1;
7716 break;
7717
7718 case 122: hash_type = HASH_TYPE_SHA1;
7719 salt_type = SALT_TYPE_EMBEDDED;
7720 attack_exec = ATTACK_EXEC_ON_GPU;
7721 opts_type = OPTS_TYPE_PT_GENERATE_BE
7722 | OPTS_TYPE_PT_ADD80
7723 | OPTS_TYPE_PT_ADDBITS15
7724 | OPTS_TYPE_ST_HEX;
7725 kern_type = KERN_TYPE_SHA1_SLTPW;
7726 dgst_size = DGST_SIZE_4_5;
7727 parse_func = osx1_parse_hash;
7728 sort_by_digest = sort_by_digest_4_5;
7729 opti_type = OPTI_TYPE_ZERO_BYTE
7730 | OPTI_TYPE_PRECOMPUTE_INIT
7731 | OPTI_TYPE_PRECOMPUTE_MERKLE
7732 | OPTI_TYPE_EARLY_SKIP
7733 | OPTI_TYPE_NOT_ITERATED
7734 | OPTI_TYPE_PREPENDED_SALT
7735 | OPTI_TYPE_RAW_HASH;
7736 dgst_pos0 = 3;
7737 dgst_pos1 = 4;
7738 dgst_pos2 = 2;
7739 dgst_pos3 = 1;
7740 break;
7741
7742 case 124: hash_type = HASH_TYPE_SHA1;
7743 salt_type = SALT_TYPE_EMBEDDED;
7744 attack_exec = ATTACK_EXEC_ON_GPU;
7745 opts_type = OPTS_TYPE_PT_GENERATE_BE
7746 | OPTS_TYPE_PT_ADD80
7747 | OPTS_TYPE_PT_ADDBITS15;
7748 kern_type = KERN_TYPE_SHA1_SLTPW;
7749 dgst_size = DGST_SIZE_4_5;
7750 parse_func = djangosha1_parse_hash;
7751 sort_by_digest = sort_by_digest_4_5;
7752 opti_type = OPTI_TYPE_ZERO_BYTE
7753 | OPTI_TYPE_PRECOMPUTE_INIT
7754 | OPTI_TYPE_PRECOMPUTE_MERKLE
7755 | OPTI_TYPE_EARLY_SKIP
7756 | OPTI_TYPE_NOT_ITERATED
7757 | OPTI_TYPE_PREPENDED_SALT
7758 | OPTI_TYPE_RAW_HASH;
7759 dgst_pos0 = 3;
7760 dgst_pos1 = 4;
7761 dgst_pos2 = 2;
7762 dgst_pos3 = 1;
7763 break;
7764
7765 case 130: hash_type = HASH_TYPE_SHA1;
7766 salt_type = SALT_TYPE_INTERN;
7767 attack_exec = ATTACK_EXEC_ON_GPU;
7768 opts_type = OPTS_TYPE_PT_GENERATE_BE
7769 | OPTS_TYPE_PT_UNICODE
7770 | OPTS_TYPE_ST_ADD80
7771 | OPTS_TYPE_ST_ADDBITS15;
7772 kern_type = KERN_TYPE_SHA1_PWUSLT;
7773 dgst_size = DGST_SIZE_4_5;
7774 parse_func = sha1s_parse_hash;
7775 sort_by_digest = sort_by_digest_4_5;
7776 opti_type = OPTI_TYPE_ZERO_BYTE
7777 | OPTI_TYPE_PRECOMPUTE_INIT
7778 | OPTI_TYPE_PRECOMPUTE_MERKLE
7779 | OPTI_TYPE_SCALAR_MODE
7780 | OPTI_TYPE_EARLY_SKIP
7781 | OPTI_TYPE_NOT_ITERATED
7782 | OPTI_TYPE_APPENDED_SALT
7783 | OPTI_TYPE_RAW_HASH;
7784 dgst_pos0 = 3;
7785 dgst_pos1 = 4;
7786 dgst_pos2 = 2;
7787 dgst_pos3 = 1;
7788 break;
7789
7790 case 131: hash_type = HASH_TYPE_SHA1;
7791 salt_type = SALT_TYPE_EMBEDDED;
7792 attack_exec = ATTACK_EXEC_ON_GPU;
7793 opts_type = OPTS_TYPE_PT_GENERATE_BE
7794 | OPTS_TYPE_PT_UNICODE
7795 | OPTS_TYPE_PT_UPPER
7796 | OPTS_TYPE_ST_ADD80
7797 | OPTS_TYPE_ST_ADDBITS15
7798 | OPTS_TYPE_ST_HEX;
7799 kern_type = KERN_TYPE_SHA1_PWUSLT;
7800 dgst_size = DGST_SIZE_4_5;
7801 parse_func = mssql2000_parse_hash;
7802 sort_by_digest = sort_by_digest_4_5;
7803 opti_type = OPTI_TYPE_ZERO_BYTE
7804 | OPTI_TYPE_PRECOMPUTE_INIT
7805 | OPTI_TYPE_PRECOMPUTE_MERKLE
7806 | OPTI_TYPE_SCALAR_MODE
7807 | OPTI_TYPE_EARLY_SKIP
7808 | OPTI_TYPE_NOT_ITERATED
7809 | OPTI_TYPE_APPENDED_SALT
7810 | OPTI_TYPE_RAW_HASH;
7811 dgst_pos0 = 3;
7812 dgst_pos1 = 4;
7813 dgst_pos2 = 2;
7814 dgst_pos3 = 1;
7815 break;
7816
7817 case 132: hash_type = HASH_TYPE_SHA1;
7818 salt_type = SALT_TYPE_EMBEDDED;
7819 attack_exec = ATTACK_EXEC_ON_GPU;
7820 opts_type = OPTS_TYPE_PT_GENERATE_BE
7821 | OPTS_TYPE_PT_UNICODE
7822 | OPTS_TYPE_ST_ADD80
7823 | OPTS_TYPE_ST_ADDBITS15
7824 | OPTS_TYPE_ST_HEX;
7825 kern_type = KERN_TYPE_SHA1_PWUSLT;
7826 dgst_size = DGST_SIZE_4_5;
7827 parse_func = mssql2005_parse_hash;
7828 sort_by_digest = sort_by_digest_4_5;
7829 opti_type = OPTI_TYPE_ZERO_BYTE
7830 | OPTI_TYPE_PRECOMPUTE_INIT
7831 | OPTI_TYPE_PRECOMPUTE_MERKLE
7832 | OPTI_TYPE_SCALAR_MODE
7833 | OPTI_TYPE_EARLY_SKIP
7834 | OPTI_TYPE_NOT_ITERATED
7835 | OPTI_TYPE_APPENDED_SALT
7836 | OPTI_TYPE_RAW_HASH;
7837 dgst_pos0 = 3;
7838 dgst_pos1 = 4;
7839 dgst_pos2 = 2;
7840 dgst_pos3 = 1;
7841 break;
7842
7843 case 133: hash_type = HASH_TYPE_SHA1;
7844 salt_type = SALT_TYPE_EMBEDDED;
7845 attack_exec = ATTACK_EXEC_ON_GPU;
7846 opts_type = OPTS_TYPE_PT_GENERATE_BE
7847 | OPTS_TYPE_PT_UNICODE
7848 | OPTS_TYPE_ST_ADD80
7849 | OPTS_TYPE_ST_ADDBITS15;
7850 kern_type = KERN_TYPE_SHA1_PWUSLT;
7851 dgst_size = DGST_SIZE_4_5;
7852 parse_func = peoplesoft_parse_hash;
7853 sort_by_digest = sort_by_digest_4_5;
7854 opti_type = OPTI_TYPE_ZERO_BYTE
7855 | OPTI_TYPE_PRECOMPUTE_INIT
7856 | OPTI_TYPE_PRECOMPUTE_MERKLE
7857 | OPTI_TYPE_SCALAR_MODE
7858 | OPTI_TYPE_EARLY_SKIP
7859 | OPTI_TYPE_NOT_ITERATED
7860 | OPTI_TYPE_APPENDED_SALT
7861 | OPTI_TYPE_RAW_HASH;
7862 dgst_pos0 = 3;
7863 dgst_pos1 = 4;
7864 dgst_pos2 = 2;
7865 dgst_pos3 = 1;
7866 break;
7867
7868 case 140: hash_type = HASH_TYPE_SHA1;
7869 salt_type = SALT_TYPE_INTERN;
7870 attack_exec = ATTACK_EXEC_ON_GPU;
7871 opts_type = OPTS_TYPE_PT_GENERATE_BE
7872 | OPTS_TYPE_PT_ADD80
7873 | OPTS_TYPE_PT_ADDBITS15
7874 | OPTS_TYPE_PT_UNICODE;
7875 kern_type = KERN_TYPE_SHA1_SLTPWU;
7876 dgst_size = DGST_SIZE_4_5;
7877 parse_func = sha1s_parse_hash;
7878 sort_by_digest = sort_by_digest_4_5;
7879 opti_type = OPTI_TYPE_ZERO_BYTE
7880 | OPTI_TYPE_PRECOMPUTE_INIT
7881 | OPTI_TYPE_PRECOMPUTE_MERKLE
7882 | OPTI_TYPE_EARLY_SKIP
7883 | OPTI_TYPE_NOT_ITERATED
7884 | OPTI_TYPE_PREPENDED_SALT
7885 | OPTI_TYPE_RAW_HASH;
7886 dgst_pos0 = 3;
7887 dgst_pos1 = 4;
7888 dgst_pos2 = 2;
7889 dgst_pos3 = 1;
7890 break;
7891
7892 case 141: hash_type = HASH_TYPE_SHA1;
7893 salt_type = SALT_TYPE_EMBEDDED;
7894 attack_exec = ATTACK_EXEC_ON_GPU;
7895 opts_type = OPTS_TYPE_PT_GENERATE_BE
7896 | OPTS_TYPE_PT_ADD80
7897 | OPTS_TYPE_PT_ADDBITS15
7898 | OPTS_TYPE_PT_UNICODE
7899 | OPTS_TYPE_ST_BASE64;
7900 kern_type = KERN_TYPE_SHA1_SLTPWU;
7901 dgst_size = DGST_SIZE_4_5;
7902 parse_func = episerver_parse_hash;
7903 sort_by_digest = sort_by_digest_4_5;
7904 opti_type = OPTI_TYPE_ZERO_BYTE
7905 | OPTI_TYPE_PRECOMPUTE_INIT
7906 | OPTI_TYPE_PRECOMPUTE_MERKLE
7907 | OPTI_TYPE_EARLY_SKIP
7908 | OPTI_TYPE_NOT_ITERATED
7909 | OPTI_TYPE_PREPENDED_SALT
7910 | OPTI_TYPE_RAW_HASH;
7911 dgst_pos0 = 3;
7912 dgst_pos1 = 4;
7913 dgst_pos2 = 2;
7914 dgst_pos3 = 1;
7915 break;
7916
7917 case 150: hash_type = HASH_TYPE_SHA1;
7918 salt_type = SALT_TYPE_INTERN;
7919 attack_exec = ATTACK_EXEC_ON_GPU;
7920 opts_type = OPTS_TYPE_PT_GENERATE_BE
7921 | OPTS_TYPE_ST_ADD80
7922 | OPTS_TYPE_ST_ADDBITS15;
7923 kern_type = KERN_TYPE_HMACSHA1_PW;
7924 dgst_size = DGST_SIZE_4_5;
7925 parse_func = hmacsha1_parse_hash;
7926 sort_by_digest = sort_by_digest_4_5;
7927 opti_type = OPTI_TYPE_ZERO_BYTE
7928 | OPTI_TYPE_NOT_ITERATED;
7929 dgst_pos0 = 3;
7930 dgst_pos1 = 4;
7931 dgst_pos2 = 2;
7932 dgst_pos3 = 1;
7933 break;
7934
7935 case 160: hash_type = HASH_TYPE_SHA1;
7936 salt_type = SALT_TYPE_INTERN;
7937 attack_exec = ATTACK_EXEC_ON_GPU;
7938 opts_type = OPTS_TYPE_PT_GENERATE_BE
7939 | OPTS_TYPE_PT_ADD80
7940 | OPTS_TYPE_PT_ADDBITS15;
7941 kern_type = KERN_TYPE_HMACSHA1_SLT;
7942 dgst_size = DGST_SIZE_4_5;
7943 parse_func = hmacsha1_parse_hash;
7944 sort_by_digest = sort_by_digest_4_5;
7945 opti_type = OPTI_TYPE_ZERO_BYTE
7946 | OPTI_TYPE_NOT_ITERATED;
7947 dgst_pos0 = 3;
7948 dgst_pos1 = 4;
7949 dgst_pos2 = 2;
7950 dgst_pos3 = 1;
7951 break;
7952
7953 case 190: hash_type = HASH_TYPE_SHA1;
7954 salt_type = SALT_TYPE_NONE;
7955 attack_exec = ATTACK_EXEC_ON_GPU;
7956 opts_type = OPTS_TYPE_PT_GENERATE_BE
7957 | OPTS_TYPE_PT_ADD80
7958 | OPTS_TYPE_PT_ADDBITS15;
7959 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7960 dgst_size = DGST_SIZE_4_5;
7961 parse_func = sha1linkedin_parse_hash;
7962 sort_by_digest = sort_by_digest_4_5;
7963 opti_type = OPTI_TYPE_ZERO_BYTE
7964 | OPTI_TYPE_PRECOMPUTE_INIT
7965 | OPTI_TYPE_SCALAR_MODE
7966 | OPTI_TYPE_EARLY_SKIP
7967 | OPTI_TYPE_NOT_ITERATED
7968 | OPTI_TYPE_NOT_SALTED;
7969 dgst_pos0 = 0;
7970 dgst_pos1 = 4;
7971 dgst_pos2 = 3;
7972 dgst_pos3 = 2;
7973 break;
7974
7975 case 200: hash_type = HASH_TYPE_MYSQL;
7976 salt_type = SALT_TYPE_NONE;
7977 attack_exec = ATTACK_EXEC_ON_GPU;
7978 opts_type = 0;
7979 kern_type = KERN_TYPE_MYSQL;
7980 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7981 parse_func = mysql323_parse_hash;
7982 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7983 opti_type = OPTI_TYPE_ZERO_BYTE
7984 | OPTI_TYPE_SCALAR_MODE;
7985 dgst_pos0 = 0;
7986 dgst_pos1 = 1;
7987 dgst_pos2 = 2;
7988 dgst_pos3 = 3;
7989 break;
7990
7991 case 300: hash_type = HASH_TYPE_SHA1;
7992 salt_type = SALT_TYPE_NONE;
7993 attack_exec = ATTACK_EXEC_ON_GPU;
7994 opts_type = OPTS_TYPE_PT_GENERATE_BE
7995 | OPTS_TYPE_PT_ADD80
7996 | OPTS_TYPE_PT_ADDBITS15;
7997 kern_type = KERN_TYPE_MYSQL41;
7998 dgst_size = DGST_SIZE_4_5;
7999 parse_func = sha1_parse_hash;
8000 sort_by_digest = sort_by_digest_4_5;
8001 opti_type = OPTI_TYPE_ZERO_BYTE
8002 | OPTI_TYPE_PRECOMPUTE_INIT
8003 | OPTI_TYPE_PRECOMPUTE_MERKLE
8004 | OPTI_TYPE_SCALAR_MODE
8005 | OPTI_TYPE_EARLY_SKIP
8006 | OPTI_TYPE_NOT_ITERATED
8007 | OPTI_TYPE_NOT_SALTED;
8008 dgst_pos0 = 3;
8009 dgst_pos1 = 4;
8010 dgst_pos2 = 2;
8011 dgst_pos3 = 1;
8012 break;
8013
8014 case 400: hash_type = HASH_TYPE_MD5;
8015 salt_type = SALT_TYPE_EMBEDDED;
8016 attack_exec = ATTACK_EXEC_ON_CPU;
8017 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8018 kern_type = KERN_TYPE_PHPASS;
8019 dgst_size = DGST_SIZE_4_4;
8020 parse_func = phpass_parse_hash;
8021 sort_by_digest = sort_by_digest_4_4;
8022 opti_type = OPTI_TYPE_ZERO_BYTE;
8023 dgst_pos0 = 0;
8024 dgst_pos1 = 1;
8025 dgst_pos2 = 2;
8026 dgst_pos3 = 3;
8027 break;
8028
8029 case 500: hash_type = HASH_TYPE_MD5;
8030 salt_type = SALT_TYPE_EMBEDDED;
8031 attack_exec = ATTACK_EXEC_ON_CPU;
8032 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8033 kern_type = KERN_TYPE_MD5CRYPT;
8034 dgst_size = DGST_SIZE_4_4;
8035 parse_func = md5crypt_parse_hash;
8036 sort_by_digest = sort_by_digest_4_4;
8037 opti_type = OPTI_TYPE_ZERO_BYTE;
8038 dgst_pos0 = 0;
8039 dgst_pos1 = 1;
8040 dgst_pos2 = 2;
8041 dgst_pos3 = 3;
8042 break;
8043
8044 case 501: hash_type = HASH_TYPE_MD5;
8045 salt_type = SALT_TYPE_EMBEDDED;
8046 attack_exec = ATTACK_EXEC_ON_CPU;
8047 opts_type = OPTS_TYPE_PT_GENERATE_LE
8048 | OPTS_TYPE_HASH_COPY;
8049 kern_type = KERN_TYPE_MD5CRYPT;
8050 dgst_size = DGST_SIZE_4_4;
8051 parse_func = juniper_parse_hash;
8052 sort_by_digest = sort_by_digest_4_4;
8053 opti_type = OPTI_TYPE_ZERO_BYTE;
8054 dgst_pos0 = 0;
8055 dgst_pos1 = 1;
8056 dgst_pos2 = 2;
8057 dgst_pos3 = 3;
8058 break;
8059
8060 case 900: hash_type = HASH_TYPE_MD4;
8061 salt_type = SALT_TYPE_NONE;
8062 attack_exec = ATTACK_EXEC_ON_GPU;
8063 opts_type = OPTS_TYPE_PT_GENERATE_LE
8064 | OPTS_TYPE_PT_ADD80
8065 | OPTS_TYPE_PT_ADDBITS14;
8066 kern_type = KERN_TYPE_MD4;
8067 dgst_size = DGST_SIZE_4_4;
8068 parse_func = md4_parse_hash;
8069 sort_by_digest = sort_by_digest_4_4;
8070 opti_type = OPTI_TYPE_ZERO_BYTE
8071 | OPTI_TYPE_PRECOMPUTE_INIT
8072 | OPTI_TYPE_PRECOMPUTE_MERKLE
8073 | OPTI_TYPE_SCALAR_MODE
8074 | OPTI_TYPE_MEET_IN_MIDDLE
8075 | OPTI_TYPE_EARLY_SKIP
8076 | OPTI_TYPE_NOT_ITERATED
8077 | OPTI_TYPE_NOT_SALTED
8078 | OPTI_TYPE_RAW_HASH;
8079 dgst_pos0 = 0;
8080 dgst_pos1 = 3;
8081 dgst_pos2 = 2;
8082 dgst_pos3 = 1;
8083 break;
8084
8085 case 1000: hash_type = HASH_TYPE_MD4;
8086 salt_type = SALT_TYPE_NONE;
8087 attack_exec = ATTACK_EXEC_ON_GPU;
8088 opts_type = OPTS_TYPE_PT_GENERATE_LE
8089 | OPTS_TYPE_PT_ADD80
8090 | OPTS_TYPE_PT_ADDBITS14
8091 | OPTS_TYPE_PT_UNICODE;
8092 kern_type = KERN_TYPE_MD4_PWU;
8093 dgst_size = DGST_SIZE_4_4;
8094 parse_func = md4_parse_hash;
8095 sort_by_digest = sort_by_digest_4_4;
8096 opti_type = OPTI_TYPE_ZERO_BYTE
8097 | OPTI_TYPE_PRECOMPUTE_INIT
8098 | OPTI_TYPE_PRECOMPUTE_MERKLE
8099 | OPTI_TYPE_SCALAR_MODE
8100 | OPTI_TYPE_MEET_IN_MIDDLE
8101 | OPTI_TYPE_EARLY_SKIP
8102 | OPTI_TYPE_NOT_ITERATED
8103 | OPTI_TYPE_NOT_SALTED
8104 | OPTI_TYPE_RAW_HASH;
8105 dgst_pos0 = 0;
8106 dgst_pos1 = 3;
8107 dgst_pos2 = 2;
8108 dgst_pos3 = 1;
8109 break;
8110
8111 case 1100: hash_type = HASH_TYPE_MD4;
8112 salt_type = SALT_TYPE_INTERN;
8113 attack_exec = ATTACK_EXEC_ON_GPU;
8114 opts_type = OPTS_TYPE_PT_GENERATE_LE
8115 | OPTS_TYPE_PT_ADD80
8116 | OPTS_TYPE_PT_ADDBITS14
8117 | OPTS_TYPE_PT_UNICODE
8118 | OPTS_TYPE_ST_ADD80
8119 | OPTS_TYPE_ST_UNICODE
8120 | OPTS_TYPE_ST_LOWER;
8121 kern_type = KERN_TYPE_MD44_PWUSLT;
8122 dgst_size = DGST_SIZE_4_4;
8123 parse_func = dcc_parse_hash;
8124 sort_by_digest = sort_by_digest_4_4;
8125 opti_type = OPTI_TYPE_ZERO_BYTE
8126 | OPTI_TYPE_PRECOMPUTE_INIT
8127 | OPTI_TYPE_PRECOMPUTE_MERKLE
8128 | OPTI_TYPE_SCALAR_MODE
8129 | OPTI_TYPE_EARLY_SKIP
8130 | OPTI_TYPE_NOT_ITERATED;
8131 dgst_pos0 = 0;
8132 dgst_pos1 = 3;
8133 dgst_pos2 = 2;
8134 dgst_pos3 = 1;
8135 break;
8136
8137 case 1400: hash_type = HASH_TYPE_SHA256;
8138 salt_type = SALT_TYPE_NONE;
8139 attack_exec = ATTACK_EXEC_ON_GPU;
8140 opts_type = OPTS_TYPE_PT_GENERATE_BE
8141 | OPTS_TYPE_PT_ADD80
8142 | OPTS_TYPE_PT_ADDBITS15;
8143 kern_type = KERN_TYPE_SHA256;
8144 dgst_size = DGST_SIZE_4_8;
8145 parse_func = sha256_parse_hash;
8146 sort_by_digest = sort_by_digest_4_8;
8147 opti_type = OPTI_TYPE_ZERO_BYTE
8148 | OPTI_TYPE_PRECOMPUTE_INIT
8149 | OPTI_TYPE_PRECOMPUTE_MERKLE
8150 | OPTI_TYPE_SCALAR_MODE
8151 | OPTI_TYPE_EARLY_SKIP
8152 | OPTI_TYPE_NOT_ITERATED
8153 | OPTI_TYPE_NOT_SALTED
8154 | OPTI_TYPE_RAW_HASH;
8155 dgst_pos0 = 3;
8156 dgst_pos1 = 7;
8157 dgst_pos2 = 2;
8158 dgst_pos3 = 6;
8159 break;
8160
8161 case 1410: hash_type = HASH_TYPE_SHA256;
8162 salt_type = SALT_TYPE_INTERN;
8163 attack_exec = ATTACK_EXEC_ON_GPU;
8164 opts_type = OPTS_TYPE_PT_GENERATE_BE
8165 | OPTS_TYPE_ST_ADD80
8166 | OPTS_TYPE_ST_ADDBITS15;
8167 kern_type = KERN_TYPE_SHA256_PWSLT;
8168 dgst_size = DGST_SIZE_4_8;
8169 parse_func = sha256s_parse_hash;
8170 sort_by_digest = sort_by_digest_4_8;
8171 opti_type = OPTI_TYPE_ZERO_BYTE
8172 | OPTI_TYPE_PRECOMPUTE_INIT
8173 | OPTI_TYPE_PRECOMPUTE_MERKLE
8174 | OPTI_TYPE_SCALAR_MODE
8175 | OPTI_TYPE_EARLY_SKIP
8176 | OPTI_TYPE_NOT_ITERATED
8177 | OPTI_TYPE_APPENDED_SALT
8178 | OPTI_TYPE_RAW_HASH;
8179 dgst_pos0 = 3;
8180 dgst_pos1 = 7;
8181 dgst_pos2 = 2;
8182 dgst_pos3 = 6;
8183 break;
8184
8185 case 1420: hash_type = HASH_TYPE_SHA256;
8186 salt_type = SALT_TYPE_INTERN;
8187 attack_exec = ATTACK_EXEC_ON_GPU;
8188 opts_type = OPTS_TYPE_PT_GENERATE_BE
8189 | OPTS_TYPE_PT_ADD80
8190 | OPTS_TYPE_PT_ADDBITS15;
8191 kern_type = KERN_TYPE_SHA256_SLTPW;
8192 dgst_size = DGST_SIZE_4_8;
8193 parse_func = sha256s_parse_hash;
8194 sort_by_digest = sort_by_digest_4_8;
8195 opti_type = OPTI_TYPE_ZERO_BYTE
8196 | OPTI_TYPE_PRECOMPUTE_INIT
8197 | OPTI_TYPE_PRECOMPUTE_MERKLE
8198 | OPTI_TYPE_EARLY_SKIP
8199 | OPTI_TYPE_NOT_ITERATED
8200 | OPTI_TYPE_PREPENDED_SALT
8201 | OPTI_TYPE_RAW_HASH;
8202 dgst_pos0 = 3;
8203 dgst_pos1 = 7;
8204 dgst_pos2 = 2;
8205 dgst_pos3 = 6;
8206 break;
8207
8208 case 1421: hash_type = HASH_TYPE_SHA256;
8209 salt_type = SALT_TYPE_EMBEDDED;
8210 attack_exec = ATTACK_EXEC_ON_GPU;
8211 opts_type = OPTS_TYPE_PT_GENERATE_BE
8212 | OPTS_TYPE_PT_ADD80
8213 | OPTS_TYPE_PT_ADDBITS15;
8214 kern_type = KERN_TYPE_SHA256_SLTPW;
8215 dgst_size = DGST_SIZE_4_8;
8216 parse_func = hmailserver_parse_hash;
8217 sort_by_digest = sort_by_digest_4_8;
8218 opti_type = OPTI_TYPE_ZERO_BYTE
8219 | OPTI_TYPE_PRECOMPUTE_INIT
8220 | OPTI_TYPE_PRECOMPUTE_MERKLE
8221 | OPTI_TYPE_EARLY_SKIP
8222 | OPTI_TYPE_NOT_ITERATED
8223 | OPTI_TYPE_PREPENDED_SALT
8224 | OPTI_TYPE_RAW_HASH;
8225 dgst_pos0 = 3;
8226 dgst_pos1 = 7;
8227 dgst_pos2 = 2;
8228 dgst_pos3 = 6;
8229 break;
8230
8231 case 1430: hash_type = HASH_TYPE_SHA256;
8232 salt_type = SALT_TYPE_INTERN;
8233 attack_exec = ATTACK_EXEC_ON_GPU;
8234 opts_type = OPTS_TYPE_PT_GENERATE_BE
8235 | OPTS_TYPE_PT_UNICODE
8236 | OPTS_TYPE_ST_ADD80
8237 | OPTS_TYPE_ST_ADDBITS15;
8238 kern_type = KERN_TYPE_SHA256_PWUSLT;
8239 dgst_size = DGST_SIZE_4_8;
8240 parse_func = sha256s_parse_hash;
8241 sort_by_digest = sort_by_digest_4_8;
8242 opti_type = OPTI_TYPE_ZERO_BYTE
8243 | OPTI_TYPE_PRECOMPUTE_INIT
8244 | OPTI_TYPE_PRECOMPUTE_MERKLE
8245 | OPTI_TYPE_SCALAR_MODE
8246 | OPTI_TYPE_EARLY_SKIP
8247 | OPTI_TYPE_NOT_ITERATED
8248 | OPTI_TYPE_APPENDED_SALT
8249 | OPTI_TYPE_RAW_HASH;
8250 dgst_pos0 = 3;
8251 dgst_pos1 = 7;
8252 dgst_pos2 = 2;
8253 dgst_pos3 = 6;
8254 break;
8255
8256 case 1440: hash_type = HASH_TYPE_SHA256;
8257 salt_type = SALT_TYPE_INTERN;
8258 attack_exec = ATTACK_EXEC_ON_GPU;
8259 opts_type = OPTS_TYPE_PT_GENERATE_BE
8260 | OPTS_TYPE_PT_ADD80
8261 | OPTS_TYPE_PT_ADDBITS15
8262 | OPTS_TYPE_PT_UNICODE;
8263 kern_type = KERN_TYPE_SHA256_SLTPWU;
8264 dgst_size = DGST_SIZE_4_8;
8265 parse_func = sha256s_parse_hash;
8266 sort_by_digest = sort_by_digest_4_8;
8267 opti_type = OPTI_TYPE_ZERO_BYTE
8268 | OPTI_TYPE_PRECOMPUTE_INIT
8269 | OPTI_TYPE_PRECOMPUTE_MERKLE
8270 | OPTI_TYPE_EARLY_SKIP
8271 | OPTI_TYPE_NOT_ITERATED
8272 | OPTI_TYPE_PREPENDED_SALT
8273 | OPTI_TYPE_RAW_HASH;
8274 dgst_pos0 = 3;
8275 dgst_pos1 = 7;
8276 dgst_pos2 = 2;
8277 dgst_pos3 = 6;
8278 break;
8279
8280 case 1441: hash_type = HASH_TYPE_SHA256;
8281 salt_type = SALT_TYPE_EMBEDDED;
8282 attack_exec = ATTACK_EXEC_ON_GPU;
8283 opts_type = OPTS_TYPE_PT_GENERATE_BE
8284 | OPTS_TYPE_PT_ADD80
8285 | OPTS_TYPE_PT_ADDBITS15
8286 | OPTS_TYPE_PT_UNICODE
8287 | OPTS_TYPE_ST_BASE64;
8288 kern_type = KERN_TYPE_SHA256_SLTPWU;
8289 dgst_size = DGST_SIZE_4_8;
8290 parse_func = episerver4_parse_hash;
8291 sort_by_digest = sort_by_digest_4_8;
8292 opti_type = OPTI_TYPE_ZERO_BYTE
8293 | OPTI_TYPE_PRECOMPUTE_INIT
8294 | OPTI_TYPE_PRECOMPUTE_MERKLE
8295 | OPTI_TYPE_EARLY_SKIP
8296 | OPTI_TYPE_NOT_ITERATED
8297 | OPTI_TYPE_PREPENDED_SALT
8298 | OPTI_TYPE_RAW_HASH;
8299 dgst_pos0 = 3;
8300 dgst_pos1 = 7;
8301 dgst_pos2 = 2;
8302 dgst_pos3 = 6;
8303 break;
8304
8305 case 1450: hash_type = HASH_TYPE_SHA256;
8306 salt_type = SALT_TYPE_INTERN;
8307 attack_exec = ATTACK_EXEC_ON_GPU;
8308 opts_type = OPTS_TYPE_PT_GENERATE_BE
8309 | OPTS_TYPE_ST_ADD80;
8310 kern_type = KERN_TYPE_HMACSHA256_PW;
8311 dgst_size = DGST_SIZE_4_8;
8312 parse_func = hmacsha256_parse_hash;
8313 sort_by_digest = sort_by_digest_4_8;
8314 opti_type = OPTI_TYPE_ZERO_BYTE
8315 | OPTI_TYPE_NOT_ITERATED;
8316 dgst_pos0 = 3;
8317 dgst_pos1 = 7;
8318 dgst_pos2 = 2;
8319 dgst_pos3 = 6;
8320 break;
8321
8322 case 1460: hash_type = HASH_TYPE_SHA256;
8323 salt_type = SALT_TYPE_INTERN;
8324 attack_exec = ATTACK_EXEC_ON_GPU;
8325 opts_type = OPTS_TYPE_PT_GENERATE_BE
8326 | OPTS_TYPE_PT_ADD80
8327 | OPTS_TYPE_PT_ADDBITS15;
8328 kern_type = KERN_TYPE_HMACSHA256_SLT;
8329 dgst_size = DGST_SIZE_4_8;
8330 parse_func = hmacsha256_parse_hash;
8331 sort_by_digest = sort_by_digest_4_8;
8332 opti_type = OPTI_TYPE_ZERO_BYTE
8333 | OPTI_TYPE_NOT_ITERATED;
8334 dgst_pos0 = 3;
8335 dgst_pos1 = 7;
8336 dgst_pos2 = 2;
8337 dgst_pos3 = 6;
8338 break;
8339
8340 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8341 salt_type = SALT_TYPE_EMBEDDED;
8342 attack_exec = ATTACK_EXEC_ON_GPU;
8343 opts_type = OPTS_TYPE_PT_GENERATE_LE
8344 | OPTS_TYPE_PT_BITSLICE;
8345 kern_type = KERN_TYPE_DESCRYPT;
8346 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8347 parse_func = descrypt_parse_hash;
8348 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8349 opti_type = OPTI_TYPE_ZERO_BYTE
8350 | OPTI_TYPE_SCALAR_MODE
8351 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8352 dgst_pos0 = 0;
8353 dgst_pos1 = 1;
8354 dgst_pos2 = 2;
8355 dgst_pos3 = 3;
8356 break;
8357
8358 case 1600: hash_type = HASH_TYPE_MD5;
8359 salt_type = SALT_TYPE_EMBEDDED;
8360 attack_exec = ATTACK_EXEC_ON_CPU;
8361 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8362 kern_type = KERN_TYPE_APR1CRYPT;
8363 dgst_size = DGST_SIZE_4_4;
8364 parse_func = md5apr1_parse_hash;
8365 sort_by_digest = sort_by_digest_4_4;
8366 opti_type = OPTI_TYPE_ZERO_BYTE;
8367 dgst_pos0 = 0;
8368 dgst_pos1 = 1;
8369 dgst_pos2 = 2;
8370 dgst_pos3 = 3;
8371 break;
8372
8373 case 1700: hash_type = HASH_TYPE_SHA512;
8374 salt_type = SALT_TYPE_NONE;
8375 attack_exec = ATTACK_EXEC_ON_GPU;
8376 opts_type = OPTS_TYPE_PT_GENERATE_BE
8377 | OPTS_TYPE_PT_ADD80
8378 | OPTS_TYPE_PT_ADDBITS15;
8379 kern_type = KERN_TYPE_SHA512;
8380 dgst_size = DGST_SIZE_8_8;
8381 parse_func = sha512_parse_hash;
8382 sort_by_digest = sort_by_digest_8_8;
8383 opti_type = OPTI_TYPE_ZERO_BYTE
8384 | OPTI_TYPE_PRECOMPUTE_INIT
8385 | OPTI_TYPE_PRECOMPUTE_MERKLE
8386 | OPTI_TYPE_SCALAR_MODE
8387 | OPTI_TYPE_EARLY_SKIP
8388 | OPTI_TYPE_NOT_ITERATED
8389 | OPTI_TYPE_NOT_SALTED
8390 | OPTI_TYPE_RAW_HASH;
8391 dgst_pos0 = 14;
8392 dgst_pos1 = 15;
8393 dgst_pos2 = 6;
8394 dgst_pos3 = 7;
8395 break;
8396
8397 case 1710: hash_type = HASH_TYPE_SHA512;
8398 salt_type = SALT_TYPE_INTERN;
8399 attack_exec = ATTACK_EXEC_ON_GPU;
8400 opts_type = OPTS_TYPE_PT_GENERATE_BE
8401 | OPTS_TYPE_ST_ADD80
8402 | OPTS_TYPE_ST_ADDBITS15;
8403 kern_type = KERN_TYPE_SHA512_PWSLT;
8404 dgst_size = DGST_SIZE_8_8;
8405 parse_func = sha512s_parse_hash;
8406 sort_by_digest = sort_by_digest_8_8;
8407 opti_type = OPTI_TYPE_ZERO_BYTE
8408 | OPTI_TYPE_PRECOMPUTE_INIT
8409 | OPTI_TYPE_PRECOMPUTE_MERKLE
8410 | OPTI_TYPE_SCALAR_MODE
8411 | OPTI_TYPE_EARLY_SKIP
8412 | OPTI_TYPE_NOT_ITERATED
8413 | OPTI_TYPE_APPENDED_SALT
8414 | OPTI_TYPE_RAW_HASH;
8415 dgst_pos0 = 14;
8416 dgst_pos1 = 15;
8417 dgst_pos2 = 6;
8418 dgst_pos3 = 7;
8419 break;
8420
8421 case 1711: hash_type = HASH_TYPE_SHA512;
8422 salt_type = SALT_TYPE_EMBEDDED;
8423 attack_exec = ATTACK_EXEC_ON_GPU;
8424 opts_type = OPTS_TYPE_PT_GENERATE_BE
8425 | OPTS_TYPE_ST_ADD80
8426 | OPTS_TYPE_ST_ADDBITS15;
8427 kern_type = KERN_TYPE_SHA512_PWSLT;
8428 dgst_size = DGST_SIZE_8_8;
8429 parse_func = sha512b64s_parse_hash;
8430 sort_by_digest = sort_by_digest_8_8;
8431 opti_type = OPTI_TYPE_ZERO_BYTE
8432 | OPTI_TYPE_PRECOMPUTE_INIT
8433 | OPTI_TYPE_PRECOMPUTE_MERKLE
8434 | OPTI_TYPE_SCALAR_MODE
8435 | OPTI_TYPE_EARLY_SKIP
8436 | OPTI_TYPE_NOT_ITERATED
8437 | OPTI_TYPE_APPENDED_SALT
8438 | OPTI_TYPE_RAW_HASH;
8439 dgst_pos0 = 14;
8440 dgst_pos1 = 15;
8441 dgst_pos2 = 6;
8442 dgst_pos3 = 7;
8443 break;
8444
8445 case 1720: hash_type = HASH_TYPE_SHA512;
8446 salt_type = SALT_TYPE_INTERN;
8447 attack_exec = ATTACK_EXEC_ON_GPU;
8448 opts_type = OPTS_TYPE_PT_GENERATE_BE
8449 | OPTS_TYPE_PT_ADD80
8450 | OPTS_TYPE_PT_ADDBITS15;
8451 kern_type = KERN_TYPE_SHA512_SLTPW;
8452 dgst_size = DGST_SIZE_8_8;
8453 parse_func = sha512s_parse_hash;
8454 sort_by_digest = sort_by_digest_8_8;
8455 opti_type = OPTI_TYPE_ZERO_BYTE
8456 | OPTI_TYPE_PRECOMPUTE_INIT
8457 | OPTI_TYPE_PRECOMPUTE_MERKLE
8458 | OPTI_TYPE_EARLY_SKIP
8459 | OPTI_TYPE_NOT_ITERATED
8460 | OPTI_TYPE_PREPENDED_SALT
8461 | OPTI_TYPE_RAW_HASH;
8462 dgst_pos0 = 14;
8463 dgst_pos1 = 15;
8464 dgst_pos2 = 6;
8465 dgst_pos3 = 7;
8466 break;
8467
8468 case 1722: hash_type = HASH_TYPE_SHA512;
8469 salt_type = SALT_TYPE_EMBEDDED;
8470 attack_exec = ATTACK_EXEC_ON_GPU;
8471 opts_type = OPTS_TYPE_PT_GENERATE_BE
8472 | OPTS_TYPE_PT_ADD80
8473 | OPTS_TYPE_PT_ADDBITS15
8474 | OPTS_TYPE_ST_HEX;
8475 kern_type = KERN_TYPE_SHA512_SLTPW;
8476 dgst_size = DGST_SIZE_8_8;
8477 parse_func = osx512_parse_hash;
8478 sort_by_digest = sort_by_digest_8_8;
8479 opti_type = OPTI_TYPE_ZERO_BYTE
8480 | OPTI_TYPE_PRECOMPUTE_INIT
8481 | OPTI_TYPE_PRECOMPUTE_MERKLE
8482 | OPTI_TYPE_EARLY_SKIP
8483 | OPTI_TYPE_NOT_ITERATED
8484 | OPTI_TYPE_PREPENDED_SALT
8485 | OPTI_TYPE_RAW_HASH;
8486 dgst_pos0 = 14;
8487 dgst_pos1 = 15;
8488 dgst_pos2 = 6;
8489 dgst_pos3 = 7;
8490 break;
8491
8492 case 1730: hash_type = HASH_TYPE_SHA512;
8493 salt_type = SALT_TYPE_INTERN;
8494 attack_exec = ATTACK_EXEC_ON_GPU;
8495 opts_type = OPTS_TYPE_PT_GENERATE_BE
8496 | OPTS_TYPE_PT_UNICODE
8497 | OPTS_TYPE_ST_ADD80
8498 | OPTS_TYPE_ST_ADDBITS15;
8499 kern_type = KERN_TYPE_SHA512_PWSLTU;
8500 dgst_size = DGST_SIZE_8_8;
8501 parse_func = sha512s_parse_hash;
8502 sort_by_digest = sort_by_digest_8_8;
8503 opti_type = OPTI_TYPE_ZERO_BYTE
8504 | OPTI_TYPE_PRECOMPUTE_INIT
8505 | OPTI_TYPE_PRECOMPUTE_MERKLE
8506 | OPTI_TYPE_SCALAR_MODE
8507 | OPTI_TYPE_EARLY_SKIP
8508 | OPTI_TYPE_NOT_ITERATED
8509 | OPTI_TYPE_APPENDED_SALT
8510 | OPTI_TYPE_RAW_HASH;
8511 dgst_pos0 = 14;
8512 dgst_pos1 = 15;
8513 dgst_pos2 = 6;
8514 dgst_pos3 = 7;
8515 break;
8516
8517 case 1731: hash_type = HASH_TYPE_SHA512;
8518 salt_type = SALT_TYPE_EMBEDDED;
8519 attack_exec = ATTACK_EXEC_ON_GPU;
8520 opts_type = OPTS_TYPE_PT_GENERATE_BE
8521 | OPTS_TYPE_PT_UNICODE
8522 | OPTS_TYPE_ST_ADD80
8523 | OPTS_TYPE_ST_ADDBITS15
8524 | OPTS_TYPE_ST_HEX;
8525 kern_type = KERN_TYPE_SHA512_PWSLTU;
8526 dgst_size = DGST_SIZE_8_8;
8527 parse_func = mssql2012_parse_hash;
8528 sort_by_digest = sort_by_digest_8_8;
8529 opti_type = OPTI_TYPE_ZERO_BYTE
8530 | OPTI_TYPE_PRECOMPUTE_INIT
8531 | OPTI_TYPE_PRECOMPUTE_MERKLE
8532 | OPTI_TYPE_SCALAR_MODE
8533 | OPTI_TYPE_EARLY_SKIP
8534 | OPTI_TYPE_NOT_ITERATED
8535 | OPTI_TYPE_APPENDED_SALT
8536 | OPTI_TYPE_RAW_HASH;
8537 dgst_pos0 = 14;
8538 dgst_pos1 = 15;
8539 dgst_pos2 = 6;
8540 dgst_pos3 = 7;
8541 break;
8542
8543 case 1740: hash_type = HASH_TYPE_SHA512;
8544 salt_type = SALT_TYPE_INTERN;
8545 attack_exec = ATTACK_EXEC_ON_GPU;
8546 opts_type = OPTS_TYPE_PT_GENERATE_BE
8547 | OPTS_TYPE_PT_ADD80
8548 | OPTS_TYPE_PT_ADDBITS15
8549 | OPTS_TYPE_PT_UNICODE;
8550 kern_type = KERN_TYPE_SHA512_SLTPWU;
8551 dgst_size = DGST_SIZE_8_8;
8552 parse_func = sha512s_parse_hash;
8553 sort_by_digest = sort_by_digest_8_8;
8554 opti_type = OPTI_TYPE_ZERO_BYTE
8555 | OPTI_TYPE_PRECOMPUTE_INIT
8556 | OPTI_TYPE_PRECOMPUTE_MERKLE
8557 | OPTI_TYPE_EARLY_SKIP
8558 | OPTI_TYPE_NOT_ITERATED
8559 | OPTI_TYPE_PREPENDED_SALT
8560 | OPTI_TYPE_RAW_HASH;
8561 dgst_pos0 = 14;
8562 dgst_pos1 = 15;
8563 dgst_pos2 = 6;
8564 dgst_pos3 = 7;
8565 break;
8566
8567 case 1750: hash_type = HASH_TYPE_SHA512;
8568 salt_type = SALT_TYPE_INTERN;
8569 attack_exec = ATTACK_EXEC_ON_GPU;
8570 opts_type = OPTS_TYPE_PT_GENERATE_BE
8571 | OPTS_TYPE_ST_ADD80;
8572 kern_type = KERN_TYPE_HMACSHA512_PW;
8573 dgst_size = DGST_SIZE_8_8;
8574 parse_func = hmacsha512_parse_hash;
8575 sort_by_digest = sort_by_digest_8_8;
8576 opti_type = OPTI_TYPE_ZERO_BYTE
8577 | OPTI_TYPE_NOT_ITERATED;
8578 dgst_pos0 = 14;
8579 dgst_pos1 = 15;
8580 dgst_pos2 = 6;
8581 dgst_pos3 = 7;
8582 break;
8583
8584 case 1760: hash_type = HASH_TYPE_SHA512;
8585 salt_type = SALT_TYPE_INTERN;
8586 attack_exec = ATTACK_EXEC_ON_GPU;
8587 opts_type = OPTS_TYPE_PT_GENERATE_BE
8588 | OPTS_TYPE_PT_ADD80
8589 | OPTS_TYPE_PT_ADDBITS15;
8590 kern_type = KERN_TYPE_HMACSHA512_SLT;
8591 dgst_size = DGST_SIZE_8_8;
8592 parse_func = hmacsha512_parse_hash;
8593 sort_by_digest = sort_by_digest_8_8;
8594 opti_type = OPTI_TYPE_ZERO_BYTE
8595 | OPTI_TYPE_NOT_ITERATED;
8596 dgst_pos0 = 14;
8597 dgst_pos1 = 15;
8598 dgst_pos2 = 6;
8599 dgst_pos3 = 7;
8600 break;
8601
8602 case 1800: hash_type = HASH_TYPE_SHA512;
8603 salt_type = SALT_TYPE_EMBEDDED;
8604 attack_exec = ATTACK_EXEC_ON_CPU;
8605 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8606 kern_type = KERN_TYPE_SHA512CRYPT;
8607 dgst_size = DGST_SIZE_8_8;
8608 parse_func = sha512crypt_parse_hash;
8609 sort_by_digest = sort_by_digest_8_8;
8610 opti_type = OPTI_TYPE_ZERO_BYTE;
8611 dgst_pos0 = 0;
8612 dgst_pos1 = 1;
8613 dgst_pos2 = 2;
8614 dgst_pos3 = 3;
8615 break;
8616
8617 case 2100: hash_type = HASH_TYPE_DCC2;
8618 salt_type = SALT_TYPE_EMBEDDED;
8619 attack_exec = ATTACK_EXEC_ON_CPU;
8620 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8621 | OPTS_TYPE_ST_LOWER
8622 | OPTS_TYPE_ST_UNICODE;
8623 kern_type = KERN_TYPE_DCC2;
8624 dgst_size = DGST_SIZE_4_4;
8625 parse_func = dcc2_parse_hash;
8626 sort_by_digest = sort_by_digest_4_4;
8627 opti_type = OPTI_TYPE_ZERO_BYTE;
8628 dgst_pos0 = 0;
8629 dgst_pos1 = 1;
8630 dgst_pos2 = 2;
8631 dgst_pos3 = 3;
8632 break;
8633
8634 case 2400: hash_type = HASH_TYPE_MD5;
8635 salt_type = SALT_TYPE_NONE;
8636 attack_exec = ATTACK_EXEC_ON_GPU;
8637 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8638 kern_type = KERN_TYPE_MD5PIX;
8639 dgst_size = DGST_SIZE_4_4;
8640 parse_func = md5pix_parse_hash;
8641 sort_by_digest = sort_by_digest_4_4;
8642 opti_type = OPTI_TYPE_ZERO_BYTE
8643 | OPTI_TYPE_PRECOMPUTE_INIT
8644 | OPTI_TYPE_PRECOMPUTE_MERKLE
8645 | OPTI_TYPE_SCALAR_MODE
8646 | OPTI_TYPE_EARLY_SKIP
8647 | OPTI_TYPE_NOT_ITERATED
8648 | OPTI_TYPE_NOT_SALTED;
8649 dgst_pos0 = 0;
8650 dgst_pos1 = 3;
8651 dgst_pos2 = 2;
8652 dgst_pos3 = 1;
8653 break;
8654
8655 case 2410: hash_type = HASH_TYPE_MD5;
8656 salt_type = SALT_TYPE_INTERN;
8657 attack_exec = ATTACK_EXEC_ON_GPU;
8658 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8659 kern_type = KERN_TYPE_MD5ASA;
8660 dgst_size = DGST_SIZE_4_4;
8661 parse_func = md5asa_parse_hash;
8662 sort_by_digest = sort_by_digest_4_4;
8663 opti_type = OPTI_TYPE_ZERO_BYTE
8664 | OPTI_TYPE_PRECOMPUTE_INIT
8665 | OPTI_TYPE_PRECOMPUTE_MERKLE
8666 | OPTI_TYPE_SCALAR_MODE
8667 | OPTI_TYPE_EARLY_SKIP
8668 | OPTI_TYPE_NOT_ITERATED;
8669 dgst_pos0 = 0;
8670 dgst_pos1 = 3;
8671 dgst_pos2 = 2;
8672 dgst_pos3 = 1;
8673 break;
8674
8675 case 2500: hash_type = HASH_TYPE_WPA;
8676 salt_type = SALT_TYPE_EMBEDDED;
8677 attack_exec = ATTACK_EXEC_ON_CPU;
8678 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8679 kern_type = KERN_TYPE_WPA;
8680 dgst_size = DGST_SIZE_4_4;
8681 parse_func = wpa_parse_hash;
8682 sort_by_digest = sort_by_digest_4_4;
8683 opti_type = OPTI_TYPE_ZERO_BYTE;
8684 dgst_pos0 = 0;
8685 dgst_pos1 = 1;
8686 dgst_pos2 = 2;
8687 dgst_pos3 = 3;
8688 break;
8689
8690 case 2600: hash_type = HASH_TYPE_MD5;
8691 salt_type = SALT_TYPE_VIRTUAL;
8692 attack_exec = ATTACK_EXEC_ON_GPU;
8693 opts_type = OPTS_TYPE_PT_GENERATE_LE
8694 | OPTS_TYPE_PT_ADD80
8695 | OPTS_TYPE_PT_ADDBITS14
8696 | OPTS_TYPE_ST_ADD80;
8697 kern_type = KERN_TYPE_MD55_PWSLT1;
8698 dgst_size = DGST_SIZE_4_4;
8699 parse_func = md5md5_parse_hash;
8700 sort_by_digest = sort_by_digest_4_4;
8701 opti_type = OPTI_TYPE_ZERO_BYTE
8702 | OPTI_TYPE_PRECOMPUTE_INIT
8703 | OPTI_TYPE_PRECOMPUTE_MERKLE
8704 | OPTI_TYPE_EARLY_SKIP;
8705 dgst_pos0 = 0;
8706 dgst_pos1 = 3;
8707 dgst_pos2 = 2;
8708 dgst_pos3 = 1;
8709 break;
8710
8711 case 2611: hash_type = HASH_TYPE_MD5;
8712 salt_type = SALT_TYPE_INTERN;
8713 attack_exec = ATTACK_EXEC_ON_GPU;
8714 opts_type = OPTS_TYPE_PT_GENERATE_LE
8715 | OPTS_TYPE_PT_ADD80
8716 | OPTS_TYPE_PT_ADDBITS14
8717 | OPTS_TYPE_ST_ADD80;
8718 kern_type = KERN_TYPE_MD55_PWSLT1;
8719 dgst_size = DGST_SIZE_4_4;
8720 parse_func = vb3_parse_hash;
8721 sort_by_digest = sort_by_digest_4_4;
8722 opti_type = OPTI_TYPE_ZERO_BYTE
8723 | OPTI_TYPE_PRECOMPUTE_INIT
8724 | OPTI_TYPE_PRECOMPUTE_MERKLE
8725 | OPTI_TYPE_EARLY_SKIP;
8726 dgst_pos0 = 0;
8727 dgst_pos1 = 3;
8728 dgst_pos2 = 2;
8729 dgst_pos3 = 1;
8730 break;
8731
8732 case 2612: hash_type = HASH_TYPE_MD5;
8733 salt_type = SALT_TYPE_EMBEDDED;
8734 attack_exec = ATTACK_EXEC_ON_GPU;
8735 opts_type = OPTS_TYPE_PT_GENERATE_LE
8736 | OPTS_TYPE_PT_ADD80
8737 | OPTS_TYPE_PT_ADDBITS14
8738 | OPTS_TYPE_ST_ADD80
8739 | OPTS_TYPE_ST_HEX;
8740 kern_type = KERN_TYPE_MD55_PWSLT1;
8741 dgst_size = DGST_SIZE_4_4;
8742 parse_func = phps_parse_hash;
8743 sort_by_digest = sort_by_digest_4_4;
8744 opti_type = OPTI_TYPE_ZERO_BYTE
8745 | OPTI_TYPE_PRECOMPUTE_INIT
8746 | OPTI_TYPE_PRECOMPUTE_MERKLE
8747 | OPTI_TYPE_EARLY_SKIP;
8748 dgst_pos0 = 0;
8749 dgst_pos1 = 3;
8750 dgst_pos2 = 2;
8751 dgst_pos3 = 1;
8752 break;
8753
8754 case 2711: hash_type = HASH_TYPE_MD5;
8755 salt_type = SALT_TYPE_INTERN;
8756 attack_exec = ATTACK_EXEC_ON_GPU;
8757 opts_type = OPTS_TYPE_PT_GENERATE_LE
8758 | OPTS_TYPE_PT_ADD80
8759 | OPTS_TYPE_PT_ADDBITS14
8760 | OPTS_TYPE_ST_ADD80;
8761 kern_type = KERN_TYPE_MD55_PWSLT2;
8762 dgst_size = DGST_SIZE_4_4;
8763 parse_func = vb30_parse_hash;
8764 sort_by_digest = sort_by_digest_4_4;
8765 opti_type = OPTI_TYPE_ZERO_BYTE
8766 | OPTI_TYPE_PRECOMPUTE_INIT
8767 | OPTI_TYPE_EARLY_SKIP;
8768 dgst_pos0 = 0;
8769 dgst_pos1 = 3;
8770 dgst_pos2 = 2;
8771 dgst_pos3 = 1;
8772 break;
8773
8774 case 2811: hash_type = HASH_TYPE_MD5;
8775 salt_type = SALT_TYPE_INTERN;
8776 attack_exec = ATTACK_EXEC_ON_GPU;
8777 opts_type = OPTS_TYPE_PT_GENERATE_LE
8778 | OPTS_TYPE_PT_ADD80
8779 | OPTS_TYPE_PT_ADDBITS14;
8780 kern_type = KERN_TYPE_MD55_SLTPW;
8781 dgst_size = DGST_SIZE_4_4;
8782 parse_func = ipb2_parse_hash;
8783 sort_by_digest = sort_by_digest_4_4;
8784 opti_type = OPTI_TYPE_ZERO_BYTE
8785 | OPTI_TYPE_PRECOMPUTE_INIT
8786 | OPTI_TYPE_EARLY_SKIP;
8787 dgst_pos0 = 0;
8788 dgst_pos1 = 3;
8789 dgst_pos2 = 2;
8790 dgst_pos3 = 1;
8791 break;
8792
8793 case 3000: hash_type = HASH_TYPE_LM;
8794 salt_type = SALT_TYPE_NONE;
8795 attack_exec = ATTACK_EXEC_ON_GPU;
8796 opts_type = OPTS_TYPE_PT_GENERATE_LE
8797 | OPTS_TYPE_PT_UPPER
8798 | OPTS_TYPE_PT_BITSLICE;
8799 kern_type = KERN_TYPE_LM;
8800 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8801 parse_func = lm_parse_hash;
8802 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8803 opti_type = OPTI_TYPE_ZERO_BYTE
8804 | OPTI_TYPE_SCALAR_MODE
8805 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8806 dgst_pos0 = 0;
8807 dgst_pos1 = 1;
8808 dgst_pos2 = 2;
8809 dgst_pos3 = 3;
8810 break;
8811
8812 case 3100: hash_type = HASH_TYPE_ORACLEH;
8813 salt_type = SALT_TYPE_INTERN;
8814 attack_exec = ATTACK_EXEC_ON_GPU;
8815 opts_type = OPTS_TYPE_PT_GENERATE_LE
8816 | OPTS_TYPE_PT_UPPER
8817 | OPTS_TYPE_ST_UPPER;
8818 kern_type = KERN_TYPE_ORACLEH;
8819 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8820 parse_func = oracleh_parse_hash;
8821 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8822 opti_type = OPTI_TYPE_ZERO_BYTE
8823 | OPTI_TYPE_SCALAR_MODE;
8824 dgst_pos0 = 0;
8825 dgst_pos1 = 1;
8826 dgst_pos2 = 2;
8827 dgst_pos3 = 3;
8828 break;
8829
8830 case 3200: hash_type = HASH_TYPE_BCRYPT;
8831 salt_type = SALT_TYPE_EMBEDDED;
8832 attack_exec = ATTACK_EXEC_ON_CPU;
8833 opts_type = OPTS_TYPE_PT_GENERATE_LE
8834 | OPTS_TYPE_ST_GENERATE_LE;
8835 kern_type = KERN_TYPE_BCRYPT;
8836 dgst_size = DGST_SIZE_4_6;
8837 parse_func = bcrypt_parse_hash;
8838 sort_by_digest = sort_by_digest_4_6;
8839 opti_type = OPTI_TYPE_ZERO_BYTE;
8840 dgst_pos0 = 0;
8841 dgst_pos1 = 1;
8842 dgst_pos2 = 2;
8843 dgst_pos3 = 3;
8844 break;
8845
8846 case 3710: hash_type = HASH_TYPE_MD5;
8847 salt_type = SALT_TYPE_INTERN;
8848 attack_exec = ATTACK_EXEC_ON_GPU;
8849 opts_type = OPTS_TYPE_PT_GENERATE_LE
8850 | OPTS_TYPE_PT_ADD80
8851 | OPTS_TYPE_PT_ADDBITS14;
8852 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8853 dgst_size = DGST_SIZE_4_4;
8854 parse_func = md5s_parse_hash;
8855 sort_by_digest = sort_by_digest_4_4;
8856 opti_type = OPTI_TYPE_ZERO_BYTE
8857 | OPTI_TYPE_PRECOMPUTE_INIT
8858 | OPTI_TYPE_PRECOMPUTE_MERKLE
8859 | OPTI_TYPE_EARLY_SKIP;
8860 dgst_pos0 = 0;
8861 dgst_pos1 = 3;
8862 dgst_pos2 = 2;
8863 dgst_pos3 = 1;
8864 break;
8865
8866 case 3711: hash_type = HASH_TYPE_MD5;
8867 salt_type = SALT_TYPE_EMBEDDED;
8868 attack_exec = ATTACK_EXEC_ON_GPU;
8869 opts_type = OPTS_TYPE_PT_GENERATE_LE
8870 | OPTS_TYPE_PT_ADD80
8871 | OPTS_TYPE_PT_ADDBITS14;
8872 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8873 dgst_size = DGST_SIZE_4_4;
8874 parse_func = mediawiki_b_parse_hash;
8875 sort_by_digest = sort_by_digest_4_4;
8876 opti_type = OPTI_TYPE_ZERO_BYTE
8877 | OPTI_TYPE_PRECOMPUTE_INIT
8878 | OPTI_TYPE_PRECOMPUTE_MERKLE
8879 | OPTI_TYPE_EARLY_SKIP;
8880 dgst_pos0 = 0;
8881 dgst_pos1 = 3;
8882 dgst_pos2 = 2;
8883 dgst_pos3 = 1;
8884 break;
8885
8886 case 3800: hash_type = HASH_TYPE_MD5;
8887 salt_type = SALT_TYPE_INTERN;
8888 attack_exec = ATTACK_EXEC_ON_GPU;
8889 opts_type = OPTS_TYPE_PT_GENERATE_LE
8890 | OPTS_TYPE_ST_ADDBITS14;
8891 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8892 dgst_size = DGST_SIZE_4_4;
8893 parse_func = md5s_parse_hash;
8894 sort_by_digest = sort_by_digest_4_4;
8895 opti_type = OPTI_TYPE_ZERO_BYTE
8896 | OPTI_TYPE_PRECOMPUTE_INIT
8897 | OPTI_TYPE_PRECOMPUTE_MERKLE
8898 | OPTI_TYPE_EARLY_SKIP
8899 | OPTI_TYPE_NOT_ITERATED
8900 | OPTI_TYPE_RAW_HASH;
8901 dgst_pos0 = 0;
8902 dgst_pos1 = 3;
8903 dgst_pos2 = 2;
8904 dgst_pos3 = 1;
8905 break;
8906
8907 case 4300: hash_type = HASH_TYPE_MD5;
8908 salt_type = SALT_TYPE_VIRTUAL;
8909 attack_exec = ATTACK_EXEC_ON_GPU;
8910 opts_type = OPTS_TYPE_PT_GENERATE_LE
8911 | OPTS_TYPE_PT_ADD80
8912 | OPTS_TYPE_PT_ADDBITS14
8913 | OPTS_TYPE_ST_ADD80;
8914 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8915 dgst_size = DGST_SIZE_4_4;
8916 parse_func = md5md5_parse_hash;
8917 sort_by_digest = sort_by_digest_4_4;
8918 opti_type = OPTI_TYPE_ZERO_BYTE
8919 | OPTI_TYPE_PRECOMPUTE_INIT
8920 | OPTI_TYPE_PRECOMPUTE_MERKLE
8921 | OPTI_TYPE_EARLY_SKIP;
8922 dgst_pos0 = 0;
8923 dgst_pos1 = 3;
8924 dgst_pos2 = 2;
8925 dgst_pos3 = 1;
8926 break;
8927
8928
8929 case 4400: hash_type = HASH_TYPE_MD5;
8930 salt_type = SALT_TYPE_NONE;
8931 attack_exec = ATTACK_EXEC_ON_GPU;
8932 opts_type = OPTS_TYPE_PT_GENERATE_BE
8933 | OPTS_TYPE_PT_ADD80
8934 | OPTS_TYPE_PT_ADDBITS15;
8935 kern_type = KERN_TYPE_MD5_SHA1;
8936 dgst_size = DGST_SIZE_4_4;
8937 parse_func = md5_parse_hash;
8938 sort_by_digest = sort_by_digest_4_4;
8939 opti_type = OPTI_TYPE_ZERO_BYTE
8940 | OPTI_TYPE_PRECOMPUTE_INIT
8941 | OPTI_TYPE_PRECOMPUTE_MERKLE
8942 | OPTI_TYPE_EARLY_SKIP
8943 | OPTI_TYPE_NOT_ITERATED
8944 | OPTI_TYPE_NOT_SALTED
8945 | OPTI_TYPE_RAW_HASH;
8946 dgst_pos0 = 0;
8947 dgst_pos1 = 3;
8948 dgst_pos2 = 2;
8949 dgst_pos3 = 1;
8950 break;
8951
8952 case 4500: hash_type = HASH_TYPE_SHA1;
8953 salt_type = SALT_TYPE_NONE;
8954 attack_exec = ATTACK_EXEC_ON_GPU;
8955 opts_type = OPTS_TYPE_PT_GENERATE_BE
8956 | OPTS_TYPE_PT_ADD80
8957 | OPTS_TYPE_PT_ADDBITS15;
8958 kern_type = KERN_TYPE_SHA11;
8959 dgst_size = DGST_SIZE_4_5;
8960 parse_func = sha1_parse_hash;
8961 sort_by_digest = sort_by_digest_4_5;
8962 opti_type = OPTI_TYPE_ZERO_BYTE
8963 | OPTI_TYPE_PRECOMPUTE_INIT
8964 | OPTI_TYPE_PRECOMPUTE_MERKLE
8965 | OPTI_TYPE_EARLY_SKIP
8966 | OPTI_TYPE_NOT_SALTED;
8967 dgst_pos0 = 3;
8968 dgst_pos1 = 4;
8969 dgst_pos2 = 2;
8970 dgst_pos3 = 1;
8971 break;
8972
8973 case 4700: hash_type = HASH_TYPE_SHA1;
8974 salt_type = SALT_TYPE_NONE;
8975 attack_exec = ATTACK_EXEC_ON_GPU;
8976 opts_type = OPTS_TYPE_PT_GENERATE_LE
8977 | OPTS_TYPE_PT_ADD80
8978 | OPTS_TYPE_PT_ADDBITS14;
8979 kern_type = KERN_TYPE_SHA1_MD5;
8980 dgst_size = DGST_SIZE_4_5;
8981 parse_func = sha1_parse_hash;
8982 sort_by_digest = sort_by_digest_4_5;
8983 opti_type = OPTI_TYPE_ZERO_BYTE
8984 | OPTI_TYPE_PRECOMPUTE_INIT
8985 | OPTI_TYPE_PRECOMPUTE_MERKLE
8986 | OPTI_TYPE_EARLY_SKIP
8987 | OPTI_TYPE_NOT_ITERATED
8988 | OPTI_TYPE_NOT_SALTED
8989 | OPTI_TYPE_RAW_HASH;
8990 dgst_pos0 = 3;
8991 dgst_pos1 = 4;
8992 dgst_pos2 = 2;
8993 dgst_pos3 = 1;
8994 break;
8995
8996 case 4800: hash_type = HASH_TYPE_MD5;
8997 salt_type = SALT_TYPE_EMBEDDED;
8998 attack_exec = ATTACK_EXEC_ON_GPU;
8999 opts_type = OPTS_TYPE_PT_GENERATE_LE
9000 | OPTS_TYPE_PT_ADDBITS14;
9001 kern_type = KERN_TYPE_MD5_CHAP;
9002 dgst_size = DGST_SIZE_4_4;
9003 parse_func = chap_parse_hash;
9004 sort_by_digest = sort_by_digest_4_4;
9005 opti_type = OPTI_TYPE_ZERO_BYTE
9006 | OPTI_TYPE_PRECOMPUTE_INIT
9007 | OPTI_TYPE_PRECOMPUTE_MERKLE
9008 | OPTI_TYPE_MEET_IN_MIDDLE
9009 | OPTI_TYPE_EARLY_SKIP
9010 | OPTI_TYPE_NOT_ITERATED
9011 | OPTI_TYPE_RAW_HASH;
9012 dgst_pos0 = 0;
9013 dgst_pos1 = 3;
9014 dgst_pos2 = 2;
9015 dgst_pos3 = 1;
9016 break;
9017
9018 case 4900: hash_type = HASH_TYPE_SHA1;
9019 salt_type = SALT_TYPE_INTERN;
9020 attack_exec = ATTACK_EXEC_ON_GPU;
9021 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9022 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
9023 dgst_size = DGST_SIZE_4_5;
9024 parse_func = sha1s_parse_hash;
9025 sort_by_digest = sort_by_digest_4_5;
9026 opti_type = OPTI_TYPE_ZERO_BYTE
9027 | OPTI_TYPE_PRECOMPUTE_INIT
9028 | OPTI_TYPE_PRECOMPUTE_MERKLE
9029 | OPTI_TYPE_EARLY_SKIP;
9030 dgst_pos0 = 3;
9031 dgst_pos1 = 4;
9032 dgst_pos2 = 2;
9033 dgst_pos3 = 1;
9034 break;
9035
9036 case 5000: hash_type = HASH_TYPE_KECCAK;
9037 salt_type = SALT_TYPE_EMBEDDED;
9038 attack_exec = ATTACK_EXEC_ON_GPU;
9039 opts_type = OPTS_TYPE_PT_GENERATE_LE
9040 | OPTS_TYPE_PT_ADD01;
9041 kern_type = KERN_TYPE_KECCAK;
9042 dgst_size = DGST_SIZE_8_25;
9043 parse_func = keccak_parse_hash;
9044 sort_by_digest = sort_by_digest_8_25;
9045 opti_type = OPTI_TYPE_ZERO_BYTE
9046 | OPTI_TYPE_RAW_HASH;
9047 dgst_pos0 = 2;
9048 dgst_pos1 = 3;
9049 dgst_pos2 = 4;
9050 dgst_pos3 = 5;
9051 break;
9052
9053 case 5100: hash_type = HASH_TYPE_MD5H;
9054 salt_type = SALT_TYPE_NONE;
9055 attack_exec = ATTACK_EXEC_ON_GPU;
9056 opts_type = OPTS_TYPE_PT_GENERATE_LE
9057 | OPTS_TYPE_PT_ADD80
9058 | OPTS_TYPE_PT_ADDBITS14;
9059 kern_type = KERN_TYPE_MD5H;
9060 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9061 parse_func = md5half_parse_hash;
9062 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9063 opti_type = OPTI_TYPE_ZERO_BYTE
9064 | OPTI_TYPE_RAW_HASH;
9065 dgst_pos0 = 0;
9066 dgst_pos1 = 1;
9067 dgst_pos2 = 2;
9068 dgst_pos3 = 3;
9069 break;
9070
9071 case 5200: hash_type = HASH_TYPE_SHA256;
9072 salt_type = SALT_TYPE_EMBEDDED;
9073 attack_exec = ATTACK_EXEC_ON_CPU;
9074 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9075 kern_type = KERN_TYPE_PSAFE3;
9076 dgst_size = DGST_SIZE_4_8;
9077 parse_func = psafe3_parse_hash;
9078 sort_by_digest = sort_by_digest_4_8;
9079 opti_type = OPTI_TYPE_ZERO_BYTE;
9080 dgst_pos0 = 0;
9081 dgst_pos1 = 1;
9082 dgst_pos2 = 2;
9083 dgst_pos3 = 3;
9084 break;
9085
9086 case 5300: hash_type = HASH_TYPE_MD5;
9087 salt_type = SALT_TYPE_EMBEDDED;
9088 attack_exec = ATTACK_EXEC_ON_GPU;
9089 opts_type = OPTS_TYPE_PT_GENERATE_LE
9090 | OPTS_TYPE_ST_ADD80;
9091 kern_type = KERN_TYPE_IKEPSK_MD5;
9092 dgst_size = DGST_SIZE_4_4;
9093 parse_func = ikepsk_md5_parse_hash;
9094 sort_by_digest = sort_by_digest_4_4;
9095 opti_type = OPTI_TYPE_ZERO_BYTE;
9096 dgst_pos0 = 0;
9097 dgst_pos1 = 3;
9098 dgst_pos2 = 2;
9099 dgst_pos3 = 1;
9100 break;
9101
9102 case 5400: hash_type = HASH_TYPE_SHA1;
9103 salt_type = SALT_TYPE_EMBEDDED;
9104 attack_exec = ATTACK_EXEC_ON_GPU;
9105 opts_type = OPTS_TYPE_PT_GENERATE_BE
9106 | OPTS_TYPE_ST_ADD80;
9107 kern_type = KERN_TYPE_IKEPSK_SHA1;
9108 dgst_size = DGST_SIZE_4_5;
9109 parse_func = ikepsk_sha1_parse_hash;
9110 sort_by_digest = sort_by_digest_4_5;
9111 opti_type = OPTI_TYPE_ZERO_BYTE;
9112 dgst_pos0 = 3;
9113 dgst_pos1 = 4;
9114 dgst_pos2 = 2;
9115 dgst_pos3 = 1;
9116 break;
9117
9118 case 5500: hash_type = HASH_TYPE_NETNTLM;
9119 salt_type = SALT_TYPE_EMBEDDED;
9120 attack_exec = ATTACK_EXEC_ON_GPU;
9121 opts_type = OPTS_TYPE_PT_GENERATE_LE
9122 | OPTS_TYPE_PT_ADD80
9123 | OPTS_TYPE_PT_ADDBITS14
9124 | OPTS_TYPE_PT_UNICODE
9125 | OPTS_TYPE_ST_HEX;
9126 kern_type = KERN_TYPE_NETNTLMv1;
9127 dgst_size = DGST_SIZE_4_4;
9128 parse_func = netntlmv1_parse_hash;
9129 sort_by_digest = sort_by_digest_4_4;
9130 opti_type = OPTI_TYPE_ZERO_BYTE
9131 | OPTI_TYPE_SCALAR_MODE
9132 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9133 dgst_pos0 = 0;
9134 dgst_pos1 = 1;
9135 dgst_pos2 = 2;
9136 dgst_pos3 = 3;
9137 break;
9138
9139 case 5600: hash_type = HASH_TYPE_MD5;
9140 salt_type = SALT_TYPE_EMBEDDED;
9141 attack_exec = ATTACK_EXEC_ON_GPU;
9142 opts_type = OPTS_TYPE_PT_GENERATE_LE
9143 | OPTS_TYPE_PT_ADD80
9144 | OPTS_TYPE_PT_ADDBITS14
9145 | OPTS_TYPE_PT_UNICODE;
9146 kern_type = KERN_TYPE_NETNTLMv2;
9147 dgst_size = DGST_SIZE_4_4;
9148 parse_func = netntlmv2_parse_hash;
9149 sort_by_digest = sort_by_digest_4_4;
9150 opti_type = OPTI_TYPE_ZERO_BYTE;
9151 dgst_pos0 = 0;
9152 dgst_pos1 = 3;
9153 dgst_pos2 = 2;
9154 dgst_pos3 = 1;
9155 break;
9156
9157 case 5700: hash_type = HASH_TYPE_SHA256;
9158 salt_type = SALT_TYPE_NONE;
9159 attack_exec = ATTACK_EXEC_ON_GPU;
9160 opts_type = OPTS_TYPE_PT_GENERATE_BE
9161 | OPTS_TYPE_PT_ADD80
9162 | OPTS_TYPE_PT_ADDBITS15;
9163 kern_type = KERN_TYPE_SHA256;
9164 dgst_size = DGST_SIZE_4_8;
9165 parse_func = cisco4_parse_hash;
9166 sort_by_digest = sort_by_digest_4_8;
9167 opti_type = OPTI_TYPE_ZERO_BYTE
9168 | OPTI_TYPE_PRECOMPUTE_INIT
9169 | OPTI_TYPE_PRECOMPUTE_MERKLE
9170 | OPTI_TYPE_SCALAR_MODE
9171 | OPTI_TYPE_EARLY_SKIP
9172 | OPTI_TYPE_NOT_ITERATED
9173 | OPTI_TYPE_NOT_SALTED
9174 | OPTI_TYPE_RAW_HASH;
9175 dgst_pos0 = 3;
9176 dgst_pos1 = 7;
9177 dgst_pos2 = 2;
9178 dgst_pos3 = 6;
9179 break;
9180
9181 case 5800: hash_type = HASH_TYPE_SHA1;
9182 salt_type = SALT_TYPE_INTERN;
9183 attack_exec = ATTACK_EXEC_ON_CPU;
9184 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
9185 | OPTS_TYPE_ST_ADD80;
9186 kern_type = KERN_TYPE_ANDROIDPIN;
9187 dgst_size = DGST_SIZE_4_5;
9188 parse_func = androidpin_parse_hash;
9189 sort_by_digest = sort_by_digest_4_5;
9190 opti_type = OPTI_TYPE_ZERO_BYTE;
9191 dgst_pos0 = 0;
9192 dgst_pos1 = 1;
9193 dgst_pos2 = 2;
9194 dgst_pos3 = 3;
9195 break;
9196
9197 case 6000: hash_type = HASH_TYPE_RIPEMD160;
9198 salt_type = SALT_TYPE_NONE;
9199 attack_exec = ATTACK_EXEC_ON_GPU;
9200 opts_type = OPTS_TYPE_PT_GENERATE_LE
9201 | OPTS_TYPE_PT_ADD80;
9202 kern_type = KERN_TYPE_RIPEMD160;
9203 dgst_size = DGST_SIZE_4_5;
9204 parse_func = ripemd160_parse_hash;
9205 sort_by_digest = sort_by_digest_4_5;
9206 opti_type = OPTI_TYPE_ZERO_BYTE;
9207 dgst_pos0 = 0;
9208 dgst_pos1 = 1;
9209 dgst_pos2 = 2;
9210 dgst_pos3 = 3;
9211 break;
9212
9213 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
9214 salt_type = SALT_TYPE_NONE;
9215 attack_exec = ATTACK_EXEC_ON_GPU;
9216 opts_type = OPTS_TYPE_PT_GENERATE_BE
9217 | OPTS_TYPE_PT_ADD80;
9218 kern_type = KERN_TYPE_WHIRLPOOL;
9219 dgst_size = DGST_SIZE_4_16;
9220 parse_func = whirlpool_parse_hash;
9221 sort_by_digest = sort_by_digest_4_16;
9222 opti_type = OPTI_TYPE_ZERO_BYTE;
9223 dgst_pos0 = 0;
9224 dgst_pos1 = 1;
9225 dgst_pos2 = 2;
9226 dgst_pos3 = 3;
9227 break;
9228
9229 case 6211: hash_type = HASH_TYPE_RIPEMD160;
9230 salt_type = SALT_TYPE_EMBEDDED;
9231 attack_exec = ATTACK_EXEC_ON_CPU;
9232 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9233 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9234 dgst_size = DGST_SIZE_4_5;
9235 parse_func = truecrypt_parse_hash_2k;
9236 sort_by_digest = sort_by_digest_4_5;
9237 opti_type = OPTI_TYPE_ZERO_BYTE;
9238 dgst_pos0 = 0;
9239 dgst_pos1 = 1;
9240 dgst_pos2 = 2;
9241 dgst_pos3 = 3;
9242 break;
9243
9244 case 6212: hash_type = HASH_TYPE_RIPEMD160;
9245 salt_type = SALT_TYPE_EMBEDDED;
9246 attack_exec = ATTACK_EXEC_ON_CPU;
9247 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9248 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9249 dgst_size = DGST_SIZE_4_5;
9250 parse_func = truecrypt_parse_hash_2k;
9251 sort_by_digest = sort_by_digest_4_5;
9252 opti_type = OPTI_TYPE_ZERO_BYTE;
9253 dgst_pos0 = 0;
9254 dgst_pos1 = 1;
9255 dgst_pos2 = 2;
9256 dgst_pos3 = 3;
9257 break;
9258
9259 case 6213: hash_type = HASH_TYPE_RIPEMD160;
9260 salt_type = SALT_TYPE_EMBEDDED;
9261 attack_exec = ATTACK_EXEC_ON_CPU;
9262 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9263 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9264 dgst_size = DGST_SIZE_4_5;
9265 parse_func = truecrypt_parse_hash_2k;
9266 sort_by_digest = sort_by_digest_4_5;
9267 opti_type = OPTI_TYPE_ZERO_BYTE;
9268 dgst_pos0 = 0;
9269 dgst_pos1 = 1;
9270 dgst_pos2 = 2;
9271 dgst_pos3 = 3;
9272 break;
9273
9274 case 6221: hash_type = HASH_TYPE_SHA512;
9275 salt_type = SALT_TYPE_EMBEDDED;
9276 attack_exec = ATTACK_EXEC_ON_CPU;
9277 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9278 kern_type = KERN_TYPE_TCSHA512_XTS512;
9279 dgst_size = DGST_SIZE_8_8;
9280 parse_func = truecrypt_parse_hash_1k;
9281 sort_by_digest = sort_by_digest_8_8;
9282 opti_type = OPTI_TYPE_ZERO_BYTE;
9283 dgst_pos0 = 0;
9284 dgst_pos1 = 1;
9285 dgst_pos2 = 2;
9286 dgst_pos3 = 3;
9287 break;
9288
9289 case 6222: hash_type = HASH_TYPE_SHA512;
9290 salt_type = SALT_TYPE_EMBEDDED;
9291 attack_exec = ATTACK_EXEC_ON_CPU;
9292 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9293 kern_type = KERN_TYPE_TCSHA512_XTS1024;
9294 dgst_size = DGST_SIZE_8_8;
9295 parse_func = truecrypt_parse_hash_1k;
9296 sort_by_digest = sort_by_digest_8_8;
9297 opti_type = OPTI_TYPE_ZERO_BYTE;
9298 dgst_pos0 = 0;
9299 dgst_pos1 = 1;
9300 dgst_pos2 = 2;
9301 dgst_pos3 = 3;
9302 break;
9303
9304 case 6223: hash_type = HASH_TYPE_SHA512;
9305 salt_type = SALT_TYPE_EMBEDDED;
9306 attack_exec = ATTACK_EXEC_ON_CPU;
9307 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9308 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9309 dgst_size = DGST_SIZE_8_8;
9310 parse_func = truecrypt_parse_hash_1k;
9311 sort_by_digest = sort_by_digest_8_8;
9312 opti_type = OPTI_TYPE_ZERO_BYTE;
9313 dgst_pos0 = 0;
9314 dgst_pos1 = 1;
9315 dgst_pos2 = 2;
9316 dgst_pos3 = 3;
9317 break;
9318
9319 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9320 salt_type = SALT_TYPE_EMBEDDED;
9321 attack_exec = ATTACK_EXEC_ON_CPU;
9322 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9323 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9324 dgst_size = DGST_SIZE_4_8;
9325 parse_func = truecrypt_parse_hash_1k;
9326 sort_by_digest = sort_by_digest_4_8;
9327 opti_type = OPTI_TYPE_ZERO_BYTE;
9328 dgst_pos0 = 0;
9329 dgst_pos1 = 1;
9330 dgst_pos2 = 2;
9331 dgst_pos3 = 3;
9332 break;
9333
9334 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9335 salt_type = SALT_TYPE_EMBEDDED;
9336 attack_exec = ATTACK_EXEC_ON_CPU;
9337 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9338 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9339 dgst_size = DGST_SIZE_4_8;
9340 parse_func = truecrypt_parse_hash_1k;
9341 sort_by_digest = sort_by_digest_4_8;
9342 opti_type = OPTI_TYPE_ZERO_BYTE;
9343 dgst_pos0 = 0;
9344 dgst_pos1 = 1;
9345 dgst_pos2 = 2;
9346 dgst_pos3 = 3;
9347 break;
9348
9349 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9350 salt_type = SALT_TYPE_EMBEDDED;
9351 attack_exec = ATTACK_EXEC_ON_CPU;
9352 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9353 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9354 dgst_size = DGST_SIZE_4_8;
9355 parse_func = truecrypt_parse_hash_1k;
9356 sort_by_digest = sort_by_digest_4_8;
9357 opti_type = OPTI_TYPE_ZERO_BYTE;
9358 dgst_pos0 = 0;
9359 dgst_pos1 = 1;
9360 dgst_pos2 = 2;
9361 dgst_pos3 = 3;
9362 break;
9363
9364 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9365 salt_type = SALT_TYPE_EMBEDDED;
9366 attack_exec = ATTACK_EXEC_ON_CPU;
9367 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9368 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9369 dgst_size = DGST_SIZE_4_5;
9370 parse_func = truecrypt_parse_hash_1k;
9371 sort_by_digest = sort_by_digest_4_5;
9372 opti_type = OPTI_TYPE_ZERO_BYTE;
9373 dgst_pos0 = 0;
9374 dgst_pos1 = 1;
9375 dgst_pos2 = 2;
9376 dgst_pos3 = 3;
9377 break;
9378
9379 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9380 salt_type = SALT_TYPE_EMBEDDED;
9381 attack_exec = ATTACK_EXEC_ON_CPU;
9382 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9383 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9384 dgst_size = DGST_SIZE_4_5;
9385 parse_func = truecrypt_parse_hash_1k;
9386 sort_by_digest = sort_by_digest_4_5;
9387 opti_type = OPTI_TYPE_ZERO_BYTE;
9388 dgst_pos0 = 0;
9389 dgst_pos1 = 1;
9390 dgst_pos2 = 2;
9391 dgst_pos3 = 3;
9392 break;
9393
9394 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9395 salt_type = SALT_TYPE_EMBEDDED;
9396 attack_exec = ATTACK_EXEC_ON_CPU;
9397 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9398 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9399 dgst_size = DGST_SIZE_4_5;
9400 parse_func = truecrypt_parse_hash_1k;
9401 sort_by_digest = sort_by_digest_4_5;
9402 opti_type = OPTI_TYPE_ZERO_BYTE;
9403 dgst_pos0 = 0;
9404 dgst_pos1 = 1;
9405 dgst_pos2 = 2;
9406 dgst_pos3 = 3;
9407 break;
9408
9409 case 6300: hash_type = HASH_TYPE_MD5;
9410 salt_type = SALT_TYPE_EMBEDDED;
9411 attack_exec = ATTACK_EXEC_ON_CPU;
9412 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9413 kern_type = KERN_TYPE_MD5AIX;
9414 dgst_size = DGST_SIZE_4_4;
9415 parse_func = md5aix_parse_hash;
9416 sort_by_digest = sort_by_digest_4_4;
9417 opti_type = OPTI_TYPE_ZERO_BYTE;
9418 dgst_pos0 = 0;
9419 dgst_pos1 = 1;
9420 dgst_pos2 = 2;
9421 dgst_pos3 = 3;
9422 break;
9423
9424 case 6400: hash_type = HASH_TYPE_SHA256;
9425 salt_type = SALT_TYPE_EMBEDDED;
9426 attack_exec = ATTACK_EXEC_ON_CPU;
9427 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9428 kern_type = KERN_TYPE_SHA256AIX;
9429 dgst_size = DGST_SIZE_4_8;
9430 parse_func = sha256aix_parse_hash;
9431 sort_by_digest = sort_by_digest_4_8;
9432 opti_type = OPTI_TYPE_ZERO_BYTE;
9433 dgst_pos0 = 0;
9434 dgst_pos1 = 1;
9435 dgst_pos2 = 2;
9436 dgst_pos3 = 3;
9437 break;
9438
9439 case 6500: hash_type = HASH_TYPE_SHA512;
9440 salt_type = SALT_TYPE_EMBEDDED;
9441 attack_exec = ATTACK_EXEC_ON_CPU;
9442 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9443 kern_type = KERN_TYPE_SHA512AIX;
9444 dgst_size = DGST_SIZE_8_8;
9445 parse_func = sha512aix_parse_hash;
9446 sort_by_digest = sort_by_digest_8_8;
9447 opti_type = OPTI_TYPE_ZERO_BYTE;
9448 dgst_pos0 = 0;
9449 dgst_pos1 = 1;
9450 dgst_pos2 = 2;
9451 dgst_pos3 = 3;
9452 break;
9453
9454 case 6600: hash_type = HASH_TYPE_AES;
9455 salt_type = SALT_TYPE_EMBEDDED;
9456 attack_exec = ATTACK_EXEC_ON_CPU;
9457 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9458 kern_type = KERN_TYPE_AGILEKEY;
9459 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9460 parse_func = agilekey_parse_hash;
9461 sort_by_digest = sort_by_digest_4_5;
9462 opti_type = OPTI_TYPE_ZERO_BYTE;
9463 dgst_pos0 = 0;
9464 dgst_pos1 = 1;
9465 dgst_pos2 = 2;
9466 dgst_pos3 = 3;
9467 break;
9468
9469 case 6700: hash_type = HASH_TYPE_SHA1;
9470 salt_type = SALT_TYPE_EMBEDDED;
9471 attack_exec = ATTACK_EXEC_ON_CPU;
9472 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9473 kern_type = KERN_TYPE_SHA1AIX;
9474 dgst_size = DGST_SIZE_4_5;
9475 parse_func = sha1aix_parse_hash;
9476 sort_by_digest = sort_by_digest_4_5;
9477 opti_type = OPTI_TYPE_ZERO_BYTE;
9478 dgst_pos0 = 0;
9479 dgst_pos1 = 1;
9480 dgst_pos2 = 2;
9481 dgst_pos3 = 3;
9482 break;
9483
9484 case 6800: hash_type = HASH_TYPE_AES;
9485 salt_type = SALT_TYPE_EMBEDDED;
9486 attack_exec = ATTACK_EXEC_ON_CPU;
9487 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9488 kern_type = KERN_TYPE_LASTPASS;
9489 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9490 parse_func = lastpass_parse_hash;
9491 sort_by_digest = sort_by_digest_4_8;
9492 opti_type = OPTI_TYPE_ZERO_BYTE;
9493 dgst_pos0 = 0;
9494 dgst_pos1 = 1;
9495 dgst_pos2 = 2;
9496 dgst_pos3 = 3;
9497 break;
9498
9499 case 6900: hash_type = HASH_TYPE_GOST;
9500 salt_type = SALT_TYPE_NONE;
9501 attack_exec = ATTACK_EXEC_ON_GPU;
9502 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9503 kern_type = KERN_TYPE_GOST;
9504 dgst_size = DGST_SIZE_4_8;
9505 parse_func = gost_parse_hash;
9506 sort_by_digest = sort_by_digest_4_8;
9507 opti_type = OPTI_TYPE_ZERO_BYTE;
9508 dgst_pos0 = 0;
9509 dgst_pos1 = 1;
9510 dgst_pos2 = 2;
9511 dgst_pos3 = 3;
9512 break;
9513
9514 case 7100: hash_type = HASH_TYPE_SHA512;
9515 salt_type = SALT_TYPE_EMBEDDED;
9516 attack_exec = ATTACK_EXEC_ON_CPU;
9517 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9518 kern_type = KERN_TYPE_PBKDF2_SHA512;
9519 dgst_size = DGST_SIZE_8_16;
9520 parse_func = sha512osx_parse_hash;
9521 sort_by_digest = sort_by_digest_8_16;
9522 opti_type = OPTI_TYPE_ZERO_BYTE;
9523 dgst_pos0 = 0;
9524 dgst_pos1 = 1;
9525 dgst_pos2 = 2;
9526 dgst_pos3 = 3;
9527 break;
9528
9529 case 7200: hash_type = HASH_TYPE_SHA512;
9530 salt_type = SALT_TYPE_EMBEDDED;
9531 attack_exec = ATTACK_EXEC_ON_CPU;
9532 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9533 kern_type = KERN_TYPE_PBKDF2_SHA512;
9534 dgst_size = DGST_SIZE_8_16;
9535 parse_func = sha512grub_parse_hash;
9536 sort_by_digest = sort_by_digest_8_16;
9537 opti_type = OPTI_TYPE_ZERO_BYTE;
9538 dgst_pos0 = 0;
9539 dgst_pos1 = 1;
9540 dgst_pos2 = 2;
9541 dgst_pos3 = 3;
9542 break;
9543
9544 case 7300: hash_type = HASH_TYPE_SHA1;
9545 salt_type = SALT_TYPE_EMBEDDED;
9546 attack_exec = ATTACK_EXEC_ON_GPU;
9547 opts_type = OPTS_TYPE_PT_GENERATE_BE
9548 | OPTS_TYPE_ST_ADD80
9549 | OPTS_TYPE_ST_ADDBITS15;
9550 kern_type = KERN_TYPE_RAKP;
9551 dgst_size = DGST_SIZE_4_5;
9552 parse_func = rakp_parse_hash;
9553 sort_by_digest = sort_by_digest_4_5;
9554 opti_type = OPTI_TYPE_ZERO_BYTE
9555 | OPTI_TYPE_NOT_ITERATED;
9556 dgst_pos0 = 3;
9557 dgst_pos1 = 4;
9558 dgst_pos2 = 2;
9559 dgst_pos3 = 1;
9560 break;
9561
9562 case 7400: hash_type = HASH_TYPE_SHA256;
9563 salt_type = SALT_TYPE_EMBEDDED;
9564 attack_exec = ATTACK_EXEC_ON_CPU;
9565 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9566 kern_type = KERN_TYPE_SHA256CRYPT;
9567 dgst_size = DGST_SIZE_4_8;
9568 parse_func = sha256crypt_parse_hash;
9569 sort_by_digest = sort_by_digest_4_8;
9570 opti_type = OPTI_TYPE_ZERO_BYTE;
9571 dgst_pos0 = 0;
9572 dgst_pos1 = 1;
9573 dgst_pos2 = 2;
9574 dgst_pos3 = 3;
9575 break;
9576
9577 case 7500: hash_type = HASH_TYPE_KRB5PA;
9578 salt_type = SALT_TYPE_EMBEDDED;
9579 attack_exec = ATTACK_EXEC_ON_GPU;
9580 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9581 kern_type = KERN_TYPE_KRB5PA;
9582 dgst_size = DGST_SIZE_4_4;
9583 parse_func = krb5pa_parse_hash;
9584 sort_by_digest = sort_by_digest_4_4;
9585 opti_type = OPTI_TYPE_ZERO_BYTE
9586 | OPTI_TYPE_NOT_ITERATED;
9587 dgst_pos0 = 3;
9588 dgst_pos1 = 7;
9589 dgst_pos2 = 2;
9590 dgst_pos3 = 6;
9591 break;
9592
9593 case 7600: hash_type = HASH_TYPE_SHA1;
9594 salt_type = SALT_TYPE_INTERN;
9595 attack_exec = ATTACK_EXEC_ON_GPU;
9596 opts_type = OPTS_TYPE_PT_GENERATE_BE
9597 | OPTS_TYPE_PT_ADD80
9598 | OPTS_TYPE_PT_ADDBITS15;
9599 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9600 dgst_size = DGST_SIZE_4_5;
9601 parse_func = redmine_parse_hash;
9602 sort_by_digest = sort_by_digest_4_5;
9603 opti_type = OPTI_TYPE_ZERO_BYTE
9604 | OPTI_TYPE_PRECOMPUTE_INIT
9605 | OPTI_TYPE_EARLY_SKIP
9606 | OPTI_TYPE_NOT_ITERATED
9607 | OPTI_TYPE_PREPENDED_SALT;
9608 dgst_pos0 = 3;
9609 dgst_pos1 = 4;
9610 dgst_pos2 = 2;
9611 dgst_pos3 = 1;
9612 break;
9613
9614 case 7700: hash_type = HASH_TYPE_SAPB;
9615 salt_type = SALT_TYPE_EMBEDDED;
9616 attack_exec = ATTACK_EXEC_ON_GPU;
9617 opts_type = OPTS_TYPE_PT_GENERATE_LE
9618 | OPTS_TYPE_PT_UPPER
9619 | OPTS_TYPE_ST_UPPER;
9620 kern_type = KERN_TYPE_SAPB;
9621 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9622 parse_func = sapb_parse_hash;
9623 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9624 opti_type = OPTI_TYPE_ZERO_BYTE
9625 | OPTI_TYPE_PRECOMPUTE_INIT
9626 | OPTI_TYPE_NOT_ITERATED;
9627 dgst_pos0 = 0;
9628 dgst_pos1 = 1;
9629 dgst_pos2 = 2;
9630 dgst_pos3 = 3;
9631 break;
9632
9633 case 7800: hash_type = HASH_TYPE_SAPG;
9634 salt_type = SALT_TYPE_EMBEDDED;
9635 attack_exec = ATTACK_EXEC_ON_GPU;
9636 opts_type = OPTS_TYPE_PT_GENERATE_BE
9637 | OPTS_TYPE_ST_ADD80
9638 | OPTS_TYPE_ST_UPPER;
9639 kern_type = KERN_TYPE_SAPG;
9640 dgst_size = DGST_SIZE_4_5;
9641 parse_func = sapg_parse_hash;
9642 sort_by_digest = sort_by_digest_4_5;
9643 opti_type = OPTI_TYPE_ZERO_BYTE
9644 | OPTI_TYPE_PRECOMPUTE_INIT
9645 | OPTI_TYPE_NOT_ITERATED;
9646 dgst_pos0 = 3;
9647 dgst_pos1 = 4;
9648 dgst_pos2 = 2;
9649 dgst_pos3 = 1;
9650 break;
9651
9652 case 7900: hash_type = HASH_TYPE_SHA512;
9653 salt_type = SALT_TYPE_EMBEDDED;
9654 attack_exec = ATTACK_EXEC_ON_CPU;
9655 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9656 kern_type = KERN_TYPE_DRUPAL7;
9657 dgst_size = DGST_SIZE_8_8;
9658 parse_func = drupal7_parse_hash;
9659 sort_by_digest = sort_by_digest_8_8;
9660 opti_type = OPTI_TYPE_ZERO_BYTE;
9661 dgst_pos0 = 0;
9662 dgst_pos1 = 1;
9663 dgst_pos2 = 2;
9664 dgst_pos3 = 3;
9665 break;
9666
9667 case 8000: hash_type = HASH_TYPE_SHA256;
9668 salt_type = SALT_TYPE_EMBEDDED;
9669 attack_exec = ATTACK_EXEC_ON_GPU;
9670 opts_type = OPTS_TYPE_PT_GENERATE_BE
9671 | OPTS_TYPE_PT_UNICODE
9672 | OPTS_TYPE_ST_ADD80
9673 | OPTS_TYPE_ST_HEX;
9674 kern_type = KERN_TYPE_SYBASEASE;
9675 dgst_size = DGST_SIZE_4_8;
9676 parse_func = sybasease_parse_hash;
9677 sort_by_digest = sort_by_digest_4_8;
9678 opti_type = OPTI_TYPE_ZERO_BYTE
9679 | OPTI_TYPE_PRECOMPUTE_INIT
9680 | OPTI_TYPE_SCALAR_MODE
9681 | OPTI_TYPE_EARLY_SKIP
9682 | OPTI_TYPE_NOT_ITERATED
9683 | OPTI_TYPE_RAW_HASH;
9684 dgst_pos0 = 3;
9685 dgst_pos1 = 7;
9686 dgst_pos2 = 2;
9687 dgst_pos3 = 6;
9688 break;
9689
9690 case 8100: hash_type = HASH_TYPE_SHA1;
9691 salt_type = SALT_TYPE_EMBEDDED;
9692 attack_exec = ATTACK_EXEC_ON_GPU;
9693 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9694 kern_type = KERN_TYPE_NETSCALER;
9695 dgst_size = DGST_SIZE_4_5;
9696 parse_func = netscaler_parse_hash;
9697 sort_by_digest = sort_by_digest_4_5;
9698 opti_type = OPTI_TYPE_ZERO_BYTE
9699 | OPTI_TYPE_PRECOMPUTE_INIT
9700 | OPTI_TYPE_PRECOMPUTE_MERKLE
9701 | OPTI_TYPE_EARLY_SKIP
9702 | OPTI_TYPE_NOT_ITERATED
9703 | OPTI_TYPE_PREPENDED_SALT
9704 | OPTI_TYPE_RAW_HASH;
9705 dgst_pos0 = 3;
9706 dgst_pos1 = 4;
9707 dgst_pos2 = 2;
9708 dgst_pos3 = 1;
9709 break;
9710
9711 case 8200: hash_type = HASH_TYPE_SHA256;
9712 salt_type = SALT_TYPE_EMBEDDED;
9713 attack_exec = ATTACK_EXEC_ON_CPU;
9714 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9715 kern_type = KERN_TYPE_CLOUDKEY;
9716 dgst_size = DGST_SIZE_4_8;
9717 parse_func = cloudkey_parse_hash;
9718 sort_by_digest = sort_by_digest_4_8;
9719 opti_type = OPTI_TYPE_ZERO_BYTE;
9720 dgst_pos0 = 0;
9721 dgst_pos1 = 1;
9722 dgst_pos2 = 2;
9723 dgst_pos3 = 3;
9724 break;
9725
9726 case 8300: hash_type = HASH_TYPE_SHA1;
9727 salt_type = SALT_TYPE_EMBEDDED;
9728 attack_exec = ATTACK_EXEC_ON_GPU;
9729 opts_type = OPTS_TYPE_PT_GENERATE_LE
9730 | OPTS_TYPE_ST_HEX
9731 | OPTS_TYPE_ST_ADD80;
9732 kern_type = KERN_TYPE_NSEC3;
9733 dgst_size = DGST_SIZE_4_5;
9734 parse_func = nsec3_parse_hash;
9735 sort_by_digest = sort_by_digest_4_5;
9736 opti_type = OPTI_TYPE_ZERO_BYTE;
9737 dgst_pos0 = 3;
9738 dgst_pos1 = 4;
9739 dgst_pos2 = 2;
9740 dgst_pos3 = 1;
9741 break;
9742
9743 case 8400: hash_type = HASH_TYPE_SHA1;
9744 salt_type = SALT_TYPE_INTERN;
9745 attack_exec = ATTACK_EXEC_ON_GPU;
9746 opts_type = OPTS_TYPE_PT_GENERATE_BE
9747 | OPTS_TYPE_PT_ADD80
9748 | OPTS_TYPE_PT_ADDBITS15;
9749 kern_type = KERN_TYPE_WBB3;
9750 dgst_size = DGST_SIZE_4_5;
9751 parse_func = wbb3_parse_hash;
9752 sort_by_digest = sort_by_digest_4_5;
9753 opti_type = OPTI_TYPE_ZERO_BYTE
9754 | OPTI_TYPE_PRECOMPUTE_INIT
9755 | OPTI_TYPE_NOT_ITERATED;
9756 dgst_pos0 = 3;
9757 dgst_pos1 = 4;
9758 dgst_pos2 = 2;
9759 dgst_pos3 = 1;
9760 break;
9761
9762 case 8500: hash_type = HASH_TYPE_DESRACF;
9763 salt_type = SALT_TYPE_EMBEDDED;
9764 attack_exec = ATTACK_EXEC_ON_GPU;
9765 opts_type = OPTS_TYPE_PT_GENERATE_LE
9766 | OPTS_TYPE_ST_UPPER;
9767 kern_type = KERN_TYPE_RACF;
9768 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9769 parse_func = racf_parse_hash;
9770 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9771 opti_type = OPTI_TYPE_ZERO_BYTE
9772 | OPTI_TYPE_SCALAR_MODE
9773 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9774 dgst_pos0 = 0;
9775 dgst_pos1 = 1;
9776 dgst_pos2 = 2;
9777 dgst_pos3 = 3;
9778 break;
9779
9780 case 8600: hash_type = HASH_TYPE_LOTUS5;
9781 salt_type = SALT_TYPE_NONE;
9782 attack_exec = ATTACK_EXEC_ON_GPU;
9783 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9784 kern_type = KERN_TYPE_LOTUS5;
9785 dgst_size = DGST_SIZE_4_4;
9786 parse_func = lotus5_parse_hash;
9787 sort_by_digest = sort_by_digest_4_4;
9788 opti_type = OPTI_TYPE_SCALAR_MODE
9789 | OPTI_TYPE_EARLY_SKIP
9790 | OPTI_TYPE_NOT_ITERATED
9791 | OPTI_TYPE_NOT_SALTED
9792 | OPTI_TYPE_RAW_HASH;
9793 dgst_pos0 = 0;
9794 dgst_pos1 = 1;
9795 dgst_pos2 = 2;
9796 dgst_pos3 = 3;
9797 break;
9798
9799 case 8700: hash_type = HASH_TYPE_LOTUS6;
9800 salt_type = SALT_TYPE_EMBEDDED;
9801 attack_exec = ATTACK_EXEC_ON_GPU;
9802 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9803 kern_type = KERN_TYPE_LOTUS6;
9804 dgst_size = DGST_SIZE_4_4;
9805 parse_func = lotus6_parse_hash;
9806 sort_by_digest = sort_by_digest_4_4;
9807 opti_type = OPTI_TYPE_SCALAR_MODE
9808 | OPTI_TYPE_EARLY_SKIP
9809 | OPTI_TYPE_NOT_ITERATED
9810 | OPTI_TYPE_RAW_HASH;
9811 dgst_pos0 = 0;
9812 dgst_pos1 = 1;
9813 dgst_pos2 = 2;
9814 dgst_pos3 = 3;
9815 break;
9816
9817 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9818 salt_type = SALT_TYPE_EMBEDDED;
9819 attack_exec = ATTACK_EXEC_ON_CPU;
9820 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9821 kern_type = KERN_TYPE_ANDROIDFDE;
9822 dgst_size = DGST_SIZE_4_4;
9823 parse_func = androidfde_parse_hash;
9824 sort_by_digest = sort_by_digest_4_4;
9825 opti_type = OPTI_TYPE_ZERO_BYTE;
9826 dgst_pos0 = 0;
9827 dgst_pos1 = 1;
9828 dgst_pos2 = 2;
9829 dgst_pos3 = 3;
9830 break;
9831
9832 case 8900: hash_type = HASH_TYPE_SCRYPT;
9833 salt_type = SALT_TYPE_EMBEDDED;
9834 attack_exec = ATTACK_EXEC_ON_CPU;
9835 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9836 kern_type = KERN_TYPE_SCRYPT;
9837 dgst_size = DGST_SIZE_4_8;
9838 parse_func = scrypt_parse_hash;
9839 sort_by_digest = sort_by_digest_4_8;
9840 opti_type = OPTI_TYPE_ZERO_BYTE;
9841 dgst_pos0 = 0;
9842 dgst_pos1 = 1;
9843 dgst_pos2 = 2;
9844 dgst_pos3 = 3;
9845 break;
9846
9847 case 9000: hash_type = HASH_TYPE_SHA1;
9848 salt_type = SALT_TYPE_EMBEDDED;
9849 attack_exec = ATTACK_EXEC_ON_CPU;
9850 opts_type = OPTS_TYPE_PT_GENERATE_LE
9851 | OPTS_TYPE_ST_GENERATE_LE;
9852 kern_type = KERN_TYPE_PSAFE2;
9853 dgst_size = DGST_SIZE_4_5;
9854 parse_func = psafe2_parse_hash;
9855 sort_by_digest = sort_by_digest_4_5;
9856 opti_type = OPTI_TYPE_ZERO_BYTE;
9857 dgst_pos0 = 0;
9858 dgst_pos1 = 1;
9859 dgst_pos2 = 2;
9860 dgst_pos3 = 3;
9861 break;
9862
9863 case 9100: hash_type = HASH_TYPE_LOTUS8;
9864 salt_type = SALT_TYPE_EMBEDDED;
9865 attack_exec = ATTACK_EXEC_ON_CPU;
9866 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9867 kern_type = KERN_TYPE_LOTUS8;
9868 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9869 parse_func = lotus8_parse_hash;
9870 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9871 opti_type = OPTI_TYPE_ZERO_BYTE;
9872 dgst_pos0 = 0;
9873 dgst_pos1 = 1;
9874 dgst_pos2 = 2;
9875 dgst_pos3 = 3;
9876 break;
9877
9878 case 9200: hash_type = HASH_TYPE_SHA256;
9879 salt_type = SALT_TYPE_EMBEDDED;
9880 attack_exec = ATTACK_EXEC_ON_CPU;
9881 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9882 kern_type = KERN_TYPE_PBKDF2_SHA256;
9883 dgst_size = DGST_SIZE_4_32;
9884 parse_func = cisco8_parse_hash;
9885 sort_by_digest = sort_by_digest_4_32;
9886 opti_type = OPTI_TYPE_ZERO_BYTE;
9887 dgst_pos0 = 0;
9888 dgst_pos1 = 1;
9889 dgst_pos2 = 2;
9890 dgst_pos3 = 3;
9891 break;
9892
9893 case 9300: hash_type = HASH_TYPE_SCRYPT;
9894 salt_type = SALT_TYPE_EMBEDDED;
9895 attack_exec = ATTACK_EXEC_ON_CPU;
9896 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9897 kern_type = KERN_TYPE_SCRYPT;
9898 dgst_size = DGST_SIZE_4_8;
9899 parse_func = cisco9_parse_hash;
9900 sort_by_digest = sort_by_digest_4_8;
9901 opti_type = OPTI_TYPE_ZERO_BYTE;
9902 dgst_pos0 = 0;
9903 dgst_pos1 = 1;
9904 dgst_pos2 = 2;
9905 dgst_pos3 = 3;
9906 break;
9907
9908 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9909 salt_type = SALT_TYPE_EMBEDDED;
9910 attack_exec = ATTACK_EXEC_ON_CPU;
9911 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9912 kern_type = KERN_TYPE_OFFICE2007;
9913 dgst_size = DGST_SIZE_4_4;
9914 parse_func = office2007_parse_hash;
9915 sort_by_digest = sort_by_digest_4_4;
9916 opti_type = OPTI_TYPE_ZERO_BYTE;
9917 dgst_pos0 = 0;
9918 dgst_pos1 = 1;
9919 dgst_pos2 = 2;
9920 dgst_pos3 = 3;
9921 break;
9922
9923 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9924 salt_type = SALT_TYPE_EMBEDDED;
9925 attack_exec = ATTACK_EXEC_ON_CPU;
9926 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9927 kern_type = KERN_TYPE_OFFICE2010;
9928 dgst_size = DGST_SIZE_4_4;
9929 parse_func = office2010_parse_hash;
9930 sort_by_digest = sort_by_digest_4_4;
9931 opti_type = OPTI_TYPE_ZERO_BYTE;
9932 dgst_pos0 = 0;
9933 dgst_pos1 = 1;
9934 dgst_pos2 = 2;
9935 dgst_pos3 = 3;
9936 break;
9937
9938 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9939 salt_type = SALT_TYPE_EMBEDDED;
9940 attack_exec = ATTACK_EXEC_ON_CPU;
9941 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9942 kern_type = KERN_TYPE_OFFICE2013;
9943 dgst_size = DGST_SIZE_4_4;
9944 parse_func = office2013_parse_hash;
9945 sort_by_digest = sort_by_digest_4_4;
9946 opti_type = OPTI_TYPE_ZERO_BYTE;
9947 dgst_pos0 = 0;
9948 dgst_pos1 = 1;
9949 dgst_pos2 = 2;
9950 dgst_pos3 = 3;
9951 break;
9952
9953 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9954 salt_type = SALT_TYPE_EMBEDDED;
9955 attack_exec = ATTACK_EXEC_ON_GPU;
9956 opts_type = OPTS_TYPE_PT_GENERATE_LE
9957 | OPTS_TYPE_PT_ADD80
9958 | OPTS_TYPE_PT_UNICODE;
9959 kern_type = KERN_TYPE_OLDOFFICE01;
9960 dgst_size = DGST_SIZE_4_4;
9961 parse_func = oldoffice01_parse_hash;
9962 sort_by_digest = sort_by_digest_4_4;
9963 opti_type = OPTI_TYPE_ZERO_BYTE
9964 | OPTI_TYPE_PRECOMPUTE_INIT
9965 | OPTI_TYPE_NOT_ITERATED;
9966 dgst_pos0 = 0;
9967 dgst_pos1 = 1;
9968 dgst_pos2 = 2;
9969 dgst_pos3 = 3;
9970 break;
9971
9972 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9973 salt_type = SALT_TYPE_EMBEDDED;
9974 attack_exec = ATTACK_EXEC_ON_GPU;
9975 opts_type = OPTS_TYPE_PT_GENERATE_LE
9976 | OPTS_TYPE_PT_ADD80;
9977 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9978 dgst_size = DGST_SIZE_4_4;
9979 parse_func = oldoffice01cm1_parse_hash;
9980 sort_by_digest = sort_by_digest_4_4;
9981 opti_type = OPTI_TYPE_ZERO_BYTE
9982 | OPTI_TYPE_PRECOMPUTE_INIT
9983 | OPTI_TYPE_NOT_ITERATED;
9984 dgst_pos0 = 0;
9985 dgst_pos1 = 1;
9986 dgst_pos2 = 2;
9987 dgst_pos3 = 3;
9988 break;
9989
9990 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9991 salt_type = SALT_TYPE_EMBEDDED;
9992 attack_exec = ATTACK_EXEC_ON_GPU;
9993 opts_type = OPTS_TYPE_PT_GENERATE_LE
9994 | OPTS_TYPE_PT_ADD80
9995 | OPTS_TYPE_PT_UNICODE
9996 | OPTS_TYPE_PT_NEVERCRACK;
9997 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9998 dgst_size = DGST_SIZE_4_4;
9999 parse_func = oldoffice01cm2_parse_hash;
10000 sort_by_digest = sort_by_digest_4_4;
10001 opti_type = OPTI_TYPE_ZERO_BYTE
10002 | OPTI_TYPE_PRECOMPUTE_INIT
10003 | OPTI_TYPE_NOT_ITERATED;
10004 dgst_pos0 = 0;
10005 dgst_pos1 = 1;
10006 dgst_pos2 = 2;
10007 dgst_pos3 = 3;
10008 break;
10009
10010 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
10011 salt_type = SALT_TYPE_EMBEDDED;
10012 attack_exec = ATTACK_EXEC_ON_GPU;
10013 opts_type = OPTS_TYPE_PT_GENERATE_BE
10014 | OPTS_TYPE_PT_ADD80
10015 | OPTS_TYPE_PT_UNICODE;
10016 kern_type = KERN_TYPE_OLDOFFICE34;
10017 dgst_size = DGST_SIZE_4_4;
10018 parse_func = oldoffice34_parse_hash;
10019 sort_by_digest = sort_by_digest_4_4;
10020 opti_type = OPTI_TYPE_ZERO_BYTE
10021 | OPTI_TYPE_PRECOMPUTE_INIT
10022 | OPTI_TYPE_NOT_ITERATED;
10023 dgst_pos0 = 0;
10024 dgst_pos1 = 1;
10025 dgst_pos2 = 2;
10026 dgst_pos3 = 3;
10027 break;
10028
10029 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
10030 salt_type = SALT_TYPE_EMBEDDED;
10031 attack_exec = ATTACK_EXEC_ON_GPU;
10032 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10033 kern_type = KERN_TYPE_OLDOFFICE34CM1;
10034 dgst_size = DGST_SIZE_4_4;
10035 parse_func = oldoffice34cm1_parse_hash;
10036 sort_by_digest = sort_by_digest_4_4;
10037 opti_type = OPTI_TYPE_ZERO_BYTE
10038 | OPTI_TYPE_PRECOMPUTE_INIT
10039 | OPTI_TYPE_NOT_ITERATED;
10040 dgst_pos0 = 0;
10041 dgst_pos1 = 1;
10042 dgst_pos2 = 2;
10043 dgst_pos3 = 3;
10044 break;
10045
10046 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
10047 salt_type = SALT_TYPE_EMBEDDED;
10048 attack_exec = ATTACK_EXEC_ON_GPU;
10049 opts_type = OPTS_TYPE_PT_GENERATE_BE
10050 | OPTS_TYPE_PT_ADD80
10051 | OPTS_TYPE_PT_UNICODE
10052 | OPTS_TYPE_PT_NEVERCRACK;
10053 kern_type = KERN_TYPE_OLDOFFICE34CM2;
10054 dgst_size = DGST_SIZE_4_4;
10055 parse_func = oldoffice34cm2_parse_hash;
10056 sort_by_digest = sort_by_digest_4_4;
10057 opti_type = OPTI_TYPE_ZERO_BYTE
10058 | OPTI_TYPE_PRECOMPUTE_INIT
10059 | OPTI_TYPE_NOT_ITERATED;
10060 dgst_pos0 = 0;
10061 dgst_pos1 = 1;
10062 dgst_pos2 = 2;
10063 dgst_pos3 = 3;
10064 break;
10065
10066 case 9900: hash_type = HASH_TYPE_MD5;
10067 salt_type = SALT_TYPE_NONE;
10068 attack_exec = ATTACK_EXEC_ON_GPU;
10069 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10070 kern_type = KERN_TYPE_RADMIN2;
10071 dgst_size = DGST_SIZE_4_4;
10072 parse_func = radmin2_parse_hash;
10073 sort_by_digest = sort_by_digest_4_4;
10074 opti_type = OPTI_TYPE_ZERO_BYTE
10075 | OPTI_TYPE_PRECOMPUTE_INIT
10076 | OPTI_TYPE_SCALAR_MODE
10077 | OPTI_TYPE_EARLY_SKIP
10078 | OPTI_TYPE_NOT_ITERATED
10079 | OPTI_TYPE_NOT_SALTED;
10080 dgst_pos0 = 0;
10081 dgst_pos1 = 3;
10082 dgst_pos2 = 2;
10083 dgst_pos3 = 1;
10084 break;
10085
10086 case 10000: hash_type = HASH_TYPE_SHA256;
10087 salt_type = SALT_TYPE_EMBEDDED;
10088 attack_exec = ATTACK_EXEC_ON_CPU;
10089 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10090 kern_type = KERN_TYPE_PBKDF2_SHA256;
10091 dgst_size = DGST_SIZE_4_32;
10092 parse_func = djangopbkdf2_parse_hash;
10093 sort_by_digest = sort_by_digest_4_32;
10094 opti_type = OPTI_TYPE_ZERO_BYTE;
10095 dgst_pos0 = 0;
10096 dgst_pos1 = 1;
10097 dgst_pos2 = 2;
10098 dgst_pos3 = 3;
10099 break;
10100
10101 case 10100: hash_type = HASH_TYPE_SIPHASH;
10102 salt_type = SALT_TYPE_EMBEDDED;
10103 attack_exec = ATTACK_EXEC_ON_GPU;
10104 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10105 kern_type = KERN_TYPE_SIPHASH;
10106 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10107 parse_func = siphash_parse_hash;
10108 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10109 opti_type = OPTI_TYPE_ZERO_BYTE
10110 | OPTI_TYPE_SCALAR_MODE
10111 | OPTI_TYPE_NOT_ITERATED
10112 | OPTI_TYPE_RAW_HASH;
10113 dgst_pos0 = 0;
10114 dgst_pos1 = 1;
10115 dgst_pos2 = 2;
10116 dgst_pos3 = 3;
10117 break;
10118
10119 case 10200: hash_type = HASH_TYPE_MD5;
10120 salt_type = SALT_TYPE_EMBEDDED;
10121 attack_exec = ATTACK_EXEC_ON_GPU;
10122 opts_type = OPTS_TYPE_PT_GENERATE_LE
10123 | OPTS_TYPE_ST_ADD80
10124 | OPTS_TYPE_ST_ADDBITS14;
10125 kern_type = KERN_TYPE_HMACMD5_PW;
10126 dgst_size = DGST_SIZE_4_4;
10127 parse_func = crammd5_parse_hash;
10128 sort_by_digest = sort_by_digest_4_4;
10129 opti_type = OPTI_TYPE_ZERO_BYTE
10130 | OPTI_TYPE_NOT_ITERATED;
10131 dgst_pos0 = 0;
10132 dgst_pos1 = 3;
10133 dgst_pos2 = 2;
10134 dgst_pos3 = 1;
10135 break;
10136
10137 case 10300: hash_type = HASH_TYPE_SHA1;
10138 salt_type = SALT_TYPE_EMBEDDED;
10139 attack_exec = ATTACK_EXEC_ON_CPU;
10140 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10141 kern_type = KERN_TYPE_SAPH_SHA1;
10142 dgst_size = DGST_SIZE_4_5;
10143 parse_func = saph_sha1_parse_hash;
10144 sort_by_digest = sort_by_digest_4_5;
10145 opti_type = OPTI_TYPE_ZERO_BYTE;
10146 dgst_pos0 = 0;
10147 dgst_pos1 = 1;
10148 dgst_pos2 = 2;
10149 dgst_pos3 = 3;
10150 break;
10151
10152 case 10400: hash_type = HASH_TYPE_PDFU16;
10153 salt_type = SALT_TYPE_EMBEDDED;
10154 attack_exec = ATTACK_EXEC_ON_GPU;
10155 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10156 kern_type = KERN_TYPE_PDF11;
10157 dgst_size = DGST_SIZE_4_4;
10158 parse_func = pdf11_parse_hash;
10159 sort_by_digest = sort_by_digest_4_4;
10160 opti_type = OPTI_TYPE_ZERO_BYTE
10161 | OPTI_TYPE_NOT_ITERATED;
10162 dgst_pos0 = 0;
10163 dgst_pos1 = 1;
10164 dgst_pos2 = 2;
10165 dgst_pos3 = 3;
10166 break;
10167
10168 case 10410: hash_type = HASH_TYPE_PDFU16;
10169 salt_type = SALT_TYPE_EMBEDDED;
10170 attack_exec = ATTACK_EXEC_ON_GPU;
10171 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10172 kern_type = KERN_TYPE_PDF11CM1;
10173 dgst_size = DGST_SIZE_4_4;
10174 parse_func = pdf11cm1_parse_hash;
10175 sort_by_digest = sort_by_digest_4_4;
10176 opti_type = OPTI_TYPE_ZERO_BYTE
10177 | OPTI_TYPE_NOT_ITERATED;
10178 dgst_pos0 = 0;
10179 dgst_pos1 = 1;
10180 dgst_pos2 = 2;
10181 dgst_pos3 = 3;
10182 break;
10183
10184 case 10420: hash_type = HASH_TYPE_PDFU16;
10185 salt_type = SALT_TYPE_EMBEDDED;
10186 attack_exec = ATTACK_EXEC_ON_GPU;
10187 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10188 kern_type = KERN_TYPE_PDF11CM2;
10189 dgst_size = DGST_SIZE_4_4;
10190 parse_func = pdf11cm2_parse_hash;
10191 sort_by_digest = sort_by_digest_4_4;
10192 opti_type = OPTI_TYPE_ZERO_BYTE
10193 | OPTI_TYPE_NOT_ITERATED;
10194 dgst_pos0 = 0;
10195 dgst_pos1 = 1;
10196 dgst_pos2 = 2;
10197 dgst_pos3 = 3;
10198 break;
10199
10200 case 10500: hash_type = HASH_TYPE_PDFU16;
10201 salt_type = SALT_TYPE_EMBEDDED;
10202 attack_exec = ATTACK_EXEC_ON_CPU;
10203 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10204 kern_type = KERN_TYPE_PDF14;
10205 dgst_size = DGST_SIZE_4_4;
10206 parse_func = pdf14_parse_hash;
10207 sort_by_digest = sort_by_digest_4_4;
10208 opti_type = OPTI_TYPE_ZERO_BYTE
10209 | OPTI_TYPE_NOT_ITERATED;
10210 dgst_pos0 = 0;
10211 dgst_pos1 = 1;
10212 dgst_pos2 = 2;
10213 dgst_pos3 = 3;
10214 break;
10215
10216 case 10600: hash_type = HASH_TYPE_SHA256;
10217 salt_type = SALT_TYPE_EMBEDDED;
10218 attack_exec = ATTACK_EXEC_ON_GPU;
10219 opts_type = OPTS_TYPE_PT_GENERATE_BE
10220 | OPTS_TYPE_ST_ADD80
10221 | OPTS_TYPE_ST_ADDBITS15
10222 | OPTS_TYPE_HASH_COPY;
10223 kern_type = KERN_TYPE_SHA256_PWSLT;
10224 dgst_size = DGST_SIZE_4_8;
10225 parse_func = pdf17l3_parse_hash;
10226 sort_by_digest = sort_by_digest_4_8;
10227 opti_type = OPTI_TYPE_ZERO_BYTE
10228 | OPTI_TYPE_PRECOMPUTE_INIT
10229 | OPTI_TYPE_PRECOMPUTE_MERKLE
10230 | OPTI_TYPE_SCALAR_MODE
10231 | OPTI_TYPE_EARLY_SKIP
10232 | OPTI_TYPE_NOT_ITERATED
10233 | OPTI_TYPE_APPENDED_SALT
10234 | OPTI_TYPE_RAW_HASH;
10235 dgst_pos0 = 3;
10236 dgst_pos1 = 7;
10237 dgst_pos2 = 2;
10238 dgst_pos3 = 6;
10239 break;
10240
10241 case 10700: hash_type = HASH_TYPE_PDFU32;
10242 salt_type = SALT_TYPE_EMBEDDED;
10243 attack_exec = ATTACK_EXEC_ON_CPU;
10244 opts_type = OPTS_TYPE_PT_GENERATE_LE
10245 | OPTS_TYPE_HASH_COPY;
10246 kern_type = KERN_TYPE_PDF17L8;
10247 dgst_size = DGST_SIZE_4_8;
10248 parse_func = pdf17l8_parse_hash;
10249 sort_by_digest = sort_by_digest_4_8;
10250 opti_type = OPTI_TYPE_ZERO_BYTE
10251 | OPTI_TYPE_NOT_ITERATED;
10252 dgst_pos0 = 0;
10253 dgst_pos1 = 1;
10254 dgst_pos2 = 2;
10255 dgst_pos3 = 3;
10256 break;
10257
10258 case 10800: hash_type = HASH_TYPE_SHA384;
10259 salt_type = SALT_TYPE_NONE;
10260 attack_exec = ATTACK_EXEC_ON_GPU;
10261 opts_type = OPTS_TYPE_PT_GENERATE_BE
10262 | OPTS_TYPE_PT_ADD80
10263 | OPTS_TYPE_PT_ADDBITS15;
10264 kern_type = KERN_TYPE_SHA384;
10265 dgst_size = DGST_SIZE_8_8;
10266 parse_func = sha384_parse_hash;
10267 sort_by_digest = sort_by_digest_8_8;
10268 opti_type = OPTI_TYPE_ZERO_BYTE
10269 | OPTI_TYPE_PRECOMPUTE_INIT
10270 | OPTI_TYPE_PRECOMPUTE_MERKLE
10271 | OPTI_TYPE_SCALAR_MODE
10272 | OPTI_TYPE_EARLY_SKIP
10273 | OPTI_TYPE_NOT_ITERATED
10274 | OPTI_TYPE_NOT_SALTED
10275 | OPTI_TYPE_RAW_HASH;
10276 dgst_pos0 = 6;
10277 dgst_pos1 = 7;
10278 dgst_pos2 = 4;
10279 dgst_pos3 = 5;
10280 break;
10281
10282 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10283 salt_type = SALT_TYPE_EMBEDDED;
10284 attack_exec = ATTACK_EXEC_ON_CPU;
10285 opts_type = OPTS_TYPE_PT_GENERATE_LE
10286 | OPTS_TYPE_ST_BASE64
10287 | OPTS_TYPE_HASH_COPY;
10288 kern_type = KERN_TYPE_PBKDF2_SHA256;
10289 dgst_size = DGST_SIZE_4_32;
10290 parse_func = pbkdf2_sha256_parse_hash;
10291 sort_by_digest = sort_by_digest_4_32;
10292 opti_type = OPTI_TYPE_ZERO_BYTE;
10293 dgst_pos0 = 0;
10294 dgst_pos1 = 1;
10295 dgst_pos2 = 2;
10296 dgst_pos3 = 3;
10297 break;
10298
10299 case 11000: hash_type = HASH_TYPE_MD5;
10300 salt_type = SALT_TYPE_INTERN;
10301 attack_exec = ATTACK_EXEC_ON_GPU;
10302 opts_type = OPTS_TYPE_PT_GENERATE_LE
10303 | OPTS_TYPE_PT_ADD80;
10304 kern_type = KERN_TYPE_PRESTASHOP;
10305 dgst_size = DGST_SIZE_4_4;
10306 parse_func = prestashop_parse_hash;
10307 sort_by_digest = sort_by_digest_4_4;
10308 opti_type = OPTI_TYPE_ZERO_BYTE
10309 | OPTI_TYPE_PRECOMPUTE_INIT
10310 | OPTI_TYPE_NOT_ITERATED
10311 | OPTI_TYPE_PREPENDED_SALT;
10312 dgst_pos0 = 0;
10313 dgst_pos1 = 3;
10314 dgst_pos2 = 2;
10315 dgst_pos3 = 1;
10316 break;
10317
10318 case 11100: hash_type = HASH_TYPE_MD5;
10319 salt_type = SALT_TYPE_EMBEDDED;
10320 attack_exec = ATTACK_EXEC_ON_GPU;
10321 opts_type = OPTS_TYPE_PT_GENERATE_LE
10322 | OPTS_TYPE_ST_ADD80;
10323 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10324 dgst_size = DGST_SIZE_4_4;
10325 parse_func = postgresql_auth_parse_hash;
10326 sort_by_digest = sort_by_digest_4_4;
10327 opti_type = OPTI_TYPE_ZERO_BYTE
10328 | OPTI_TYPE_PRECOMPUTE_INIT
10329 | OPTI_TYPE_PRECOMPUTE_MERKLE
10330 | OPTI_TYPE_EARLY_SKIP;
10331 dgst_pos0 = 0;
10332 dgst_pos1 = 3;
10333 dgst_pos2 = 2;
10334 dgst_pos3 = 1;
10335 break;
10336
10337 case 11200: hash_type = HASH_TYPE_SHA1;
10338 salt_type = SALT_TYPE_EMBEDDED;
10339 attack_exec = ATTACK_EXEC_ON_GPU;
10340 opts_type = OPTS_TYPE_PT_GENERATE_BE
10341 | OPTS_TYPE_PT_ADD80
10342 | OPTS_TYPE_ST_HEX;
10343 kern_type = KERN_TYPE_MYSQL_AUTH;
10344 dgst_size = DGST_SIZE_4_5;
10345 parse_func = mysql_auth_parse_hash;
10346 sort_by_digest = sort_by_digest_4_5;
10347 opti_type = OPTI_TYPE_ZERO_BYTE
10348 | OPTI_TYPE_EARLY_SKIP;
10349 dgst_pos0 = 3;
10350 dgst_pos1 = 4;
10351 dgst_pos2 = 2;
10352 dgst_pos3 = 1;
10353 break;
10354
10355 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10356 salt_type = SALT_TYPE_EMBEDDED;
10357 attack_exec = ATTACK_EXEC_ON_CPU;
10358 opts_type = OPTS_TYPE_PT_GENERATE_LE
10359 | OPTS_TYPE_ST_HEX
10360 | OPTS_TYPE_ST_ADD80;
10361 kern_type = KERN_TYPE_BITCOIN_WALLET;
10362 dgst_size = DGST_SIZE_4_4;
10363 parse_func = bitcoin_wallet_parse_hash;
10364 sort_by_digest = sort_by_digest_4_4;
10365 opti_type = OPTI_TYPE_ZERO_BYTE;
10366 dgst_pos0 = 0;
10367 dgst_pos1 = 1;
10368 dgst_pos2 = 2;
10369 dgst_pos3 = 3;
10370 break;
10371
10372 case 11400: hash_type = HASH_TYPE_MD5;
10373 salt_type = SALT_TYPE_EMBEDDED;
10374 attack_exec = ATTACK_EXEC_ON_GPU;
10375 opts_type = OPTS_TYPE_PT_GENERATE_LE
10376 | OPTS_TYPE_PT_ADD80
10377 | OPTS_TYPE_HASH_COPY;
10378 kern_type = KERN_TYPE_SIP_AUTH;
10379 dgst_size = DGST_SIZE_4_4;
10380 parse_func = sip_auth_parse_hash;
10381 sort_by_digest = sort_by_digest_4_4;
10382 opti_type = OPTI_TYPE_ZERO_BYTE;
10383 dgst_pos0 = 0;
10384 dgst_pos1 = 3;
10385 dgst_pos2 = 2;
10386 dgst_pos3 = 1;
10387 break;
10388
10389 case 11500: hash_type = HASH_TYPE_CRC32;
10390 salt_type = SALT_TYPE_INTERN;
10391 attack_exec = ATTACK_EXEC_ON_GPU;
10392 opts_type = OPTS_TYPE_PT_GENERATE_LE
10393 | OPTS_TYPE_ST_GENERATE_LE
10394 | OPTS_TYPE_ST_HEX;
10395 kern_type = KERN_TYPE_CRC32;
10396 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10397 parse_func = crc32_parse_hash;
10398 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10399 opti_type = OPTI_TYPE_ZERO_BYTE
10400 | OPTI_TYPE_SCALAR_MODE;
10401 dgst_pos0 = 0;
10402 dgst_pos1 = 1;
10403 dgst_pos2 = 2;
10404 dgst_pos3 = 3;
10405 break;
10406
10407 case 11600: hash_type = HASH_TYPE_AES;
10408 salt_type = SALT_TYPE_EMBEDDED;
10409 attack_exec = ATTACK_EXEC_ON_CPU;
10410 opts_type = OPTS_TYPE_PT_GENERATE_LE
10411 | OPTS_TYPE_PT_NEVERCRACK;
10412 kern_type = KERN_TYPE_SEVEN_ZIP;
10413 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10414 parse_func = seven_zip_parse_hash;
10415 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10416 opti_type = OPTI_TYPE_ZERO_BYTE;
10417 dgst_pos0 = 0;
10418 dgst_pos1 = 1;
10419 dgst_pos2 = 2;
10420 dgst_pos3 = 3;
10421 break;
10422
10423 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10424 salt_type = SALT_TYPE_NONE;
10425 attack_exec = ATTACK_EXEC_ON_GPU;
10426 opts_type = OPTS_TYPE_PT_GENERATE_LE
10427 | OPTS_TYPE_PT_ADD01;
10428 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10429 dgst_size = DGST_SIZE_4_8;
10430 parse_func = gost2012sbog_256_parse_hash;
10431 sort_by_digest = sort_by_digest_4_8;
10432 opti_type = OPTI_TYPE_ZERO_BYTE;
10433 dgst_pos0 = 0;
10434 dgst_pos1 = 1;
10435 dgst_pos2 = 2;
10436 dgst_pos3 = 3;
10437 break;
10438
10439 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10440 salt_type = SALT_TYPE_NONE;
10441 attack_exec = ATTACK_EXEC_ON_GPU;
10442 opts_type = OPTS_TYPE_PT_GENERATE_LE
10443 | OPTS_TYPE_PT_ADD01;
10444 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10445 dgst_size = DGST_SIZE_4_16;
10446 parse_func = gost2012sbog_512_parse_hash;
10447 sort_by_digest = sort_by_digest_4_16;
10448 opti_type = OPTI_TYPE_ZERO_BYTE;
10449 dgst_pos0 = 0;
10450 dgst_pos1 = 1;
10451 dgst_pos2 = 2;
10452 dgst_pos3 = 3;
10453 break;
10454
10455 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10456 salt_type = SALT_TYPE_EMBEDDED;
10457 attack_exec = ATTACK_EXEC_ON_CPU;
10458 opts_type = OPTS_TYPE_PT_GENERATE_LE
10459 | OPTS_TYPE_ST_BASE64
10460 | OPTS_TYPE_HASH_COPY;
10461 kern_type = KERN_TYPE_PBKDF2_MD5;
10462 dgst_size = DGST_SIZE_4_32;
10463 parse_func = pbkdf2_md5_parse_hash;
10464 sort_by_digest = sort_by_digest_4_32;
10465 opti_type = OPTI_TYPE_ZERO_BYTE;
10466 dgst_pos0 = 0;
10467 dgst_pos1 = 1;
10468 dgst_pos2 = 2;
10469 dgst_pos3 = 3;
10470 break;
10471
10472 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10473 salt_type = SALT_TYPE_EMBEDDED;
10474 attack_exec = ATTACK_EXEC_ON_CPU;
10475 opts_type = OPTS_TYPE_PT_GENERATE_LE
10476 | OPTS_TYPE_ST_BASE64
10477 | OPTS_TYPE_HASH_COPY;
10478 kern_type = KERN_TYPE_PBKDF2_SHA1;
10479 dgst_size = DGST_SIZE_4_32;
10480 parse_func = pbkdf2_sha1_parse_hash;
10481 sort_by_digest = sort_by_digest_4_32;
10482 opti_type = OPTI_TYPE_ZERO_BYTE;
10483 dgst_pos0 = 0;
10484 dgst_pos1 = 1;
10485 dgst_pos2 = 2;
10486 dgst_pos3 = 3;
10487 break;
10488
10489 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10490 salt_type = SALT_TYPE_EMBEDDED;
10491 attack_exec = ATTACK_EXEC_ON_CPU;
10492 opts_type = OPTS_TYPE_PT_GENERATE_LE
10493 | OPTS_TYPE_ST_BASE64
10494 | OPTS_TYPE_HASH_COPY;
10495 kern_type = KERN_TYPE_PBKDF2_SHA512;
10496 dgst_size = DGST_SIZE_8_16;
10497 parse_func = pbkdf2_sha512_parse_hash;
10498 sort_by_digest = sort_by_digest_8_16;
10499 opti_type = OPTI_TYPE_ZERO_BYTE;
10500 dgst_pos0 = 0;
10501 dgst_pos1 = 1;
10502 dgst_pos2 = 2;
10503 dgst_pos3 = 3;
10504 break;
10505
10506 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10507 salt_type = SALT_TYPE_EMBEDDED;
10508 attack_exec = ATTACK_EXEC_ON_CPU;
10509 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10510 kern_type = KERN_TYPE_ECRYPTFS;
10511 dgst_size = DGST_SIZE_8_8;
10512 parse_func = ecryptfs_parse_hash;
10513 sort_by_digest = sort_by_digest_8_8;
10514 opti_type = OPTI_TYPE_ZERO_BYTE;
10515 dgst_pos0 = 0;
10516 dgst_pos1 = 1;
10517 dgst_pos2 = 2;
10518 dgst_pos3 = 3;
10519 break;
10520
10521 case 12300: hash_type = HASH_TYPE_ORACLET;
10522 salt_type = SALT_TYPE_EMBEDDED;
10523 attack_exec = ATTACK_EXEC_ON_CPU;
10524 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10525 kern_type = KERN_TYPE_ORACLET;
10526 dgst_size = DGST_SIZE_8_16;
10527 parse_func = oraclet_parse_hash;
10528 sort_by_digest = sort_by_digest_8_16;
10529 opti_type = OPTI_TYPE_ZERO_BYTE;
10530 dgst_pos0 = 0;
10531 dgst_pos1 = 1;
10532 dgst_pos2 = 2;
10533 dgst_pos3 = 3;
10534 break;
10535
10536 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10537 salt_type = SALT_TYPE_EMBEDDED;
10538 attack_exec = ATTACK_EXEC_ON_CPU;
10539 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10540 kern_type = KERN_TYPE_BSDICRYPT;
10541 dgst_size = DGST_SIZE_4_4;
10542 parse_func = bsdicrypt_parse_hash;
10543 sort_by_digest = sort_by_digest_4_4;
10544 opti_type = OPTI_TYPE_ZERO_BYTE
10545 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10546 dgst_pos0 = 0;
10547 dgst_pos1 = 1;
10548 dgst_pos2 = 2;
10549 dgst_pos3 = 3;
10550 break;
10551
10552 case 12500: hash_type = HASH_TYPE_RAR3HP;
10553 salt_type = SALT_TYPE_EMBEDDED;
10554 attack_exec = ATTACK_EXEC_ON_CPU;
10555 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10556 kern_type = KERN_TYPE_RAR3;
10557 dgst_size = DGST_SIZE_4_4;
10558 parse_func = rar3hp_parse_hash;
10559 sort_by_digest = sort_by_digest_4_4;
10560 opti_type = OPTI_TYPE_ZERO_BYTE;
10561 dgst_pos0 = 0;
10562 dgst_pos1 = 1;
10563 dgst_pos2 = 2;
10564 dgst_pos3 = 3;
10565 break;
10566
10567 case 12600: hash_type = HASH_TYPE_SHA256;
10568 salt_type = SALT_TYPE_INTERN;
10569 attack_exec = ATTACK_EXEC_ON_GPU;
10570 opts_type = OPTS_TYPE_PT_GENERATE_BE
10571 | OPTS_TYPE_PT_ADD80;
10572 kern_type = KERN_TYPE_CF10;
10573 dgst_size = DGST_SIZE_4_8;
10574 parse_func = cf10_parse_hash;
10575 sort_by_digest = sort_by_digest_4_8;
10576 opti_type = OPTI_TYPE_ZERO_BYTE
10577 | OPTI_TYPE_PRECOMPUTE_INIT
10578 | OPTI_TYPE_EARLY_SKIP
10579 | OPTI_TYPE_NOT_ITERATED;
10580 dgst_pos0 = 3;
10581 dgst_pos1 = 7;
10582 dgst_pos2 = 2;
10583 dgst_pos3 = 6;
10584 break;
10585
10586 case 12700: hash_type = HASH_TYPE_AES;
10587 salt_type = SALT_TYPE_EMBEDDED;
10588 attack_exec = ATTACK_EXEC_ON_CPU;
10589 opts_type = OPTS_TYPE_PT_GENERATE_LE
10590 | OPTS_TYPE_HASH_COPY;
10591 kern_type = KERN_TYPE_MYWALLET;
10592 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10593 parse_func = mywallet_parse_hash;
10594 sort_by_digest = sort_by_digest_4_5;
10595 opti_type = OPTI_TYPE_ZERO_BYTE;
10596 dgst_pos0 = 0;
10597 dgst_pos1 = 1;
10598 dgst_pos2 = 2;
10599 dgst_pos3 = 3;
10600 break;
10601
10602 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10603 salt_type = SALT_TYPE_EMBEDDED;
10604 attack_exec = ATTACK_EXEC_ON_CPU;
10605 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10606 kern_type = KERN_TYPE_MS_DRSR;
10607 dgst_size = DGST_SIZE_4_8;
10608 parse_func = ms_drsr_parse_hash;
10609 sort_by_digest = sort_by_digest_4_8;
10610 opti_type = OPTI_TYPE_ZERO_BYTE;
10611 dgst_pos0 = 0;
10612 dgst_pos1 = 1;
10613 dgst_pos2 = 2;
10614 dgst_pos3 = 3;
10615 break;
10616
10617 default: usage_mini_print (PROGNAME); return (-1);
10618 }
10619
10620 /**
10621 * transpose
10622 */
10623
10624 data.parse_func = parse_func;
10625
10626 /**
10627 * misc stuff
10628 */
10629
10630 if (hex_salt)
10631 {
10632 if (salt_type == SALT_TYPE_INTERN)
10633 {
10634 opts_type |= OPTS_TYPE_ST_HEX;
10635 }
10636 else
10637 {
10638 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10639
10640 return (-1);
10641 }
10642 }
10643
10644 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10645 | (salt_type == SALT_TYPE_EXTERN)
10646 | (salt_type == SALT_TYPE_EMBEDDED)
10647 | (salt_type == SALT_TYPE_VIRTUAL));
10648
10649 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10650
10651 data.hash_type = hash_type;
10652 data.attack_mode = attack_mode;
10653 data.attack_kern = attack_kern;
10654 data.attack_exec = attack_exec;
10655 data.kern_type = kern_type;
10656 data.opts_type = opts_type;
10657 data.dgst_size = dgst_size;
10658 data.salt_type = salt_type;
10659 data.isSalted = isSalted;
10660 data.sort_by_digest = sort_by_digest;
10661 data.dgst_pos0 = dgst_pos0;
10662 data.dgst_pos1 = dgst_pos1;
10663 data.dgst_pos2 = dgst_pos2;
10664 data.dgst_pos3 = dgst_pos3;
10665
10666 esalt_size = 0;
10667
10668 switch (hash_mode)
10669 {
10670 case 2500: esalt_size = sizeof (wpa_t); break;
10671 case 5300: esalt_size = sizeof (ikepsk_t); break;
10672 case 5400: esalt_size = sizeof (ikepsk_t); break;
10673 case 5500: esalt_size = sizeof (netntlm_t); break;
10674 case 5600: esalt_size = sizeof (netntlm_t); break;
10675 case 6211:
10676 case 6212:
10677 case 6213:
10678 case 6221:
10679 case 6222:
10680 case 6223:
10681 case 6231:
10682 case 6232:
10683 case 6233:
10684 case 6241:
10685 case 6242:
10686 case 6243: esalt_size = sizeof (tc_t); break;
10687 case 6600: esalt_size = sizeof (agilekey_t); break;
10688 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10689 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10690 case 7300: esalt_size = sizeof (rakp_t); break;
10691 case 7500: esalt_size = sizeof (krb5pa_t); break;
10692 case 8200: esalt_size = sizeof (cloudkey_t); break;
10693 case 8800: esalt_size = sizeof (androidfde_t); break;
10694 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10695 case 9400: esalt_size = sizeof (office2007_t); break;
10696 case 9500: esalt_size = sizeof (office2010_t); break;
10697 case 9600: esalt_size = sizeof (office2013_t); break;
10698 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10699 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10700 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10701 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10702 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10703 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10704 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10705 case 10200: esalt_size = sizeof (cram_md5_t); break;
10706 case 10400: esalt_size = sizeof (pdf_t); break;
10707 case 10410: esalt_size = sizeof (pdf_t); break;
10708 case 10420: esalt_size = sizeof (pdf_t); break;
10709 case 10500: esalt_size = sizeof (pdf_t); break;
10710 case 10600: esalt_size = sizeof (pdf_t); break;
10711 case 10700: esalt_size = sizeof (pdf_t); break;
10712 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10713 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10714 case 11400: esalt_size = sizeof (sip_t); break;
10715 case 11600: esalt_size = sizeof (seven_zip_t); break;
10716 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10717 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10718 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10719 }
10720
10721 data.esalt_size = esalt_size;
10722
10723 /**
10724 * choose dictionary parser
10725 */
10726
10727 if (hash_type == HASH_TYPE_LM)
10728 {
10729 get_next_word_func = get_next_word_lm;
10730 }
10731 else if (opts_type & OPTS_TYPE_PT_UPPER)
10732 {
10733 get_next_word_func = get_next_word_uc;
10734 }
10735 else
10736 {
10737 get_next_word_func = get_next_word_std;
10738 }
10739
10740 /**
10741 * dictstat
10742 */
10743
10744 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10745
10746 #ifdef _POSIX
10747 size_t dictstat_nmemb = 0;
10748 #endif
10749
10750 #ifdef _WIN
10751 uint dictstat_nmemb = 0;
10752 #endif
10753
10754 char dictstat[256];
10755
10756 FILE *dictstat_fp = NULL;
10757
10758 if (keyspace == 0)
10759 {
10760 memset (dictstat, 0, sizeof (dictstat));
10761
10762 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s.dictstat", install_dir, PROGNAME);
10763
10764 dictstat_fp = fopen (dictstat, "rb");
10765
10766 if (dictstat_fp)
10767 {
10768 #ifdef _POSIX
10769 struct stat tmpstat;
10770
10771 fstat (fileno (dictstat_fp), &tmpstat);
10772 #endif
10773
10774 #ifdef _WIN
10775 struct stat64 tmpstat;
10776
10777 _fstat64 (fileno (dictstat_fp), &tmpstat);
10778 #endif
10779
10780 if (tmpstat.st_mtime < COMPTIME)
10781 {
10782 /* with v0.15 the format changed so we have to ensure user is using a good version
10783 since there is no version-header in the dictstat file */
10784
10785 fclose (dictstat_fp);
10786
10787 unlink (dictstat);
10788 }
10789 else
10790 {
10791 while (!feof (dictstat_fp))
10792 {
10793 dictstat_t d;
10794
10795 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10796
10797 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10798
10799 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10800 {
10801 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10802
10803 return -1;
10804 }
10805 }
10806
10807 fclose (dictstat_fp);
10808 }
10809 }
10810 }
10811
10812 /**
10813 * potfile
10814 */
10815
10816 char potfile[256];
10817
10818 memset (potfile, 0, sizeof (potfile));
10819
10820 snprintf (potfile, sizeof (potfile) - 1, "%s.pot", session);
10821
10822 data.pot_fp = NULL;
10823
10824 FILE *out_fp = NULL;
10825 FILE *pot_fp = NULL;
10826
10827 if (show == 1 || left == 1)
10828 {
10829 pot_fp = fopen (potfile, "rb");
10830
10831 if (pot_fp == NULL)
10832 {
10833 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10834
10835 return (-1);
10836 }
10837
10838 if (outfile != NULL)
10839 {
10840 if ((out_fp = fopen (outfile, "ab")) == NULL)
10841 {
10842 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10843
10844 fclose (pot_fp);
10845
10846 return (-1);
10847 }
10848 }
10849 else
10850 {
10851 out_fp = stdout;
10852 }
10853 }
10854 else
10855 {
10856 if (potfile_disable == 0)
10857 {
10858 pot_fp = fopen (potfile, "ab");
10859
10860 if (pot_fp == NULL)
10861 {
10862 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10863
10864 return (-1);
10865 }
10866
10867 data.pot_fp = pot_fp;
10868 }
10869 }
10870
10871 pot_t *pot = NULL;
10872
10873 uint pot_cnt = 0;
10874 uint pot_avail = 0;
10875
10876 if (show == 1 || left == 1)
10877 {
10878 SUPPRESS_OUTPUT = 1;
10879
10880 pot_avail = count_lines (pot_fp);
10881
10882 rewind (pot_fp);
10883
10884 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10885
10886 uint pot_hashes_avail = 0;
10887
10888 uint line_num = 0;
10889
10890 while (!feof (pot_fp))
10891 {
10892 line_num++;
10893
10894 char line_buf[BUFSIZ];
10895
10896 int line_len = fgetl (pot_fp, line_buf);
10897
10898 if (line_len == 0) continue;
10899
10900 char *plain_buf = line_buf + line_len;
10901
10902 pot_t *pot_ptr = &pot[pot_cnt];
10903
10904 hash_t *hashes_buf = &pot_ptr->hash;
10905
10906 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10907 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10908
10909 if (pot_cnt == pot_hashes_avail)
10910 {
10911 uint pos = 0;
10912
10913 for (pos = 0; pos < INCR_POT; pos++)
10914 {
10915 if ((pot_cnt + pos) >= pot_avail) break;
10916
10917 pot_t *tmp_pot = &pot[pot_cnt + pos];
10918
10919 hash_t *tmp_hash = &tmp_pot->hash;
10920
10921 tmp_hash->digest = mymalloc (dgst_size);
10922
10923 if (isSalted)
10924 {
10925 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10926 }
10927
10928 if (esalt_size)
10929 {
10930 tmp_hash->esalt = mymalloc (esalt_size);
10931 }
10932
10933 pot_hashes_avail++;
10934 }
10935 }
10936
10937 int plain_len = 0;
10938
10939 int parser_status;
10940
10941 int iter = MAX_CUT_TRIES;
10942
10943 do
10944 {
10945 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10946 {
10947 if (line_buf[i] == ':')
10948 {
10949 line_len--;
10950
10951 break;
10952 }
10953 }
10954
10955 if (data.hash_mode != 2500)
10956 {
10957 parser_status = parse_func (line_buf, line_len, hashes_buf);
10958 }
10959 else
10960 {
10961 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10962
10963 if (line_len > max_salt_size)
10964 {
10965 parser_status = PARSER_GLOBAL_LENGTH;
10966 }
10967 else
10968 {
10969 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10970
10971 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10972
10973 hashes_buf->salt->salt_len = line_len;
10974
10975 parser_status = PARSER_OK;
10976 }
10977 }
10978
10979 // if NOT parsed without error, we add the ":" to the plain
10980
10981 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10982 {
10983 plain_len++;
10984 plain_buf--;
10985 }
10986
10987 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10988
10989 if (parser_status < PARSER_GLOBAL_ZERO)
10990 {
10991 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10992
10993 continue;
10994 }
10995
10996 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10997
10998 pot_ptr->plain_len = plain_len;
10999
11000 pot_cnt++;
11001 }
11002
11003 fclose (pot_fp);
11004
11005 SUPPRESS_OUTPUT = 0;
11006
11007 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11008 }
11009
11010 /**
11011 * gpu accel and loops auto adjustment
11012 */
11013
11014 if (gpu_accel_chgd == 0) gpu_accel = set_gpu_accel (hash_mode);
11015 if (gpu_loops_chgd == 0) gpu_loops = set_gpu_loops (hash_mode);
11016
11017 if (workload_profile == 1)
11018 {
11019 gpu_loops /= 8;
11020 gpu_accel /= 4;
11021
11022 if (gpu_loops == 0) gpu_loops = 8;
11023 if (gpu_accel == 0) gpu_accel = 2;
11024 }
11025 else if (workload_profile == 3)
11026 {
11027 gpu_loops *= 8;
11028 gpu_accel *= 4;
11029
11030 if (gpu_loops > 1024) gpu_loops = 1024;
11031 if (gpu_accel > 256) gpu_accel = 256; // causes memory problems otherwise
11032 }
11033
11034 // those hashes *must* run at a specific gpu_loops count because of some optimization inside the kernel
11035
11036 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
11037 {
11038 gpu_loops = 1024;
11039 }
11040
11041 if (hash_mode == 12500)
11042 {
11043 gpu_loops = ROUNDS_RAR3 / 16;
11044 }
11045
11046 data.gpu_accel = gpu_accel;
11047 data.gpu_loops = gpu_loops;
11048
11049 /**
11050 * word len
11051 */
11052
11053 uint pw_min = PW_MIN;
11054 uint pw_max = PW_MAX;
11055
11056 switch (hash_mode)
11057 {
11058 case 400: if (pw_max > 40) pw_max = 40;
11059 break;
11060 case 500: if (pw_max > 16) pw_max = 16;
11061 break;
11062 case 1500: if (pw_max > 8) pw_max = 8;
11063 break;
11064 case 1600: if (pw_max > 16) pw_max = 16;
11065 break;
11066 case 1800: if (pw_max > 16) pw_max = 16;
11067 break;
11068 case 2100: if (pw_max > 16) pw_max = 16;
11069 break;
11070 case 2500: if (pw_min < 8) pw_min = 8;
11071 break;
11072 case 3000: if (pw_max > 7) pw_max = 7;
11073 break;
11074 case 5200: if (pw_max > 24) pw_max = 24;
11075 break;
11076 case 5800: if (pw_max > 16) pw_max = 16;
11077 break;
11078 case 6300: if (pw_max > 16) pw_max = 16;
11079 break;
11080 case 7400: if (pw_max > 16) pw_max = 16;
11081 break;
11082 case 7900: if (pw_max > 48) pw_max = 48;
11083 break;
11084 case 8500: if (pw_max > 8) pw_max = 8;
11085 break;
11086 case 8600: if (pw_max > 16) pw_max = 16;
11087 break;
11088 case 9710: pw_min = 5;
11089 pw_max = 5;
11090 break;
11091 case 9810: pw_min = 5;
11092 pw_max = 5;
11093 break;
11094 case 10410: pw_min = 5;
11095 pw_max = 5;
11096 break;
11097 case 10300: if (pw_max < 3) pw_min = 3;
11098 if (pw_max > 40) pw_max = 40;
11099 break;
11100 case 10500: if (pw_max < 3) pw_min = 3;
11101 if (pw_max > 40) pw_max = 40;
11102 break;
11103 case 10700: if (pw_max > 16) pw_max = 16;
11104 break;
11105 case 11300: if (pw_max > 40) pw_max = 40;
11106 break;
11107 case 12500: if (pw_max > 20) pw_max = 20;
11108 break;
11109 case 12800: if (pw_max > 24) pw_max = 24;
11110 break;
11111 }
11112
11113 if (attack_exec == ATTACK_EXEC_ON_GPU)
11114 {
11115 switch (attack_kern)
11116 {
11117 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11118 break;
11119 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11120 break;
11121 }
11122 }
11123
11124 /**
11125 * charsets : keep them together for more easy maintainnce
11126 */
11127
11128 cs_t mp_sys[6];
11129 cs_t mp_usr[4];
11130
11131 memset (mp_sys, 0, sizeof (mp_sys));
11132 memset (mp_usr, 0, sizeof (mp_usr));
11133
11134 mp_setup_sys (mp_sys);
11135
11136 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11137 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11138 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11139 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11140
11141 /**
11142 * load hashes, part I: find input mode, count hashes
11143 */
11144
11145 uint hashlist_mode = 0;
11146 uint hashlist_format = HLFMT_HASHCAT;
11147
11148 uint hashes_avail = 0;
11149
11150 if (benchmark == 0)
11151 {
11152 struct stat f;
11153
11154 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11155
11156 if ((hash_mode == 2500) ||
11157 (hash_mode == 5200) ||
11158 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11159 (hash_mode == 9000))
11160 {
11161 hashlist_mode = HL_MODE_ARG;
11162
11163 char *hashfile = myargv[optind];
11164
11165 data.hashfile = hashfile;
11166
11167 logfile_top_var_string ("target", hashfile);
11168 }
11169
11170 if (hashlist_mode == HL_MODE_ARG)
11171 {
11172 if (hash_mode == 2500)
11173 {
11174 struct stat st;
11175
11176 if (stat (data.hashfile, &st) == -1)
11177 {
11178 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11179
11180 return (-1);
11181 }
11182
11183 hashes_avail = st.st_size / sizeof (hccap_t);
11184 }
11185 else
11186 {
11187 hashes_avail = 1;
11188 }
11189 }
11190 else if (hashlist_mode == HL_MODE_FILE)
11191 {
11192 char *hashfile = myargv[optind];
11193
11194 data.hashfile = hashfile;
11195
11196 logfile_top_var_string ("target", hashfile);
11197
11198 FILE *fp = NULL;
11199
11200 if ((fp = fopen (hashfile, "rb")) == NULL)
11201 {
11202 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11203
11204 return (-1);
11205 }
11206
11207 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11208
11209 hashes_avail = count_lines (fp);
11210
11211 rewind (fp);
11212
11213 if (hashes_avail == 0)
11214 {
11215 log_error ("ERROR: hashfile is empty or corrupt");
11216
11217 fclose (fp);
11218
11219 return (-1);
11220 }
11221
11222 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11223
11224 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11225 {
11226 log_error ("ERROR: remove not supported in native hashfile-format mode");
11227
11228 fclose (fp);
11229
11230 return (-1);
11231 }
11232
11233 fclose (fp);
11234 }
11235 }
11236 else
11237 {
11238 hashlist_mode = HL_MODE_ARG;
11239
11240 hashes_avail = 1;
11241 }
11242
11243 if (hash_mode == 3000) hashes_avail *= 2;
11244
11245 data.hashlist_mode = hashlist_mode;
11246 data.hashlist_format = hashlist_format;
11247
11248 logfile_top_uint (hashlist_mode);
11249 logfile_top_uint (hashlist_format);
11250
11251 /**
11252 * load hashes, part II: allocate required memory, set pointers
11253 */
11254
11255 hash_t *hashes_buf = NULL;
11256 void *digests_buf = NULL;
11257 salt_t *salts_buf = NULL;
11258 void *esalts_buf = NULL;
11259
11260 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11261
11262 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11263
11264 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11265 {
11266 uint32_t hash_pos;
11267
11268 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11269 {
11270 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11271
11272 hashes_buf[hash_pos].hash_info = hash_info;
11273
11274 if (username && (remove || show || left))
11275 {
11276 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11277 }
11278
11279 if (benchmark)
11280 {
11281 hash_info->orighash = (char *) mymalloc (256);
11282 }
11283 }
11284 }
11285
11286 if (isSalted)
11287 {
11288 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11289
11290 if (esalt_size)
11291 {
11292 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11293 }
11294 }
11295 else
11296 {
11297 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11298 }
11299
11300 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11301 {
11302 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11303
11304 if (isSalted)
11305 {
11306 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11307
11308 if (esalt_size)
11309 {
11310 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11311 }
11312 }
11313 else
11314 {
11315 hashes_buf[hash_pos].salt = &salts_buf[0];
11316 }
11317 }
11318
11319 /**
11320 * load hashes, part III: parse hashes or generate them if benchmark
11321 */
11322
11323 uint hashes_cnt = 0;
11324
11325 if (benchmark == 0)
11326 {
11327 if (keyspace == 1)
11328 {
11329 // useless to read hash file for keyspace, cheat a little bit w/ optind
11330 }
11331 else if (hashes_avail == 0)
11332 {
11333 }
11334 else if (hashlist_mode == HL_MODE_ARG)
11335 {
11336 char *input_buf = myargv[optind];
11337
11338 uint input_len = strlen (input_buf);
11339
11340 logfile_top_var_string ("target", input_buf);
11341
11342 char *hash_buf = NULL;
11343 int hash_len = 0;
11344
11345 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11346
11347 if (hash_len)
11348 {
11349 if (opts_type & OPTS_TYPE_HASH_COPY)
11350 {
11351 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11352
11353 hash_info_tmp->orighash = mystrdup (hash_buf);
11354 }
11355
11356 if (isSalted)
11357 {
11358 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11359 }
11360
11361 int parser_status = PARSER_OK;
11362
11363 if (hash_mode == 2500)
11364 {
11365 if (hash_len == 0)
11366 {
11367 log_error ("ERROR: hccap file not specified");
11368
11369 return (-1);
11370 }
11371
11372 hashlist_mode = HL_MODE_FILE;
11373
11374 data.hashlist_mode = hashlist_mode;
11375
11376 FILE *fp = fopen (hash_buf, "rb");
11377
11378 if (fp == NULL)
11379 {
11380 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11381
11382 return (-1);
11383 }
11384
11385 if (hashes_avail < 1)
11386 {
11387 log_error ("ERROR: hccap file is empty or corrupt");
11388
11389 fclose (fp);
11390
11391 return (-1);
11392 }
11393
11394 uint hccap_size = sizeof (hccap_t);
11395
11396 char in[hccap_size];
11397
11398 while (!feof (fp))
11399 {
11400 int n = fread (&in, hccap_size, 1, fp);
11401
11402 if (n != 1)
11403 {
11404 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11405
11406 break;
11407 }
11408
11409 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11410
11411 if (parser_status != PARSER_OK)
11412 {
11413 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11414
11415 continue;
11416 }
11417
11418 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11419
11420 if ((show == 1) || (left == 1))
11421 {
11422 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11423
11424 char *salt_ptr = (char *) tmp_salt->salt_buf;
11425
11426 int cur_pos = tmp_salt->salt_len;
11427 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11428
11429 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11430
11431 unsigned char *pke_ptr = (unsigned char *) wpa->pke;
11432
11433 // do the appending task
11434
11435 snprintf (salt_ptr + cur_pos,
11436 rem_len,
11437 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11438 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
11439 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
11440
11441
11442 // memset () the remaining part of the salt
11443
11444 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11445 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11446
11447 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11448
11449 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11450 }
11451
11452 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);
11453 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);
11454
11455 hashes_cnt++;
11456 }
11457
11458 fclose (fp);
11459 }
11460 else if (hash_mode == 3000)
11461 {
11462 if (hash_len == 32)
11463 {
11464 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11465
11466 hash_t *lm_hash_left = NULL;
11467
11468 if (parser_status == PARSER_OK)
11469 {
11470 lm_hash_left = &hashes_buf[hashes_cnt];
11471
11472 hashes_cnt++;
11473 }
11474 else
11475 {
11476 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11477 }
11478
11479
11480 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11481
11482 hash_t *lm_hash_right = NULL;
11483
11484 if (parser_status == PARSER_OK)
11485 {
11486 lm_hash_right = &hashes_buf[hashes_cnt];
11487
11488 hashes_cnt++;
11489 }
11490 else
11491 {
11492 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11493 }
11494
11495 // show / left
11496
11497 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11498 {
11499 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);
11500 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);
11501 }
11502 }
11503 else
11504 {
11505 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11506
11507 if (parser_status == PARSER_OK)
11508 {
11509 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11510 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11511 }
11512
11513 if (parser_status == PARSER_OK)
11514 {
11515 hashes_cnt++;
11516 }
11517 else
11518 {
11519 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11520 }
11521 }
11522 }
11523 else
11524 {
11525 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11526
11527 if (parser_status == PARSER_OK)
11528 {
11529 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11530 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11531 }
11532
11533 if (parser_status == PARSER_OK)
11534 {
11535 hashes_cnt++;
11536 }
11537 else
11538 {
11539 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11540 }
11541 }
11542 }
11543 }
11544 else if (hashlist_mode == HL_MODE_FILE)
11545 {
11546 char *hashfile = data.hashfile;
11547
11548 FILE *fp;
11549
11550 if ((fp = fopen (hashfile, "rb")) == NULL)
11551 {
11552 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11553
11554 return (-1);
11555 }
11556
11557 uint line_num = 0;
11558
11559 while (!feof (fp))
11560 {
11561 line_num++;
11562
11563 char line_buf[BUFSIZ];
11564
11565 int line_len = fgetl (fp, line_buf);
11566
11567 if (line_len == 0) continue;
11568
11569 char *hash_buf = NULL;
11570 int hash_len = 0;
11571
11572 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11573
11574 if (username)
11575 {
11576 char *user_buf = NULL;
11577 int user_len = 0;
11578
11579 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11580
11581 if (remove || show)
11582 {
11583 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11584
11585 *user = (user_t *) malloc (sizeof (user_t));
11586
11587 user_t *user_ptr = *user;
11588
11589 if (user_buf != NULL)
11590 {
11591 user_ptr->user_name = mystrdup (user_buf);
11592 }
11593 else
11594 {
11595 user_ptr->user_name = mystrdup ("");
11596 }
11597
11598 user_ptr->user_len = user_len;
11599 }
11600 }
11601
11602 if (opts_type & OPTS_TYPE_HASH_COPY)
11603 {
11604 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11605
11606 hash_info_tmp->orighash = mystrdup (hash_buf);
11607 }
11608
11609 if (isSalted)
11610 {
11611 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11612 }
11613
11614 if (hash_mode == 3000)
11615 {
11616 if (hash_len == 32)
11617 {
11618 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11619
11620 if (parser_status < PARSER_GLOBAL_ZERO)
11621 {
11622 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11623
11624 continue;
11625 }
11626
11627 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11628
11629 hashes_cnt++;
11630
11631 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11632
11633 if (parser_status < PARSER_GLOBAL_ZERO)
11634 {
11635 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11636
11637 continue;
11638 }
11639
11640 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11641
11642 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);
11643
11644 hashes_cnt++;
11645
11646 // show / left
11647
11648 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);
11649 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);
11650 }
11651 else
11652 {
11653 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11654
11655 if (parser_status < PARSER_GLOBAL_ZERO)
11656 {
11657 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11658
11659 continue;
11660 }
11661
11662 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);
11663
11664 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11665 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11666
11667 hashes_cnt++;
11668 }
11669 }
11670 else
11671 {
11672 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11673
11674 if (parser_status < PARSER_GLOBAL_ZERO)
11675 {
11676 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11677
11678 continue;
11679 }
11680
11681 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);
11682
11683 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11684 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11685
11686 hashes_cnt++;
11687 }
11688 }
11689
11690 fclose (fp);
11691
11692 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11693
11694 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11695 }
11696 }
11697 else
11698 {
11699 if (isSalted)
11700 {
11701 hashes_buf[0].salt->salt_len = 8;
11702
11703 // special salt handling
11704
11705 switch (hash_mode)
11706 {
11707 case 1500: hashes_buf[0].salt->salt_len = 2;
11708 break;
11709 case 1731: hashes_buf[0].salt->salt_len = 4;
11710 break;
11711 case 2410: hashes_buf[0].salt->salt_len = 4;
11712 break;
11713 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11714 break;
11715 case 3100: hashes_buf[0].salt->salt_len = 1;
11716 break;
11717 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11718 break;
11719 case 5800: hashes_buf[0].salt->salt_len = 16;
11720 break;
11721 case 6800: hashes_buf[0].salt->salt_len = 32;
11722 break;
11723 case 8400: hashes_buf[0].salt->salt_len = 40;
11724 break;
11725 case 8800: hashes_buf[0].salt->salt_len = 16;
11726 break;
11727 case 8900: hashes_buf[0].salt->salt_len = 16;
11728 hashes_buf[0].salt->scrypt_N = 1024;
11729 hashes_buf[0].salt->scrypt_r = 1;
11730 hashes_buf[0].salt->scrypt_p = 1;
11731 break;
11732 case 9100: hashes_buf[0].salt->salt_len = 16;
11733 break;
11734 case 9300: hashes_buf[0].salt->salt_len = 14;
11735 hashes_buf[0].salt->scrypt_N = 16384;
11736 hashes_buf[0].salt->scrypt_r = 1;
11737 hashes_buf[0].salt->scrypt_p = 1;
11738 break;
11739 case 9400: hashes_buf[0].salt->salt_len = 16;
11740 break;
11741 case 9500: hashes_buf[0].salt->salt_len = 16;
11742 break;
11743 case 9600: hashes_buf[0].salt->salt_len = 16;
11744 break;
11745 case 9700: hashes_buf[0].salt->salt_len = 16;
11746 break;
11747 case 9710: hashes_buf[0].salt->salt_len = 16;
11748 break;
11749 case 9720: hashes_buf[0].salt->salt_len = 16;
11750 break;
11751 case 9800: hashes_buf[0].salt->salt_len = 16;
11752 break;
11753 case 9810: hashes_buf[0].salt->salt_len = 16;
11754 break;
11755 case 9820: hashes_buf[0].salt->salt_len = 16;
11756 break;
11757 case 10300: hashes_buf[0].salt->salt_len = 12;
11758 break;
11759 case 11500: hashes_buf[0].salt->salt_len = 4;
11760 break;
11761 case 11600: hashes_buf[0].salt->salt_len = 4;
11762 break;
11763 case 12400: hashes_buf[0].salt->salt_len = 4;
11764 break;
11765 case 12500: hashes_buf[0].salt->salt_len = 8;
11766 break;
11767 case 12600: hashes_buf[0].salt->salt_len = 64;
11768 break;
11769 }
11770
11771 // special esalt handling
11772
11773 switch (hash_mode)
11774 {
11775 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11776 break;
11777 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11778 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11779 break;
11780 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11781 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11782 break;
11783 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11784 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11785 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11786 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11787 break;
11788 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11789 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11790 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11791 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11792 break;
11793 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11794 break;
11795 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11796 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11797 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11798 break;
11799 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11800 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11801 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11802 break;
11803 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11804 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11805 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11806 break;
11807 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11808 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11809 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11810 break;
11811 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11812 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11813 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11814 break;
11815 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11816 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11817 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11818 break;
11819 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11820 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11821 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11822 break;
11823 }
11824 }
11825
11826 // set hashfile
11827
11828 switch (hash_mode)
11829 {
11830 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11831 break;
11832 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11833 break;
11834 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11835 break;
11836 case 6211:
11837 case 6212:
11838 case 6213:
11839 case 6221:
11840 case 6222:
11841 case 6223:
11842 case 6231:
11843 case 6232:
11844 case 6233:
11845 case 6241:
11846 case 6242:
11847 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11848 break;
11849 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11850 break;
11851 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11852 break;
11853 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11854 break;
11855 }
11856
11857 // set default iterations
11858
11859 switch (hash_mode)
11860 {
11861 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11862 break;
11863 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11864 break;
11865 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11866 break;
11867 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11868 break;
11869 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11870 break;
11871 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11872 break;
11873 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11874 break;
11875 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11876 break;
11877 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11878 break;
11879 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11880 break;
11881 case 6211:
11882 case 6212:
11883 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11884 break;
11885 case 6221:
11886 case 6222:
11887 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11888 break;
11889 case 6231:
11890 case 6232:
11891 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11892 break;
11893 case 6241:
11894 case 6242:
11895 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11896 break;
11897 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11898 break;
11899 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11900 break;
11901 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11902 break;
11903 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11904 break;
11905 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11906 break;
11907 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11908 break;
11909 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11910 break;
11911 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11912 break;
11913 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11914 break;
11915 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11916 break;
11917 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11918 break;
11919 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11920 break;
11921 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11922 break;
11923 case 8900: hashes_buf[0].salt->salt_iter = 1;
11924 break;
11925 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11926 break;
11927 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11928 break;
11929 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11930 break;
11931 case 9300: hashes_buf[0].salt->salt_iter = 1;
11932 break;
11933 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11934 break;
11935 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11936 break;
11937 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11938 break;
11939 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11940 break;
11941 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11942 break;
11943 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11944 break;
11945 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11946 break;
11947 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11948 break;
11949 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11950 break;
11951 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11952 break;
11953 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11954 break;
11955 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11956 break;
11957 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11958 break;
11959 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11960 break;
11961 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11962 break;
11963 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11964 break;
11965 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11966 break;
11967 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11968 break;
11969 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11970 break;
11971 }
11972
11973 // set special tuning for benchmark-mode 1
11974
11975 if (benchmark_mode == 1)
11976 {
11977 gpu_loops *= 8;
11978 gpu_accel *= 4;
11979
11980 switch (hash_mode)
11981 {
11982 case 400: gpu_loops = ROUNDS_PHPASS;
11983 gpu_accel = 32;
11984 break;
11985 case 500: gpu_loops = ROUNDS_MD5CRYPT;
11986 gpu_accel = 32;
11987 break;
11988 case 501: gpu_loops = ROUNDS_MD5CRYPT;
11989 gpu_accel = 32;
11990 break;
11991 case 1600: gpu_loops = ROUNDS_MD5CRYPT;
11992 gpu_accel = 32;
11993 break;
11994 case 1800: gpu_loops = ROUNDS_SHA512CRYPT;
11995 gpu_accel = 8;
11996 break;
11997 case 2100: gpu_loops = ROUNDS_DCC2;
11998 gpu_accel = 16;
11999 break;
12000 case 2500: gpu_loops = ROUNDS_WPA2;
12001 gpu_accel = 32;
12002 break;
12003 case 3200: gpu_loops = ROUNDS_BCRYPT;
12004 gpu_accel = 2;
12005 break;
12006 case 5200: gpu_loops = ROUNDS_PSAFE3;
12007 gpu_accel = 16;
12008 break;
12009 case 5800: gpu_loops = ROUNDS_ANDROIDPIN;
12010 gpu_accel = 16;
12011 break;
12012 case 6211: gpu_loops = ROUNDS_TRUECRYPT_2K;
12013 gpu_accel = 64;
12014 break;
12015 case 6212: gpu_loops = ROUNDS_TRUECRYPT_2K;
12016 gpu_accel = 32;
12017 break;
12018 case 6213: gpu_loops = ROUNDS_TRUECRYPT_2K;
12019 gpu_accel = 32;
12020 break;
12021 case 6221: gpu_loops = ROUNDS_TRUECRYPT_1K;
12022 gpu_accel = 8;
12023 break;
12024 case 6222: gpu_loops = ROUNDS_TRUECRYPT_1K;
12025 gpu_accel = 8;
12026 break;
12027 case 6223: gpu_loops = ROUNDS_TRUECRYPT_1K;
12028 gpu_accel = 8;
12029 break;
12030 case 6231: gpu_loops = ROUNDS_TRUECRYPT_1K;
12031 gpu_accel = 8;
12032 break;
12033 case 6232: gpu_loops = ROUNDS_TRUECRYPT_1K;
12034 gpu_accel = 8;
12035 break;
12036 case 6233: gpu_loops = ROUNDS_TRUECRYPT_1K;
12037 gpu_accel = 8;
12038 break;
12039 case 6241: gpu_loops = ROUNDS_TRUECRYPT_1K;
12040 gpu_accel = 128;
12041 break;
12042 case 6242: gpu_loops = ROUNDS_TRUECRYPT_1K;
12043 gpu_accel = 64;
12044 break;
12045 case 6243: gpu_loops = ROUNDS_TRUECRYPT_1K;
12046 gpu_accel = 64;
12047 break;
12048 case 6300: gpu_loops = ROUNDS_MD5CRYPT;
12049 gpu_accel = 32;
12050 break;
12051 case 6700: gpu_loops = ROUNDS_SHA1AIX;
12052 gpu_accel = 128;
12053 break;
12054 case 6400: gpu_loops = ROUNDS_SHA256AIX;
12055 gpu_accel = 128;
12056 break;
12057 case 6500: gpu_loops = ROUNDS_SHA512AIX;
12058 gpu_accel = 32;
12059 break;
12060 case 6600: gpu_loops = ROUNDS_AGILEKEY;
12061 gpu_accel = 64;
12062 break;
12063 case 6800: gpu_loops = ROUNDS_LASTPASS;
12064 gpu_accel = 64;
12065 break;
12066 case 7100: gpu_loops = ROUNDS_SHA512OSX;
12067 gpu_accel = 2;
12068 break;
12069 case 7200: gpu_loops = ROUNDS_GRUB;
12070 gpu_accel = 2;
12071 break;
12072 case 7400: gpu_loops = ROUNDS_SHA256CRYPT;
12073 gpu_accel = 4;
12074 break;
12075 case 7900: gpu_loops = ROUNDS_DRUPAL7;
12076 gpu_accel = 8;
12077 break;
12078 case 8200: gpu_loops = ROUNDS_CLOUDKEY;
12079 gpu_accel = 2;
12080 break;
12081 case 8800: gpu_loops = ROUNDS_ANDROIDFDE;
12082 gpu_accel = 32;
12083 break;
12084 case 8900: gpu_loops = 1;
12085 gpu_accel = 64;
12086 break;
12087 case 9000: gpu_loops = ROUNDS_PSAFE2;
12088 gpu_accel = 16;
12089 break;
12090 case 9100: gpu_loops = ROUNDS_LOTUS8;
12091 gpu_accel = 64;
12092 break;
12093 case 9200: gpu_loops = ROUNDS_CISCO8;
12094 gpu_accel = 8;
12095 break;
12096 case 9300: gpu_loops = 1;
12097 gpu_accel = 4;
12098 break;
12099 case 9400: gpu_loops = ROUNDS_OFFICE2007;
12100 gpu_accel = 32;
12101 break;
12102 case 9500: gpu_loops = ROUNDS_OFFICE2010;
12103 gpu_accel = 32;
12104 break;
12105 case 9600: gpu_loops = ROUNDS_OFFICE2013;
12106 gpu_accel = 4;
12107 break;
12108 case 10000: gpu_loops = ROUNDS_DJANGOPBKDF2;
12109 gpu_accel = 8;
12110 break;
12111 case 10300: gpu_loops = ROUNDS_SAPH_SHA1;
12112 gpu_accel = 16;
12113 break;
12114 case 10500: gpu_loops = ROUNDS_PDF14;
12115 gpu_accel = 256;
12116 break;
12117 case 10700: gpu_loops = ROUNDS_PDF17L8;
12118 gpu_accel = 8;
12119 break;
12120 case 10900: gpu_loops = ROUNDS_PBKDF2_SHA256;
12121 gpu_accel = 8;
12122 break;
12123 case 11300: gpu_loops = ROUNDS_BITCOIN_WALLET;
12124 gpu_accel = 2;
12125 break;
12126 case 11600: gpu_loops = ROUNDS_SEVEN_ZIP;
12127 gpu_accel = 4;
12128 break;
12129 case 11900: gpu_loops = ROUNDS_PBKDF2_MD5;
12130 gpu_accel = 8;
12131 break;
12132 case 12000: gpu_loops = ROUNDS_PBKDF2_SHA1;
12133 gpu_accel = 8;
12134 break;
12135 case 12100: gpu_loops = ROUNDS_PBKDF2_SHA512;
12136 gpu_accel = 8;
12137 break;
12138 case 12200: gpu_loops = ROUNDS_ECRYPTFS;
12139 gpu_accel = 8;
12140 break;
12141 case 12300: gpu_loops = ROUNDS_ORACLET;
12142 gpu_accel = 8;
12143 break;
12144 case 12500: gpu_loops = ROUNDS_RAR3;
12145 gpu_accel = 32;
12146 break;
12147 case 12700: gpu_loops = ROUNDS_MYWALLET;
12148 gpu_accel = 512;
12149 break;
12150 case 12800: gpu_loops = ROUNDS_MS_DRSR;
12151 gpu_accel = 512;
12152 break;
12153 }
12154
12155 // some algorithm collide too fast, make that impossible
12156
12157 switch (hash_mode)
12158 {
12159 case 11500: ((uint *) digests_buf)[1] = 1;
12160 break;
12161 }
12162
12163 if (gpu_loops > 1024) gpu_loops = 1024;
12164 if (gpu_accel > 256) gpu_accel = 256; // causes memory problems otherwise
12165 }
12166
12167 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
12168 {
12169 gpu_loops = 1024;
12170 }
12171
12172 if (hash_mode == 12500)
12173 {
12174 gpu_loops = ROUNDS_RAR3 / 16;
12175 }
12176
12177 data.gpu_accel = gpu_accel;
12178 data.gpu_loops = gpu_loops;
12179
12180 hashes_cnt = 1;
12181 }
12182
12183 if (show == 1 || left == 1)
12184 {
12185 for (uint i = 0; i < pot_cnt; i++)
12186 {
12187 pot_t *pot_ptr = &pot[i];
12188
12189 hash_t *hashes_buf = &pot_ptr->hash;
12190
12191 local_free (hashes_buf->digest);
12192
12193 if (isSalted)
12194 {
12195 local_free (hashes_buf->salt);
12196 }
12197 }
12198
12199 local_free (pot);
12200
12201 if (data.quiet == 0) log_info_nn ("");
12202
12203 return (0);
12204 }
12205
12206 if (keyspace == 0)
12207 {
12208 if (hashes_cnt == 0)
12209 {
12210 log_error ("ERROR: No hashes loaded");
12211
12212 return (-1);
12213 }
12214 }
12215
12216 /**
12217 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12218 */
12219
12220 if (data.outfile != NULL)
12221 {
12222 if (data.hashfile != NULL)
12223 {
12224 #ifdef _POSIX
12225 struct stat tmpstat_outfile;
12226 struct stat tmpstat_hashfile;
12227 #endif
12228
12229 #ifdef _WIN
12230 struct stat64 tmpstat_outfile;
12231 struct stat64 tmpstat_hashfile;
12232 #endif
12233
12234 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12235
12236 if (tmp_outfile_fp)
12237 {
12238 #ifdef _POSIX
12239 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12240 #endif
12241
12242 #ifdef _WIN
12243 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12244 #endif
12245
12246 fclose (tmp_outfile_fp);
12247 }
12248
12249 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12250
12251 if (tmp_hashfile_fp)
12252 {
12253 #ifdef _POSIX
12254 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12255 #endif
12256
12257 #ifdef _WIN
12258 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12259 #endif
12260
12261 fclose (tmp_hashfile_fp);
12262 }
12263
12264 if (tmp_outfile_fp && tmp_outfile_fp)
12265 {
12266 tmpstat_outfile.st_mode = 0;
12267 tmpstat_outfile.st_nlink = 0;
12268 tmpstat_outfile.st_uid = 0;
12269 tmpstat_outfile.st_gid = 0;
12270 tmpstat_outfile.st_rdev = 0;
12271 tmpstat_outfile.st_atime = 0;
12272
12273 tmpstat_hashfile.st_mode = 0;
12274 tmpstat_hashfile.st_nlink = 0;
12275 tmpstat_hashfile.st_uid = 0;
12276 tmpstat_hashfile.st_gid = 0;
12277 tmpstat_hashfile.st_rdev = 0;
12278 tmpstat_hashfile.st_atime = 0;
12279
12280 #ifdef _POSIX
12281 tmpstat_outfile.st_blksize = 0;
12282 tmpstat_outfile.st_blocks = 0;
12283
12284 tmpstat_hashfile.st_blksize = 0;
12285 tmpstat_hashfile.st_blocks = 0;
12286 #endif
12287
12288 #ifdef _POSIX
12289 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12290 {
12291 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12292
12293 return (-1);
12294 }
12295 #endif
12296
12297 #ifdef _WIN
12298 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12299 {
12300 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12301
12302 return (-1);
12303 }
12304 #endif
12305 }
12306 }
12307 }
12308
12309 /**
12310 * Remove duplicates
12311 */
12312
12313 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12314
12315 if (isSalted)
12316 {
12317 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12318 }
12319 else
12320 {
12321 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12322 }
12323
12324 uint hashes_cnt_orig = hashes_cnt;
12325
12326 hashes_cnt = 1;
12327
12328 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12329 {
12330 if (isSalted)
12331 {
12332 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12333 {
12334 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12335 }
12336 }
12337 else
12338 {
12339 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12340 }
12341
12342 if (hashes_pos > hashes_cnt)
12343 {
12344 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12345 }
12346
12347 hashes_cnt++;
12348 }
12349
12350 /**
12351 * Potfile removes
12352 */
12353
12354 uint potfile_remove_cracks = 0;
12355
12356 if (potfile_disable == 0)
12357 {
12358 hash_t hash_buf;
12359
12360 hash_buf.digest = mymalloc (dgst_size);
12361 hash_buf.salt = NULL;
12362 hash_buf.esalt = NULL;
12363 hash_buf.hash_info = NULL;
12364 hash_buf.cracked = 0;
12365
12366 if (isSalted)
12367 {
12368 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12369 }
12370
12371 if (esalt_size)
12372 {
12373 hash_buf.esalt = mymalloc (esalt_size);
12374 }
12375
12376 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12377
12378 // no solution for these special hash types (for instane because they use hashfile in output etc)
12379 if ((hash_mode != 5200) &&
12380 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12381 (hash_mode != 9000))
12382 {
12383 FILE *fp = fopen (potfile, "rb");
12384
12385 if (fp != NULL)
12386 {
12387 while (!feof (fp))
12388 {
12389 char line_buf[BUFSIZ];
12390
12391 memset (line_buf, 0, BUFSIZ);
12392
12393 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
12394
12395 if (ptr == NULL) break;
12396
12397 int line_len = strlen (line_buf);
12398
12399 if (line_len == 0) continue;
12400
12401 int iter = MAX_CUT_TRIES;
12402
12403 for (int i = line_len - 1; i && iter; i--, line_len--)
12404 {
12405 if (line_buf[i] != ':') continue;
12406
12407 if (isSalted)
12408 {
12409 memset (hash_buf.salt, 0, sizeof (salt_t));
12410 }
12411
12412 hash_t *found = NULL;
12413
12414 if (hash_mode == 6800)
12415 {
12416 if (i < 48) // 48 = 12 * uint in salt_buf[]
12417 {
12418 // manipulate salt_buf
12419 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12420
12421 hash_buf.salt->salt_len = i;
12422
12423 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12424 }
12425 }
12426 else if (hash_mode == 2500)
12427 {
12428 if (i < 48) // 48 = 12 * uint in salt_buf[]
12429 {
12430 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12431 // manipulate salt_buf
12432
12433 // to be safe work with a copy (because of line_len loop, i etc)
12434
12435 char line_buf_cpy[BUFSIZ];
12436 memset (line_buf_cpy, 0, BUFSIZ);
12437
12438 memset (line_buf_cpy, 0, sizeof (line_buf_cpy));
12439
12440 memcpy (line_buf_cpy, line_buf, i);
12441
12442 char *mac2_pos = strrchr (line_buf_cpy, ':');
12443
12444 if (mac2_pos == NULL) continue;
12445
12446 mac2_pos[0] = 0;
12447 mac2_pos++;
12448
12449 if (strlen (mac2_pos) != 12) continue;
12450
12451 char *mac1_pos = strrchr (line_buf_cpy, ':');
12452
12453 if (mac1_pos == NULL) continue;
12454
12455 mac1_pos[0] = 0;
12456 mac1_pos++;
12457
12458 if (strlen (mac1_pos) != 12) continue;
12459
12460 uint essid_length = mac1_pos - line_buf_cpy - 1;
12461
12462 // here we need the ESSID
12463 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12464
12465 hash_buf.salt->salt_len = essid_length;
12466
12467 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12468
12469 if (found)
12470 {
12471 wpa_t *wpa = (wpa_t *) found->esalt;
12472
12473 uint pke[25];
12474
12475 char *pke_ptr = (char *) pke;
12476
12477 for (uint i = 0; i < 25; i++)
12478 {
12479 pke[i] = byte_swap_32 (wpa->pke[i]);
12480 }
12481
12482 unsigned char mac1[6];
12483 unsigned char mac2[6];
12484
12485 memcpy (mac1, pke_ptr + 23, 6);
12486 memcpy (mac2, pke_ptr + 29, 6);
12487
12488 // compare hex string(s) vs binary MAC address(es)
12489
12490 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12491 {
12492 if (mac1[i] != (unsigned char) hex_to_char (&mac1_pos[j]))
12493 {
12494 found = NULL;
12495 break;
12496 }
12497 }
12498
12499 // early skip ;)
12500 if (!found) continue;
12501
12502 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12503 {
12504 if (mac2[i] != (unsigned char) hex_to_char (&mac2_pos[j]))
12505 {
12506 found = NULL;
12507 break;
12508 }
12509 }
12510 }
12511 }
12512 }
12513 else
12514 {
12515 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12516
12517 if (parser_status == PARSER_OK)
12518 {
12519 if (isSalted)
12520 {
12521 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12522 }
12523 else
12524 {
12525 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12526 }
12527 }
12528 }
12529
12530 if (found == NULL) continue;
12531
12532 if (!found->cracked) potfile_remove_cracks++;
12533
12534 found->cracked = 1;
12535
12536 if (found) break;
12537
12538 iter--;
12539 }
12540 }
12541
12542 fclose (fp);
12543 }
12544 }
12545
12546 if (esalt_size)
12547 {
12548 local_free (hash_buf.esalt);
12549 }
12550
12551 if (isSalted)
12552 {
12553 local_free (hash_buf.salt);
12554 }
12555
12556 local_free (hash_buf.digest);
12557 }
12558
12559 /**
12560 * Now generate all the buffers required for later
12561 */
12562
12563 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12564
12565 salt_t *salts_buf_new = NULL;
12566 void *esalts_buf_new = NULL;
12567
12568 if (isSalted)
12569 {
12570 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12571
12572 if (esalt_size)
12573 {
12574 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12575 }
12576 }
12577 else
12578 {
12579 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12580 }
12581
12582 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12583
12584 uint digests_cnt = hashes_cnt;
12585 uint digests_done = 0;
12586
12587 uint size_digests = digests_cnt * dgst_size;
12588 uint size_shown = digests_cnt * sizeof (uint);
12589
12590 uint *digests_shown = (uint *) mymalloc (size_shown);
12591 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12592
12593 uint salts_cnt = 0;
12594 uint salts_done = 0;
12595
12596 hashinfo_t **hash_info = NULL;
12597
12598 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12599 {
12600 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12601
12602 if (username && (remove || show))
12603 {
12604 uint user_pos;
12605
12606 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12607 {
12608 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12609
12610 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12611 }
12612 }
12613 }
12614
12615 uint *salts_shown = (uint *) mymalloc (size_shown);
12616
12617 salt_t *salt_buf;
12618
12619 {
12620 // copied from inner loop
12621
12622 salt_buf = &salts_buf_new[salts_cnt];
12623
12624 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12625
12626 if (esalt_size)
12627 {
12628 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12629 }
12630
12631 salt_buf->digests_cnt = 0;
12632 salt_buf->digests_done = 0;
12633 salt_buf->digests_offset = 0;
12634
12635 salts_cnt++;
12636 }
12637
12638 if (hashes_buf[0].cracked == 1)
12639 {
12640 digests_shown[0] = 1;
12641
12642 digests_done++;
12643
12644 salt_buf->digests_done++;
12645 }
12646
12647 salt_buf->digests_cnt++;
12648
12649 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12650
12651 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12652 {
12653 hash_info[0] = hashes_buf[0].hash_info;
12654 }
12655
12656 // copy from inner loop
12657
12658 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12659 {
12660 if (isSalted)
12661 {
12662 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12663 {
12664 salt_buf = &salts_buf_new[salts_cnt];
12665
12666 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12667
12668 if (esalt_size)
12669 {
12670 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12671 }
12672
12673 salt_buf->digests_cnt = 0;
12674 salt_buf->digests_done = 0;
12675 salt_buf->digests_offset = hashes_pos;
12676
12677 salts_cnt++;
12678 }
12679 }
12680
12681 if (hashes_buf[hashes_pos].cracked == 1)
12682 {
12683 digests_shown[hashes_pos] = 1;
12684
12685 digests_done++;
12686
12687 salt_buf->digests_done++;
12688 }
12689
12690 salt_buf->digests_cnt++;
12691
12692 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12693
12694 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12695 {
12696 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12697 }
12698 }
12699
12700 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12701 {
12702 salt_t *salt_buf = &salts_buf_new[salt_pos];
12703
12704 if (salt_buf->digests_done == salt_buf->digests_cnt)
12705 {
12706 salts_shown[salt_pos] = 1;
12707
12708 salts_done++;
12709 }
12710
12711 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12712 }
12713
12714 local_free (digests_buf);
12715 local_free (salts_buf);
12716 local_free (esalts_buf);
12717
12718 digests_buf = digests_buf_new;
12719 salts_buf = salts_buf_new;
12720 esalts_buf = esalts_buf_new;
12721
12722 local_free (hashes_buf);
12723
12724 /**
12725 * special modification not set from parser
12726 */
12727
12728 switch (hash_mode)
12729 {
12730 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12731 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12732 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12733 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12734 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12735 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12736 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12737 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12738 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12739 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12740 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12741 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12742 }
12743
12744 if (truecrypt_keyfiles)
12745 {
12746 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12747
12748 char *keyfiles = strdup (truecrypt_keyfiles);
12749
12750 char *keyfile = strtok (keyfiles, ",");
12751
12752 do
12753 {
12754 truecrypt_crc32 (keyfile, (unsigned char *) keyfile_buf);
12755
12756 } while ((keyfile = strtok (NULL, ",")) != NULL);
12757
12758 free (keyfiles);
12759 }
12760
12761 data.digests_cnt = digests_cnt;
12762 data.digests_done = digests_done;
12763 data.digests_buf = digests_buf;
12764 data.digests_shown = digests_shown;
12765 data.digests_shown_tmp = digests_shown_tmp;
12766
12767 data.salts_cnt = salts_cnt;
12768 data.salts_done = salts_done;
12769 data.salts_buf = salts_buf;
12770 data.salts_shown = salts_shown;
12771
12772 data.esalts_buf = esalts_buf;
12773 data.hash_info = hash_info;
12774
12775 /**
12776 * Automatic Optimizers
12777 */
12778
12779 if (salts_cnt == 1)
12780 opti_type |= OPTI_TYPE_SINGLE_SALT;
12781
12782 if (digests_cnt == 1)
12783 opti_type |= OPTI_TYPE_SINGLE_HASH;
12784
12785 if (attack_exec == ATTACK_EXEC_ON_GPU)
12786 opti_type |= OPTI_TYPE_NOT_ITERATED;
12787
12788 if (attack_mode == ATTACK_MODE_BF)
12789 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12790
12791 data.opti_type = opti_type;
12792
12793 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12794 {
12795 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12796 {
12797 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12798 {
12799 if (opts_type & OPTS_TYPE_ST_ADD80)
12800 {
12801 opts_type &= ~OPTS_TYPE_ST_ADD80;
12802 opts_type |= OPTS_TYPE_PT_ADD80;
12803 }
12804
12805 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12806 {
12807 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12808 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12809 }
12810
12811 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12812 {
12813 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12814 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12815 }
12816 }
12817 }
12818 }
12819
12820 /**
12821 * Some algorithm, like descrypt, can benefit from JIT compilation
12822 */
12823
12824 uint force_jit_compilation = 0;
12825
12826 if (hash_mode == 8900)
12827 {
12828 force_jit_compilation = 8900;
12829 }
12830 else if (hash_mode == 9300)
12831 {
12832 force_jit_compilation = 8900;
12833 }
12834 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12835 {
12836 force_jit_compilation = 1500;
12837 }
12838
12839 /**
12840 * generate bitmap tables
12841 */
12842
12843 const uint bitmap_shift1 = 5;
12844 const uint bitmap_shift2 = 13;
12845
12846 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12847
12848 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12849 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12850 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12851 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12852 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12853 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12854 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12855 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12856
12857 uint bitmap_bits;
12858 uint bitmap_nums;
12859 uint bitmap_mask;
12860 uint bitmap_size;
12861
12862 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12863 {
12864 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12865
12866 bitmap_nums = 1 << bitmap_bits;
12867
12868 bitmap_mask = bitmap_nums - 1;
12869
12870 bitmap_size = bitmap_nums * sizeof (uint);
12871
12872 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12873
12874 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;
12875 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;
12876
12877 break;
12878 }
12879
12880 bitmap_nums = 1 << bitmap_bits;
12881
12882 bitmap_mask = bitmap_nums - 1;
12883
12884 bitmap_size = bitmap_nums * sizeof (uint);
12885
12886 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);
12887 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);
12888
12889 /**
12890 * prepare quick rule
12891 */
12892
12893 data.rule_buf_l = rule_buf_l;
12894 data.rule_buf_r = rule_buf_r;
12895
12896 int rule_len_l = (int) strlen (rule_buf_l);
12897 int rule_len_r = (int) strlen (rule_buf_r);
12898
12899 data.rule_len_l = rule_len_l;
12900 data.rule_len_r = rule_len_r;
12901
12902 /**
12903 * load rules
12904 */
12905
12906 uint *all_gpu_rules_cnt = NULL;
12907
12908 gpu_rule_t **all_gpu_rules_buf = NULL;
12909
12910 if (rp_files_cnt)
12911 {
12912 all_gpu_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12913
12914 all_gpu_rules_buf = (gpu_rule_t **) mycalloc (rp_files_cnt, sizeof (gpu_rule_t *));
12915 }
12916
12917 char rule_buf[BUFSIZ];
12918
12919 int rule_len = 0;
12920
12921 for (uint i = 0; i < rp_files_cnt; i++)
12922 {
12923 uint gpu_rules_avail = 0;
12924
12925 uint gpu_rules_cnt = 0;
12926
12927 gpu_rule_t *gpu_rules_buf = NULL;
12928
12929 char *rp_file = rp_files[i];
12930
12931 char in[BLOCK_SIZE];
12932 char out[BLOCK_SIZE];
12933
12934 FILE *fp = NULL;
12935
12936 uint rule_line = 0;
12937
12938 if ((fp = fopen (rp_file, "rb")) == NULL)
12939 {
12940 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12941
12942 return (-1);
12943 }
12944
12945 while (!feof (fp))
12946 {
12947 memset (rule_buf, 0, BUFSIZ);
12948
12949 rule_len = fgetl (fp, rule_buf);
12950
12951 rule_line++;
12952
12953 if (rule_len == 0) continue;
12954
12955 if (rule_buf[0] == '#') continue;
12956
12957 if (gpu_rules_avail == gpu_rules_cnt)
12958 {
12959 gpu_rules_buf = (gpu_rule_t *) myrealloc (gpu_rules_buf, gpu_rules_avail * sizeof (gpu_rule_t), INCR_RULES * sizeof (gpu_rule_t));
12960
12961 gpu_rules_avail += INCR_RULES;
12962 }
12963
12964 memset (in, 0, BLOCK_SIZE);
12965 memset (out, 0, BLOCK_SIZE);
12966
12967 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12968
12969 if (result == -1)
12970 {
12971 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12972
12973 continue;
12974 }
12975
12976 if (cpu_rule_to_gpu_rule (rule_buf, rule_len, &gpu_rules_buf[gpu_rules_cnt]) == -1)
12977 {
12978 log_info ("WARNING: Cannot convert rule for use on GPU in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12979
12980 memset (&gpu_rules_buf[gpu_rules_cnt], 0, sizeof (gpu_rule_t)); // needs to be cleared otherwise we could have some remaining data
12981
12982 continue;
12983 }
12984
12985 /* its so slow
12986 if (rulefind (&gpu_rules_buf[gpu_rules_cnt], gpu_rules_buf, gpu_rules_cnt, sizeof (gpu_rule_t), sort_by_gpu_rule))
12987 {
12988 log_info ("Duplicate rule for use on GPU in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12989
12990 continue;
12991 }
12992 */
12993
12994 gpu_rules_cnt++;
12995 }
12996
12997 fclose (fp);
12998
12999 all_gpu_rules_cnt[i] = gpu_rules_cnt;
13000
13001 all_gpu_rules_buf[i] = gpu_rules_buf;
13002 }
13003
13004 /**
13005 * merge rules or automatic rule generator
13006 */
13007
13008 uint gpu_rules_cnt = 0;
13009
13010 gpu_rule_t *gpu_rules_buf = NULL;
13011
13012 if (attack_mode == ATTACK_MODE_STRAIGHT)
13013 {
13014 if (rp_files_cnt)
13015 {
13016 gpu_rules_cnt = 1;
13017
13018 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13019
13020 repeats[0] = gpu_rules_cnt;
13021
13022 for (uint i = 0; i < rp_files_cnt; i++)
13023 {
13024 gpu_rules_cnt *= all_gpu_rules_cnt[i];
13025
13026 repeats[i + 1] = gpu_rules_cnt;
13027 }
13028
13029 gpu_rules_buf = (gpu_rule_t *) mycalloc (gpu_rules_cnt, sizeof (gpu_rule_t));
13030
13031 memset (gpu_rules_buf, 0, gpu_rules_cnt * sizeof (gpu_rule_t));
13032
13033 for (uint i = 0; i < gpu_rules_cnt; i++)
13034 {
13035 uint out_pos = 0;
13036
13037 gpu_rule_t *out = &gpu_rules_buf[i];
13038
13039 for (uint j = 0; j < rp_files_cnt; j++)
13040 {
13041 uint in_off = (i / repeats[j]) % all_gpu_rules_cnt[j];
13042 uint in_pos;
13043
13044 gpu_rule_t *in = &all_gpu_rules_buf[j][in_off];
13045
13046 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13047 {
13048 if (out_pos == RULES_MAX - 1)
13049 {
13050 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13051
13052 break;
13053 }
13054
13055 out->cmds[out_pos] = in->cmds[in_pos];
13056 }
13057 }
13058 }
13059
13060 local_free (repeats);
13061 }
13062 else if (rp_gen)
13063 {
13064 uint gpu_rules_avail = 0;
13065
13066 while (gpu_rules_cnt < rp_gen)
13067 {
13068 if (gpu_rules_avail == gpu_rules_cnt)
13069 {
13070 gpu_rules_buf = (gpu_rule_t *) myrealloc (gpu_rules_buf, gpu_rules_avail * sizeof (gpu_rule_t), INCR_RULES * sizeof (gpu_rule_t));
13071
13072 gpu_rules_avail += INCR_RULES;
13073 }
13074
13075 memset (rule_buf, 0, BLOCK_SIZE);
13076
13077 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13078
13079 if (cpu_rule_to_gpu_rule (rule_buf, rule_len, &gpu_rules_buf[gpu_rules_cnt]) == -1) continue;
13080
13081 gpu_rules_cnt++;
13082 }
13083 }
13084 }
13085
13086 /**
13087 * generate NOP rules
13088 */
13089
13090 if (gpu_rules_cnt == 0)
13091 {
13092 gpu_rules_buf = (gpu_rule_t *) mymalloc (sizeof (gpu_rule_t));
13093
13094 gpu_rules_buf[gpu_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13095
13096 gpu_rules_cnt++;
13097 }
13098
13099 data.gpu_rules_cnt = gpu_rules_cnt;
13100 data.gpu_rules_buf = gpu_rules_buf;
13101
13102 /**
13103 * platform
13104 */
13105
13106 #ifdef _CUDA
13107 if (cuInit (0) != CUDA_SUCCESS)
13108 {
13109 log_error ("ERROR: No NVidia compatible platform found");
13110
13111 return (-1);
13112 }
13113 #endif
13114
13115 /**
13116 * devices get
13117 */
13118
13119 uint devices_all_cnt = 0;
13120
13121 #ifdef _CUDA
13122 CUdevice devices_all[DEVICES_MAX];
13123 CUdevice devices[DEVICES_MAX];
13124
13125 hc_cuDeviceGetCount ((int *) &devices_all_cnt);
13126
13127 for (uint i = 0; i < devices_all_cnt; i++)
13128 {
13129 hc_cuDeviceGet (&devices_all[i], i);
13130 }
13131
13132 #elif _OCL
13133 cl_platform_id CL_platform = NULL;
13134
13135 cl_platform_id CL_platforms[CL_PLATFORMS_MAX];
13136
13137 uint CL_platforms_cnt = 0;
13138
13139 hc_clGetPlatformIDs (CL_PLATFORMS_MAX, CL_platforms, &CL_platforms_cnt);
13140
13141 for (uint i = 0; i < CL_platforms_cnt; i++)
13142 {
13143 char CL_platform_vendor[INFOSZ];
13144
13145 memset (CL_platform_vendor, 0, sizeof (CL_platform_vendor));
13146
13147 hc_clGetPlatformInfo (CL_platforms[i], CL_PLATFORM_VENDOR, sizeof (CL_platform_vendor), CL_platform_vendor, NULL);
13148
13149 if ((strcmp (CL_platform_vendor, CL_VENDOR_AMD) != 0)
13150 && (strcmp (CL_platform_vendor, CL_VENDOR_SDS) != 0)
13151 && (strcmp (CL_platform_vendor, CL_VENDOR_APPLE) != 0)) continue;
13152
13153 if (strcmp (CL_platform_vendor, CL_VENDOR_SDS) == 0) gpu_temp_disable = 1;
13154
13155 CL_platform = CL_platforms[i];
13156 }
13157
13158 if (CL_platform == NULL)
13159 {
13160 log_error ("ERROR: No AMD/SDS compatible platform found");
13161
13162 return (-1);
13163 }
13164
13165 cl_device_id devices_all[DEVICES_MAX];
13166 cl_device_id devices[DEVICES_MAX];
13167
13168 hc_clGetDeviceIDs (CL_platform, CL_DEVICE_TYPE_GPU, DEVICES_MAX, devices_all, (uint *) &devices_all_cnt);
13169
13170 #endif
13171
13172 int hm_adapters_all = devices_all_cnt;
13173
13174 hm_attrs_t hm_adapter_all[DEVICES_MAX];
13175
13176 memset (hm_adapter_all, 0, sizeof (hm_adapter_all));
13177
13178 if (gpu_temp_disable == 0)
13179 {
13180 #ifdef _CUDA
13181 #ifdef LINUX
13182 if (hc_NVML_nvmlInit () == NVML_SUCCESS)
13183 {
13184 HM_ADAPTER nvGPUHandle[DEVICES_MAX];
13185
13186 int tmp_in = hm_get_adapter_index (nvGPUHandle);
13187
13188 int tmp_out = 0;
13189
13190 for (int i = 0; i < tmp_in; i++)
13191 {
13192 hm_adapter_all[tmp_out++].adapter_index = nvGPUHandle[i];
13193 }
13194
13195 hm_adapters_all = tmp_out;
13196
13197 for (int i = 0; i < tmp_out; i++)
13198 {
13199 unsigned int speed;
13200
13201 if (nvmlDeviceGetFanSpeed (hm_adapter_all[i].adapter_index, &speed) != NVML_ERROR_NOT_SUPPORTED) hm_adapter_all[i].fan_supported = 1;
13202 }
13203 }
13204 #endif
13205
13206 #ifdef WIN
13207 if (NvAPI_Initialize () == NVAPI_OK)
13208 {
13209 HM_ADAPTER nvGPUHandle[DEVICES_MAX];
13210
13211 int tmp_in = hm_get_adapter_index (nvGPUHandle);
13212
13213 int tmp_out = 0;
13214
13215 for (int i = 0; i < tmp_in; i++)
13216 {
13217 hm_adapter_all[tmp_out++].adapter_index = nvGPUHandle[i];
13218 }
13219
13220 hm_adapters_all = tmp_out;
13221
13222 for (int i = 0; i < tmp_out; i++)
13223 {
13224 NvU32 speed;
13225
13226 if (NvAPI_GPU_GetTachReading (hm_adapter_all[i].adapter_index, &speed) != NVAPI_NOT_SUPPORTED) hm_adapter_all[i].fan_supported = 1;
13227 }
13228 }
13229 #endif
13230 #endif
13231
13232 #ifdef _OCL
13233 #ifndef OSX
13234 HM_LIB hm_dll = hm_init ();
13235
13236 data.hm_dll = hm_dll;
13237
13238 if (hc_ADL_Main_Control_Create (hm_dll, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13239 {
13240 // total number of adapters
13241
13242 int hm_adapters_num;
13243
13244 if (get_adapters_num (hm_dll, &hm_adapters_num) != 0) return (-1);
13245
13246 // adapter info
13247
13248 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info (hm_dll, hm_adapters_num);
13249
13250 if (lpAdapterInfo == NULL) return (-1);
13251
13252 // get a list (of ids of) valid/usable adapters
13253
13254 int num_adl_adapters = 0;
13255
13256 uint32_t *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13257
13258 if (num_adl_adapters > 0)
13259 {
13260 hc_thread_mutex_lock (mux_adl);
13261
13262 // hm_get_opencl_busid_devid (hm_adapter_all, devices_all_cnt, devices_all);
13263
13264 hm_get_adapter_index (hm_adapter_all, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13265
13266 hm_get_overdrive_version (hm_dll, hm_adapter_all, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13267 hm_check_fanspeed_control (hm_dll, hm_adapter_all, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13268
13269 hc_thread_mutex_unlock (mux_adl);
13270 }
13271
13272 hm_adapters_all = num_adl_adapters;
13273
13274 myfree (valid_adl_device_list);
13275 myfree (lpAdapterInfo);
13276 }
13277 #endif
13278 #endif
13279 }
13280
13281 if (hm_adapters_all == 0)
13282 {
13283 gpu_temp_disable = 1;
13284 }
13285
13286 if (gpu_temp_disable == 1)
13287 {
13288 gpu_temp_abort = 0;
13289 gpu_temp_retain = 0;
13290 }
13291
13292 /**
13293 * enable custom signal handler(s)
13294 */
13295
13296 if (benchmark == 0)
13297 {
13298 hc_signal (sigHandler_default);
13299 }
13300 else
13301 {
13302 hc_signal (sigHandler_benchmark);
13303 }
13304
13305 /**
13306 * devices mask and properties
13307 */
13308
13309 uint devices_cnt = 0;
13310
13311 for (uint device_all_id = 0; device_all_id < devices_all_cnt; device_all_id++)
13312 {
13313 if (gpu_devicemask)
13314 {
13315 uint device_all_id_mask = 1 << device_all_id;
13316
13317 if ((device_all_id_mask & gpu_devicemask) != device_all_id_mask)
13318 {
13319 if (quiet == 0 && algorithm_pos == 0) log_info ("Device #%d: skipped by user", device_all_id_mask + 1);
13320
13321 continue;
13322 }
13323 }
13324
13325 const uint device_id = devices_cnt;
13326
13327 devices[device_id] = devices_all[device_all_id];
13328
13329 memcpy (&data.hm_device[device_id], &hm_adapter_all[device_all_id], sizeof (hm_attrs_t));
13330
13331 char device_name[INFOSZ];
13332
13333 memset (device_name, 0, sizeof (device_name));
13334
13335 #ifdef _CUDA
13336 size_t global_mem_size;
13337 int max_clock_frequency;
13338 int max_compute_units;
13339 int kernel_exec_timeout;
13340
13341 hc_cuDeviceGetName (device_name, sizeof (device_name), devices[device_id]);
13342 hc_cuDeviceTotalMem (&global_mem_size, devices[device_id]);
13343 hc_cuDeviceGetAttribute (&max_clock_frequency, CU_DEVICE_ATTRIBUTE_CLOCK_RATE, devices[device_id]); max_clock_frequency /= 1000;
13344 hc_cuDeviceGetAttribute (&max_compute_units, CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT, devices[device_id]);
13345 hc_cuDeviceGetAttribute (&kernel_exec_timeout, CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT, devices[device_id]);
13346
13347 #elif _OCL
13348 cl_ulong global_mem_size;
13349 cl_uint max_clock_frequency;
13350 cl_uint max_compute_units;
13351
13352 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_NAME, sizeof (device_name), &device_name, NULL);
13353 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (global_mem_size), &global_mem_size, NULL);
13354 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (max_clock_frequency), &max_clock_frequency, NULL);
13355 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (max_compute_units), &max_compute_units, NULL);
13356
13357 #endif
13358
13359 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13360 {
13361 log_info ("Device #%u: %s, %luMB, %dMhz, %uMCU",
13362 device_all_id + 1,
13363 device_name,
13364 (unsigned int) (global_mem_size / 1024 / 1024),
13365 (unsigned int) (max_clock_frequency),
13366 (unsigned int) max_compute_units);
13367 }
13368
13369 #ifdef _CUDA
13370 if (quiet == 0 && kernel_exec_timeout != 0 && algorithm_pos == 0)
13371 {
13372 log_info ("Device #%u: WARNING! Kernel exec timeout is not disabled, it might cause you errors of code 702", device_id + 1);
13373 #if _WIN
13374 log_info (" You can disable it with a regpatch, see here: http://hashcat.net/wiki/doku.php?id=timeout_patch");
13375 #endif
13376 }
13377 #endif
13378
13379 devices_cnt++;
13380 }
13381
13382 if (devices_cnt == 0)
13383 {
13384 log_error ("ERROR: No devices left that matches your specification.");
13385
13386 return (-1);
13387 }
13388
13389 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13390 {
13391 log_info ("");
13392 }
13393
13394 /**
13395 * inform the user
13396 */
13397
13398 // gpu temp sanity check
13399
13400 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13401 {
13402 if (gpu_temp_abort < gpu_temp_retain)
13403 {
13404 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13405
13406 return (-1);
13407 }
13408 }
13409
13410 if (data.quiet == 0)
13411 {
13412 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13413
13414 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);
13415
13416 if (attack_mode == ATTACK_MODE_STRAIGHT)
13417 {
13418 log_info ("Rules: %u", gpu_rules_cnt);
13419 }
13420
13421 if (opti_type)
13422 {
13423 log_info ("Applicable Optimizers:");
13424
13425 for (uint i = 0; i < 32; i++)
13426 {
13427 const uint opti_bit = 1 << i;
13428
13429 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13430 }
13431 }
13432
13433 /**
13434 * Watchdog and Temperature balance
13435 */
13436
13437 if (gpu_temp_abort == 0)
13438 {
13439 log_info ("Watchdog: Temperature abort trigger disabled");
13440 }
13441 else
13442 {
13443 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13444 }
13445
13446 if (gpu_temp_retain == 0)
13447 {
13448 log_info ("Watchdog: Temperature retain trigger disabled");
13449 }
13450 else
13451 {
13452 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13453 }
13454 }
13455
13456 /**
13457 * store all the preparation, not hash_mode dependant
13458 */
13459
13460 data.gpu_temp_disable = gpu_temp_disable;
13461 data.gpu_temp_abort = gpu_temp_abort;
13462 data.gpu_temp_retain = gpu_temp_retain;
13463
13464 data.devices_cnt = devices_cnt;
13465
13466 #ifdef _OCL
13467 /**
13468 * catalyst driver check
13469 */
13470
13471 int catalyst_check = (force == 1) ? 0 : 1;
13472
13473 int catalyst_warn = 0;
13474
13475 int catalyst_broken = 0;
13476 #endif
13477
13478 /**
13479 * devices init
13480 */
13481
13482 #ifdef _OCL
13483 #ifndef OSX
13484 int gpu_temp_retain_set = 0;
13485
13486 int *temp_retain_fanspeed_value = (int *) mycalloc (devices_cnt, sizeof (int));
13487
13488 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (devices_cnt, sizeof (ADLOD6MemClockState));
13489
13490 int *od_power_control_status = (int *) mycalloc (devices_cnt, sizeof (int));
13491 #endif
13492 #endif
13493
13494 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (devices_cnt, sizeof (hc_device_param_t));
13495
13496 data.devices_param = devices_param;
13497
13498 for (uint device_id = 0; device_id < devices_cnt; device_id++)
13499 {
13500 hc_device_param_t *device_param = &data.devices_param[device_id];
13501
13502 #ifdef _CUDA
13503 CUdevice device = devices[device_id];
13504
13505 device_param->device = device;
13506
13507 size_t bytes;
13508
13509 hc_cuDeviceTotalMem (&bytes, device);
13510
13511 device_param->gpu_maxmem_alloc = bytes;
13512
13513 int sm_major = 0;
13514 int sm_minor = 0;
13515 int max_compute_units = 0;
13516
13517 hc_cuDeviceComputeCapability (&sm_major, &sm_minor, device);
13518
13519 if (sm_major == 1)
13520 {
13521 log_error ("ERROR: Shader Model 1.0 - 1.3 based GPU detected. Support for CUDA was dropped by NVidia.");
13522 log_error (" Remove it from your system or use -d and select only supported cards.");
13523
13524 return (-1);
13525 }
13526
13527 device_param->sm_major = sm_major;
13528 device_param->sm_minor = sm_minor;
13529
13530 hc_cuDeviceGetAttribute (&max_compute_units, CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT, device);
13531
13532 if (sm_major >= 5)
13533 {
13534 // those maxwell and newer are so good compared to older chipsets we need to equalize
13535 // their power to older chipsets, otherwise workload distribution which is based on the compute_units
13536 // gets out of control
13537
13538 max_compute_units *= 3;
13539 }
13540
13541 device_param->gpu_processors = max_compute_units;
13542
13543 /**
13544 * calculate vector size
13545 */
13546
13547 uint vliw = get_vliw_by_compute_capability (sm_major, sm_minor);
13548
13549 device_param->gpu_vector_width = get_gpu_vector_width (hash_mode, attack_kern, attack_exec, opti_type, vliw);
13550
13551 #elif _OCL
13552 cl_device_id device = devices[device_id];
13553
13554 device_param->device = device;
13555
13556 cl_uint max_compute_units = 0;
13557
13558 hc_clGetDeviceInfo (device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (max_compute_units), &max_compute_units, NULL);
13559
13560 device_param->gpu_processors = max_compute_units;
13561
13562 cl_ulong max_mem_alloc_size = 0;
13563
13564 hc_clGetDeviceInfo (device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (max_mem_alloc_size), &max_mem_alloc_size, NULL);
13565
13566 device_param->gpu_maxmem_alloc = max_mem_alloc_size;
13567
13568 char tmp[INFOSZ], t1[64];
13569
13570 memset (tmp, 0, sizeof (tmp));
13571
13572 hc_clGetDeviceInfo (device, CL_DEVICE_NAME, sizeof (tmp), &tmp, NULL);
13573
13574 device_param->device_name = mystrdup (tmp);
13575
13576 memset (tmp, 0, sizeof (tmp));
13577
13578 hc_clGetDeviceInfo (device, CL_DEVICE_VERSION, sizeof (tmp), &tmp, NULL);
13579
13580 memset (t1, 0, sizeof (t1));
13581
13582 sscanf (tmp, "%*16s %*16s %*16s (%[^)]16s)", t1);
13583
13584 device_param->device_version = mystrdup (t1);
13585
13586 memset (tmp, 0, sizeof (tmp));
13587
13588 hc_clGetDeviceInfo (device, CL_DRIVER_VERSION, sizeof (tmp), &tmp, NULL);
13589
13590 device_param->driver_version = mystrdup (tmp);
13591
13592 /**
13593 * calculate vector size
13594 */
13595
13596 uint vliw = get_vliw_by_device_name (device_param->device_name);
13597
13598 device_param->gpu_vector_width = get_gpu_vector_width (hash_mode, attack_kern, attack_exec, opti_type, vliw);
13599
13600 /**
13601 * catalyst driver check
13602 */
13603
13604 if (catalyst_check == 1)
13605 {
13606 catalyst_warn = 1;
13607
13608 // v14.9 and higher
13609 if ((atoi (device_param->device_version) >= 1573)
13610 && (atoi (device_param->driver_version) >= 1573))
13611 {
13612 catalyst_warn = 0;
13613 }
13614
13615 /*
13616 // v14.9
13617 if ((strstr (device_param->device_version, "1573.") != NULL)
13618 && (strstr (device_param->driver_version, "1573.") != NULL))
13619 {
13620 catalyst_warn = 0;
13621 }
13622
13623 // v14.12 -- version overlaps with v15.4 beta
13624 if ((strstr (device_param->device_version, "1642.") != NULL)
13625 && (strstr (device_param->driver_version, "1642.") != NULL))
13626 {
13627 catalyst_broken = 1;
13628 }
13629
13630 // v15.4 (Beta, Windows only release)
13631 if ((strstr (device_param->device_version, "1642.") != NULL)
13632 && (strstr (device_param->driver_version, "1642.") != NULL))
13633 {
13634 catalyst_warn = 0;
13635 }
13636
13637 // v15.5 (Release, Linux)
13638 if ((strstr (device_param->device_version, "1702.") != NULL)
13639 && (strstr (device_param->driver_version, "1702.") != NULL))
13640 {
13641 catalyst_warn = 0;
13642 }
13643
13644 // v15.3 (Beta, Ubuntu repository release)
13645 if ((strstr (device_param->device_version, "1729.") != NULL)
13646 && (strstr (device_param->driver_version, "1729.") != NULL))
13647 {
13648 catalyst_warn = 0;
13649 }
13650 */
13651
13652 catalyst_check = 0;
13653 }
13654 #endif
13655 }
13656
13657 #ifdef _OCL
13658 if (catalyst_broken == 1)
13659 {
13660 log_error ("");
13661 log_error ("ATTENTION! The installed GPU driver in your system is known to be broken!");
13662 log_error ("It will pass over cracked hashes and does not report them as cracked");
13663 log_error ("You are STRONGLY encouraged not to use it");
13664 log_error ("You can use --force to override this but do not post error reports if you do so");
13665
13666 return (-1);
13667 }
13668
13669 if (catalyst_warn == 1)
13670 {
13671 log_error ("");
13672 log_error ("ATTENTION! Unsupported or incorrect installed GPU driver detected!");
13673 log_error ("You are STRONGLY encouraged to use the official supported GPU driver for good reasons");
13674 log_error ("See oclHashcat's homepage for official supported GPU drivers");
13675 #ifdef _WIN
13676 log_error ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13677 #endif
13678 log_error ("You can use --force to override this but do not post error reports if you do so");
13679
13680 return (-1);
13681 }
13682 #endif
13683
13684 uint gpu_blocks_all = 0;
13685
13686 #ifdef _CUDA
13687 for (uint device_id = 0; device_id < devices_cnt; device_id++)
13688 {
13689 /**
13690 * host buffer
13691 */
13692
13693 hc_device_param_t *device_param = &data.devices_param[device_id];
13694
13695 /**
13696 * device properties
13697 */
13698
13699 int sm_minor = device_param->sm_minor;
13700 int sm_major = device_param->sm_major;
13701
13702 uint gpu_processors = device_param->gpu_processors;
13703 uint gpu_vector_width = device_param->gpu_vector_width;
13704
13705 /**
13706 * create context for each device
13707 */
13708
13709 uint flags = 0;
13710
13711 if (gpu_async == 0) flags |= CU_CTX_SCHED_BLOCKING_SYNC;
13712 else flags |= CU_CTX_SCHED_SPIN;
13713
13714 hc_cuCtxCreate (&device_param->context, flags, device_param->device);
13715
13716 // does bad things hc_cuCtxSetCacheConfig (CU_FUNC_CACHE_PREFER_L1);
13717
13718 /**
13719 * create input buffers on device
13720 */
13721
13722 uint gpu_threads = GPU_THREADS_NV;
13723
13724 if (hash_mode == 1500) gpu_threads = 64;
13725 if (hash_mode == 3000) gpu_threads = 64;
13726 if (hash_mode == 3200) gpu_threads = 8;
13727 if (hash_mode == 7500) gpu_threads = 64;
13728 if (hash_mode == 8900) gpu_threads = 64;
13729 if (hash_mode == 9000) gpu_threads = 8;
13730 if (hash_mode == 9300) gpu_threads = 64;
13731 if (hash_mode == 9700) gpu_threads = 64;
13732 if (hash_mode == 9710) gpu_threads = 64;
13733 if (hash_mode == 9800) gpu_threads = 64;
13734 if (hash_mode == 9810) gpu_threads = 64;
13735 if (hash_mode == 10400) gpu_threads = 64;
13736 if (hash_mode == 10410) gpu_threads = 64;
13737 if (hash_mode == 10500) gpu_threads = 64;
13738
13739 uint gpu_power = gpu_processors * gpu_threads * gpu_accel;
13740 uint gpu_blocks = gpu_power * gpu_vector_width;
13741
13742 device_param->gpu_threads = gpu_threads;
13743 device_param->gpu_power_user = gpu_power;
13744 device_param->gpu_blocks_user = gpu_blocks;
13745
13746 gpu_blocks_all += gpu_blocks;
13747
13748 uint size_pws = gpu_power * sizeof (pw_t);
13749
13750 uint size_tmps = 4;
13751
13752 switch (hash_mode)
13753 {
13754 case 400: size_tmps = gpu_blocks * sizeof (phpass_tmp_t); break;
13755 case 500: size_tmps = gpu_blocks * sizeof (md5crypt_tmp_t); break;
13756 case 501: size_tmps = gpu_blocks * sizeof (md5crypt_tmp_t); break;
13757 case 1600: size_tmps = gpu_blocks * sizeof (md5crypt_tmp_t); break;
13758 case 1800: size_tmps = gpu_blocks * sizeof (sha512crypt_tmp_t); break;
13759 case 2100: size_tmps = gpu_blocks * sizeof (dcc2_tmp_t); break;
13760 case 2500: size_tmps = gpu_blocks * sizeof (wpa_tmp_t); break;
13761 case 3200: size_tmps = gpu_blocks * sizeof (bcrypt_tmp_t); break;
13762 case 5200: size_tmps = gpu_blocks * sizeof (pwsafe3_tmp_t); break;
13763 case 5800: size_tmps = gpu_blocks * sizeof (androidpin_tmp_t); break;
13764 case 6211:
13765 case 6212:
13766 case 6213: size_tmps = gpu_blocks * sizeof (tc_tmp_t); break;
13767 case 6221:
13768 case 6222:
13769 case 6223: size_tmps = gpu_blocks * sizeof (tc64_tmp_t); break;
13770 case 6231:
13771 case 6232:
13772 case 6233: size_tmps = gpu_blocks * sizeof (tc_tmp_t); break;
13773 case 6241:
13774 case 6242:
13775 case 6243: size_tmps = gpu_blocks * sizeof (tc_tmp_t); break;
13776 case 6300: size_tmps = gpu_blocks * sizeof (md5crypt_tmp_t); break;
13777 case 6400: size_tmps = gpu_blocks * sizeof (sha256aix_tmp_t); break;
13778 case 6500: size_tmps = gpu_blocks * sizeof (sha512aix_tmp_t); break;
13779 case 6600: size_tmps = gpu_blocks * sizeof (agilekey_tmp_t); break;
13780 case 6700: size_tmps = gpu_blocks * sizeof (sha1aix_tmp_t); break;
13781 case 6800: size_tmps = gpu_blocks * sizeof (lastpass_tmp_t); break;
13782 case 7100: size_tmps = gpu_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13783 case 7200: size_tmps = gpu_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13784 case 7400: size_tmps = gpu_blocks * sizeof (sha256crypt_tmp_t); break;
13785 case 7900: size_tmps = gpu_blocks * sizeof (drupal7_tmp_t); break;
13786 case 8200: size_tmps = gpu_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13787 case 8800: size_tmps = gpu_blocks * sizeof (androidfde_tmp_t); break;
13788 case 8900: size_tmps = gpu_blocks * sizeof (scrypt_tmp_t); break;
13789 case 9000: size_tmps = gpu_blocks * sizeof (pwsafe2_tmp_t); break;
13790 case 9100: size_tmps = gpu_blocks * sizeof (lotus8_tmp_t); break;
13791 case 9200: size_tmps = gpu_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13792 case 9300: size_tmps = gpu_blocks * sizeof (scrypt_tmp_t); break;
13793 case 9400: size_tmps = gpu_blocks * sizeof (office2007_tmp_t); break;
13794 case 9500: size_tmps = gpu_blocks * sizeof (office2010_tmp_t); break;
13795 case 9600: size_tmps = gpu_blocks * sizeof (office2013_tmp_t); break;
13796 case 10000: size_tmps = gpu_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13797 case 10200: size_tmps = gpu_blocks * sizeof (cram_md5_t); break;
13798 case 10300: size_tmps = gpu_blocks * sizeof (saph_sha1_tmp_t); break;
13799 case 10500: size_tmps = gpu_blocks * sizeof (pdf14_tmp_t); break;
13800 case 10700: size_tmps = gpu_blocks * sizeof (pdf17l8_tmp_t); break;
13801 case 10900: size_tmps = gpu_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13802 case 11300: size_tmps = gpu_blocks * sizeof (bitcoin_wallet_tmp_t); break;
13803 case 11600: size_tmps = gpu_blocks * sizeof (seven_zip_tmp_t); break;
13804 case 11900: size_tmps = gpu_blocks * sizeof (pbkdf2_md5_tmp_t); break;
13805 case 12000: size_tmps = gpu_blocks * sizeof (pbkdf2_sha1_tmp_t); break;
13806 case 12100: size_tmps = gpu_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13807 case 12200: size_tmps = gpu_blocks * sizeof (ecryptfs_tmp_t); break;
13808 case 12300: size_tmps = gpu_blocks * sizeof (oraclet_tmp_t); break;
13809 case 12400: size_tmps = gpu_blocks * sizeof (bsdicrypt_tmp_t); break;
13810 case 12500: size_tmps = gpu_blocks * sizeof (rar3_tmp_t); break;
13811 case 12700: size_tmps = gpu_blocks * sizeof (mywallet_tmp_t); break;
13812 case 12800: size_tmps = gpu_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13813 };
13814
13815 uint size_hooks = 4;
13816
13817 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13818 {
13819 // fill size_hook with correct size
13820 }
13821
13822 // we can optimize some stuff here...
13823
13824 device_param->size_pws = size_pws;
13825 device_param->size_tmps = size_tmps;
13826 device_param->size_hooks = size_hooks;
13827
13828 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13829 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13830
13831 device_param->size_root_css = size_root_css;
13832 device_param->size_markov_css = size_markov_css;
13833
13834 uint size_results = GPU_THREADS_NV * sizeof (uint);
13835
13836 device_param->size_results = size_results;
13837
13838 uint size_rules = gpu_rules_cnt * sizeof (gpu_rule_t);
13839 uint size_plains = digests_cnt * sizeof (plain_t);
13840 uint size_salts = salts_cnt * sizeof (salt_t);
13841 uint size_esalts = salts_cnt * esalt_size;
13842
13843 device_param->size_plains = size_plains;
13844 device_param->size_digests = size_digests;
13845 device_param->size_shown = size_shown;
13846 device_param->size_salts = size_salts;
13847
13848 uint size_combs = GPU_COMBS * sizeof (comb_t);
13849 uint size_bfs = GPU_BFS * sizeof (bf_t);
13850 uint size_tm = 32 * sizeof (bs_word_t);
13851
13852 uint64_t size_scryptV = 1;
13853
13854 if ((hash_mode == 8900) || (hash_mode == 9300))
13855 {
13856 #define SHADER_PER_MP 32
13857 #define WARPS 32
13858
13859 uint tmto_start = 2;
13860 uint tmto_stop = 1024;
13861
13862 if (scrypt_tmto)
13863 {
13864 tmto_start = 1 << scrypt_tmto;
13865 tmto_stop = tmto_start + 1;
13866 }
13867
13868 for (uint tmto = tmto_start; tmto < tmto_stop; tmto <<= 1)
13869 {
13870 // todo -- make sure all salts get the new tmto value
13871
13872 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13873
13874 size_scryptV /= tmto;
13875
13876 size_scryptV *= gpu_processors * WARPS * SHADER_PER_MP;
13877
13878 if (size_scryptV > (device_param->gpu_maxmem_alloc / 2)) continue;
13879
13880 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13881 {
13882 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13883 data.salts_buf[salts_pos].scrypt_phy = gpu_processors * WARPS * SHADER_PER_MP;
13884 }
13885
13886 break;
13887 }
13888
13889 if (data.salts_buf[0].scrypt_tmto == 0)
13890 {
13891 log_error ("ERROR: can't allocate enough GPU memory");
13892
13893 return -1;
13894 }
13895
13896 if (quiet == 0) log_info ("");
13897 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u\n", data.salts_buf[0].scrypt_tmto);
13898 }
13899
13900 /**
13901 * stream
13902 */
13903
13904 hc_cuStreamCreate (&device_param->stream, 0);
13905
13906 /**
13907 * In theory we'd need a real JIT solution as we have it with OpenCL, but CUDA does not provide such a feature, what a shame!
13908 * There's NVRTC library which is able to compile sourcecode to PTX which we could use, but for some unknown reason this works only for 64 bit
13909 * There's also the problem that the user needs to install the CUDA SDK to get this to work.
13910 */
13911
13912 force_jit_compilation = 0;
13913
13914 /**
13915 * module find
13916 */
13917
13918 struct stat st;
13919
13920 char module_file[256];
13921
13922 memset (module_file, 0, sizeof (module_file));
13923
13924 #ifdef BINARY_KERNEL
13925
13926 if (force_jit_compilation == 0)
13927 {
13928 #ifdef __x86_64__
13929 if (attack_exec == ATTACK_EXEC_ON_GPU)
13930 {
13931 if (attack_kern == ATTACK_KERN_STRAIGHT)
13932 snprintf (module_file, sizeof (module_file) - 1, "%s/kernels/4318/m%05d_a0.sm_%d%d.64.cubin", install_dir, (int) kern_type, sm_major, sm_minor);
13933 else if (attack_kern == ATTACK_KERN_COMBI)
13934 snprintf (module_file, sizeof (module_file) - 1, "%s/kernels/4318/m%05d_a1.sm_%d%d.64.cubin", install_dir, (int) kern_type, sm_major, sm_minor);
13935 else if (attack_kern == ATTACK_KERN_BF)
13936 snprintf (module_file, sizeof (module_file) - 1, "%s/kernels/4318/m%05d_a3.sm_%d%d.64.cubin", install_dir, (int) kern_type, sm_major, sm_minor);
13937 }
13938 else
13939 {
13940 snprintf (module_file, sizeof (module_file) - 1, "%s/kernels/4318/m%05d.sm_%d%d.64.cubin", install_dir, (int) kern_type, sm_major, sm_minor);
13941
13942 if ((hash_mode == 8900) || (hash_mode == 9300))
13943 {
13944 snprintf (module_file, sizeof (module_file) - 1, "%s/kernels/4318/m%05d_%d_%d_%d_%d.sm_%d%d.64.cubin", 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, sm_major, sm_minor);
13945 }
13946 }
13947
13948 #else
13949 if (attack_exec == ATTACK_EXEC_ON_GPU)
13950 {
13951 if (attack_kern == ATTACK_KERN_STRAIGHT)
13952 snprintf (module_file, sizeof (module_file) - 1, "%s/kernels/4318/m%05d_a0.sm_%d%d.32.cubin", install_dir, (int) kern_type, sm_major, sm_minor);
13953 else if (attack_kern == ATTACK_KERN_COMBI)
13954 snprintf (module_file, sizeof (module_file) - 1, "%s/kernels/4318/m%05d_a1.sm_%d%d.32.cubin", install_dir, (int) kern_type, sm_major, sm_minor);
13955 else if (attack_kern == ATTACK_KERN_BF)
13956 snprintf (module_file, sizeof (module_file) - 1, "%s/kernels/4318/m%05d_a3.sm_%d%d.32.cubin", install_dir, (int) kern_type, sm_major, sm_minor);
13957 }
13958 else
13959 {
13960 snprintf (module_file, sizeof (module_file) - 1, "%s/kernels/4318/m%05d.sm_%d%d.32.cubin", install_dir, (int) kern_type, sm_major, sm_minor);
13961
13962 if ((hash_mode == 8900) || (hash_mode == 9300))
13963 {
13964 snprintf (module_file, sizeof (module_file) - 1, "%s/kernels/4318/m%05d_%d_%d_%d_%d.sm_%d%d.32.cubin", 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, sm_major, sm_minor);
13965 }
13966 }
13967
13968 #endif
13969 }
13970 else
13971 {
13972 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, install_dir, module_file);
13973
13974 if (stat (module_file, &st) == -1)
13975 {
13976 log_error ("ERROR: %s: %s", module_file, strerror (errno));
13977
13978 return -1;
13979 }
13980 }
13981
13982 #else
13983
13984 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, install_dir, module_file);
13985
13986 if (stat (module_file, &st) == -1)
13987 {
13988 log_error ("ERROR: %s: %s", module_file, strerror (errno));
13989
13990 return -1;
13991 }
13992
13993 #endif
13994
13995 char module_mp_file[256];
13996
13997 memset (module_mp_file, 0, sizeof (module_mp_file));
13998
13999 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
14000 {
14001 #ifdef __x86_64__
14002 snprintf (module_mp_file, sizeof (module_mp_file) - 1, "%s/kernels/4318/markov_be_v%d.sm_%d%d.64.cubin", install_dir, gpu_vector_width, sm_major, sm_minor);
14003 #else
14004 snprintf (module_mp_file, sizeof (module_mp_file) - 1, "%s/kernels/4318/markov_be_v%d.sm_%d%d.32.cubin", install_dir, gpu_vector_width, sm_major, sm_minor);
14005 #endif
14006 }
14007 else
14008 {
14009 #ifdef __x86_64__
14010 snprintf (module_mp_file, sizeof (module_mp_file) - 1, "%s/kernels/4318/markov_le_v%d.sm_%d%d.64.cubin", install_dir, gpu_vector_width, sm_major, sm_minor);
14011 #else
14012 snprintf (module_mp_file, sizeof (module_mp_file) - 1, "%s/kernels/4318/markov_le_v%d.sm_%d%d.32.cubin", install_dir, gpu_vector_width, sm_major, sm_minor);
14013 #endif
14014 }
14015
14016 char module_amp_file[256];
14017
14018 memset (module_amp_file, 0, sizeof (module_amp_file));
14019
14020 #ifdef __x86_64__
14021 snprintf (module_amp_file, sizeof (module_amp_file) - 1, "%s/kernels/4318/amp_a%d_v%d.sm_%d%d.64.cubin", install_dir, attack_kern, gpu_vector_width, sm_major, sm_minor);
14022 #else
14023 snprintf (module_amp_file, sizeof (module_amp_file) - 1, "%s/kernels/4318/amp_a%d_v%d.sm_%d%d.32.cubin", install_dir, attack_kern, gpu_vector_width, sm_major, sm_minor);
14024 #endif
14025
14026 /**
14027 * module load
14028 */
14029
14030 hc_cuModuleLoad (&device_param->module, module_file);
14031
14032 if (quiet == 0) log_info ("Device #%u: Kernel %s", device_id + 1, module_file);
14033
14034 if (attack_mode != ATTACK_MODE_STRAIGHT)
14035 {
14036 hc_cuModuleLoad (&device_param->module_mp, module_mp_file);
14037
14038 if (quiet == 0) log_info ("Device #%u: Kernel %s", device_id + 1, module_mp_file);
14039 }
14040
14041 if (attack_exec == ATTACK_EXEC_ON_GPU)
14042 {
14043 // nothing to do
14044 }
14045 else
14046 {
14047 hc_cuModuleLoad (&device_param->module_amp, module_amp_file);
14048
14049 if (quiet == 0) log_info ("Device #%u: Kernel %s", device_id + 1, module_amp_file);
14050 }
14051
14052 /**
14053 * module functions
14054 */
14055
14056 char module_name[64];
14057
14058 memset (module_name, 0, sizeof (module_name));
14059
14060 if (attack_exec == ATTACK_EXEC_ON_GPU)
14061 {
14062 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14063 {
14064 snprintf (module_name, sizeof (module_name) - 1, "m%05d_s%02d", kern_type, 4);
14065
14066 hc_cuModuleGetFunction (&device_param->function1, device_param->module, module_name);
14067
14068 snprintf (module_name, sizeof (module_name) - 1, "m%05d_s%02d", kern_type, 8);
14069
14070 hc_cuModuleGetFunction (&device_param->function2, device_param->module, module_name);
14071
14072 snprintf (module_name, sizeof (module_name) - 1, "m%05d_s%02d", kern_type, 16);
14073
14074 hc_cuModuleGetFunction (&device_param->function3, device_param->module, module_name);
14075 }
14076 else
14077 {
14078 snprintf (module_name, sizeof (module_name) - 1, "m%05d_m%02d", kern_type, 4);
14079
14080 hc_cuModuleGetFunction (&device_param->function1, device_param->module, module_name);
14081
14082 snprintf (module_name, sizeof (module_name) - 1, "m%05d_m%02d", kern_type, 8);
14083
14084 hc_cuModuleGetFunction (&device_param->function2, device_param->module, module_name);
14085
14086 snprintf (module_name, sizeof (module_name) - 1, "m%05d_m%02d", kern_type, 16);
14087
14088 hc_cuModuleGetFunction (&device_param->function3, device_param->module, module_name);
14089 }
14090
14091 if (attack_mode == ATTACK_MODE_BF)
14092 {
14093 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14094 {
14095 snprintf (module_name, sizeof (module_name) - 1, "m%05d_tb", kern_type);
14096
14097 hc_cuModuleGetFunction (&device_param->function_tb, device_param->module, module_name);
14098
14099 snprintf (module_name, sizeof (module_name) - 1, "m%05d_tm", kern_type);
14100
14101 hc_cuModuleGetFunction (&device_param->function_tm, device_param->module, module_name);
14102 }
14103 }
14104 }
14105 else
14106 {
14107 snprintf (module_name, sizeof (module_name) - 1, "m%05d_init", kern_type);
14108
14109 hc_cuModuleGetFunction (&device_param->function1, device_param->module, module_name);
14110
14111 snprintf (module_name, sizeof (module_name) - 1, "m%05d_loop", kern_type);
14112
14113 hc_cuModuleGetFunction (&device_param->function2, device_param->module, module_name);
14114
14115 snprintf (module_name, sizeof (module_name) - 1, "m%05d_comp", kern_type);
14116
14117 hc_cuModuleGetFunction (&device_param->function3, device_param->module, module_name);
14118
14119 if (opts_type & OPTS_TYPE_HOOK12)
14120 {
14121 snprintf (module_name, sizeof (module_name) - 1, "m%05d_hook12", kern_type);
14122
14123 hc_cuModuleGetFunction (&device_param->function12, device_param->module, module_name);
14124 }
14125
14126 if (opts_type & OPTS_TYPE_HOOK23)
14127 {
14128 snprintf (module_name, sizeof (module_name) - 1, "m%05d_hook23", kern_type);
14129
14130 hc_cuModuleGetFunction (&device_param->function23, device_param->module, module_name);
14131 }
14132 }
14133
14134 if (attack_mode == ATTACK_MODE_BF)
14135 {
14136 hc_cuModuleGetFunction (&device_param->function_mp_l, device_param->module_mp, "l_markov");
14137 hc_cuModuleGetFunction (&device_param->function_mp_r, device_param->module_mp, "r_markov");
14138 }
14139 else if (attack_mode == ATTACK_MODE_HYBRID1)
14140 {
14141 hc_cuModuleGetFunction (&device_param->function_mp, device_param->module_mp, "C_markov");
14142 }
14143 else if (attack_mode == ATTACK_MODE_HYBRID2)
14144 {
14145 hc_cuModuleGetFunction (&device_param->function_mp, device_param->module_mp, "C_markov");
14146 }
14147
14148 /**
14149 * amplifiers are not independant
14150 */
14151
14152 if (attack_exec == ATTACK_EXEC_ON_GPU)
14153 {
14154 // nothing to do
14155 }
14156 else
14157 {
14158 hc_cuModuleGetFunction (&device_param->function_amp, device_param->module_amp, "amp");
14159 }
14160
14161 /**
14162 * global buffers
14163 */
14164
14165 hc_cuMemAlloc (&device_param->d_pws_buf, size_pws);
14166 hc_cuMemAlloc (&device_param->d_pws_amp_buf, size_pws);
14167 hc_cuMemAlloc (&device_param->d_tmps, size_tmps);
14168 hc_cuMemAlloc (&device_param->d_hooks, size_hooks);
14169 hc_cuMemAlloc (&device_param->d_bitmap_s1_a, bitmap_size);
14170 hc_cuMemAlloc (&device_param->d_bitmap_s1_b, bitmap_size);
14171 hc_cuMemAlloc (&device_param->d_bitmap_s1_c, bitmap_size);
14172 hc_cuMemAlloc (&device_param->d_bitmap_s1_d, bitmap_size);
14173 hc_cuMemAlloc (&device_param->d_bitmap_s2_a, bitmap_size);
14174 hc_cuMemAlloc (&device_param->d_bitmap_s2_b, bitmap_size);
14175 hc_cuMemAlloc (&device_param->d_bitmap_s2_c, bitmap_size);
14176 hc_cuMemAlloc (&device_param->d_bitmap_s2_d, bitmap_size);
14177 hc_cuMemAlloc (&device_param->d_plain_bufs, size_plains);
14178 hc_cuMemAlloc (&device_param->d_digests_buf, size_digests);
14179 hc_cuMemAlloc (&device_param->d_digests_shown, size_shown);
14180 hc_cuMemAlloc (&device_param->d_salt_bufs, size_salts);
14181 hc_cuMemAlloc (&device_param->d_result, size_results);
14182 hc_cuMemAlloc (&device_param->d_scryptV_buf, size_scryptV);
14183
14184 hc_cuMemcpyHtoD (device_param->d_bitmap_s1_a, bitmap_s1_a, bitmap_size);
14185 hc_cuMemcpyHtoD (device_param->d_bitmap_s1_b, bitmap_s1_b, bitmap_size);
14186 hc_cuMemcpyHtoD (device_param->d_bitmap_s1_c, bitmap_s1_c, bitmap_size);
14187 hc_cuMemcpyHtoD (device_param->d_bitmap_s1_d, bitmap_s1_d, bitmap_size);
14188 hc_cuMemcpyHtoD (device_param->d_bitmap_s2_a, bitmap_s2_a, bitmap_size);
14189 hc_cuMemcpyHtoD (device_param->d_bitmap_s2_b, bitmap_s2_b, bitmap_size);
14190 hc_cuMemcpyHtoD (device_param->d_bitmap_s2_c, bitmap_s2_c, bitmap_size);
14191 hc_cuMemcpyHtoD (device_param->d_bitmap_s2_d, bitmap_s2_d, bitmap_size);
14192 hc_cuMemcpyHtoD (device_param->d_digests_buf, data.digests_buf, size_digests);
14193 hc_cuMemcpyHtoD (device_param->d_digests_shown, data.digests_shown, size_shown);
14194 hc_cuMemcpyHtoD (device_param->d_salt_bufs, data.salts_buf, size_salts);
14195
14196 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14197 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14198 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14199 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14200 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14201 run_kernel_bzero (device_param, device_param->d_result, size_results);
14202
14203 /**
14204 * special buffers
14205 */
14206
14207 if (attack_kern == ATTACK_KERN_STRAIGHT)
14208 {
14209 hc_cuMemAlloc (&device_param->d_rules, size_rules);
14210
14211 hc_cuMemcpyHtoD (device_param->d_rules, gpu_rules_buf, size_rules);
14212 }
14213 else if (attack_kern == ATTACK_KERN_COMBI)
14214 {
14215 hc_cuMemAlloc (&device_param->d_combs, size_combs);
14216 hc_cuMemAlloc (&device_param->d_root_css_buf, size_root_css);
14217 hc_cuMemAlloc (&device_param->d_markov_css_buf, size_markov_css);
14218
14219 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14220 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14221 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14222 }
14223 else if (attack_kern == ATTACK_KERN_BF)
14224 {
14225 hc_cuMemAlloc (&device_param->d_bfs, size_bfs);
14226 hc_cuMemAlloc (&device_param->d_tm, size_tm);
14227 hc_cuMemAlloc (&device_param->d_root_css_buf, size_root_css);
14228 hc_cuMemAlloc (&device_param->d_markov_css_buf, size_markov_css);
14229
14230 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14231 run_kernel_bzero (device_param, device_param->d_tm, size_tm);
14232 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14233 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14234 }
14235
14236 if (size_esalts)
14237 {
14238 hc_cuMemAlloc (&device_param->d_esalt_bufs, size_esalts);
14239
14240 hc_cuMemcpyHtoD (device_param->d_esalt_bufs, data.esalts_buf, size_esalts);
14241 }
14242
14243 /**
14244 * main host data
14245 */
14246
14247 uint *result = (uint *) mymalloc (size_results);
14248
14249 memset (result, 0, size_results);
14250
14251 device_param->result = result;
14252
14253 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14254
14255 memset (pws_buf, 0, size_pws);
14256
14257 device_param->pws_buf = pws_buf;
14258
14259 pw_cache_t *pw_caches = (pw_cache_t *) mycalloc (64, sizeof (pw_cache_t));
14260
14261 for (int i = 0; i < 64; i++)
14262 {
14263 pw_caches[i].pw_buf.pw_len = i;
14264 pw_caches[i].cnt = 0;
14265 }
14266
14267 device_param->pw_caches = pw_caches;
14268
14269 comb_t *combs_buf = (comb_t *) mycalloc (GPU_COMBS, sizeof (comb_t));
14270
14271 device_param->combs_buf = combs_buf;
14272
14273 void *hooks_buf = mymalloc (size_hooks);
14274
14275 device_param->hooks_buf = hooks_buf;
14276
14277 switch (device_param->gpu_vector_width)
14278 {
14279 case 1: device_param->pw_transpose = pw_transpose_to_hi1;
14280 device_param->pw_add = pw_add_to_hc1;
14281 break;
14282 case 2: device_param->pw_transpose = pw_transpose_to_hi2;
14283 device_param->pw_add = pw_add_to_hc2;
14284 break;
14285 case 4: device_param->pw_transpose = pw_transpose_to_hi4;
14286 device_param->pw_add = pw_add_to_hc4;
14287 break;
14288 }
14289
14290 /**
14291 * module args
14292 */
14293
14294 device_param->kernel_params_buf32[21] = bitmap_mask;
14295 device_param->kernel_params_buf32[22] = bitmap_shift1;
14296 device_param->kernel_params_buf32[23] = bitmap_shift2;
14297 device_param->kernel_params_buf32[24] = 0; // salt_pos
14298 device_param->kernel_params_buf32[25] = 0; // loop_pos
14299 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14300 device_param->kernel_params_buf32[27] = 0; // gpu_rules_cnt
14301 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14302 device_param->kernel_params_buf32[29] = 0; // digests_offset
14303 device_param->kernel_params_buf32[30] = 0; // combs_mode
14304 device_param->kernel_params_buf32[31] = 0; // gid_max
14305
14306 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_ON_GPU)
14307 ? &device_param->d_pws_buf
14308 : &device_param->d_pws_amp_buf;
14309 device_param->kernel_params[ 1] = &device_param->d_rules;
14310 device_param->kernel_params[ 2] = &device_param->d_combs;
14311 device_param->kernel_params[ 3] = &device_param->d_bfs;
14312 device_param->kernel_params[ 4] = &device_param->d_tmps;
14313 device_param->kernel_params[ 5] = &device_param->d_hooks;
14314 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14315 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14316 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14317 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14318 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14319 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14320 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14321 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14322 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14323 device_param->kernel_params[15] = &device_param->d_digests_buf;
14324 device_param->kernel_params[16] = &device_param->d_digests_shown;
14325 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14326 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14327 device_param->kernel_params[19] = &device_param->d_result;
14328 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14329 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14330 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14331 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14332 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14333 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14334 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14335 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14336 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14337 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14338 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14339 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14340
14341 device_param->kernel_params_mp_buf64[3] = 0;
14342 device_param->kernel_params_mp_buf32[4] = 0;
14343 device_param->kernel_params_mp_buf32[5] = 0;
14344 device_param->kernel_params_mp_buf32[6] = 0;
14345 device_param->kernel_params_mp_buf32[7] = 0;
14346 device_param->kernel_params_mp_buf32[8] = 0;
14347
14348 device_param->kernel_params_mp[0] = NULL;
14349 device_param->kernel_params_mp[1] = NULL;
14350 device_param->kernel_params_mp[2] = NULL;
14351 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14352 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14353 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14354 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14355 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14356 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14357
14358 device_param->kernel_params_mp_l_buf64[3] = 0;
14359 device_param->kernel_params_mp_l_buf32[4] = 0;
14360 device_param->kernel_params_mp_l_buf32[5] = 0;
14361 device_param->kernel_params_mp_l_buf32[6] = 0;
14362 device_param->kernel_params_mp_l_buf32[7] = 0;
14363 device_param->kernel_params_mp_l_buf32[8] = 0;
14364 device_param->kernel_params_mp_l_buf32[9] = 0;
14365
14366 device_param->kernel_params_mp_l[0] = NULL;
14367 device_param->kernel_params_mp_l[1] = NULL;
14368 device_param->kernel_params_mp_l[2] = NULL;
14369 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14370 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14371 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14372 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14373 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14374 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14375 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14376
14377 device_param->kernel_params_mp_r_buf64[3] = 0;
14378 device_param->kernel_params_mp_r_buf32[4] = 0;
14379 device_param->kernel_params_mp_r_buf32[5] = 0;
14380 device_param->kernel_params_mp_r_buf32[6] = 0;
14381 device_param->kernel_params_mp_r_buf32[7] = 0;
14382 device_param->kernel_params_mp_r_buf32[8] = 0;
14383
14384 device_param->kernel_params_mp_r[0] = NULL;
14385 device_param->kernel_params_mp_r[1] = NULL;
14386 device_param->kernel_params_mp_r[2] = NULL;
14387 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14388 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14389 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14390 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14391 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14392 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14393
14394 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14395 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14396
14397 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14398 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14399 device_param->kernel_params_amp[2] = &device_param->d_rules;
14400 device_param->kernel_params_amp[3] = &device_param->d_combs;
14401 device_param->kernel_params_amp[4] = &device_param->d_bfs;
14402 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14403 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14404
14405 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
14406
14407 device_param->kernel_params_tm[0] = &device_param->d_bfs;
14408 device_param->kernel_params_tm[1] = &device_param->d_tm;
14409
14410 /* constant memory init */
14411
14412 CUmodule c_module;
14413
14414 if (attack_exec == ATTACK_EXEC_ON_GPU)
14415 {
14416 c_module = device_param->module;
14417 }
14418 else
14419 {
14420 c_module = device_param->module_amp;
14421 }
14422
14423 size_t c_bytes;
14424
14425 if (attack_kern == ATTACK_KERN_STRAIGHT)
14426 {
14427 CUdeviceptr c_rules;
14428
14429 hc_cuModuleGetGlobal (&c_rules, &c_bytes, c_module, "c_rules");
14430
14431 device_param->c_rules = c_rules;
14432 device_param->c_bytes = c_bytes;
14433
14434 hc_cuMemsetD8 (c_rules, 0, c_bytes);
14435 }
14436 else if (attack_kern == ATTACK_KERN_COMBI)
14437 {
14438 CUdeviceptr c_combs;
14439
14440 hc_cuModuleGetGlobal (&c_combs, &c_bytes, c_module, "c_combs");
14441
14442 device_param->c_combs = c_combs;
14443 device_param->c_bytes = c_bytes;
14444
14445 hc_cuMemsetD8 (c_combs, 0, c_bytes);
14446 }
14447 else if (attack_kern == ATTACK_KERN_BF)
14448 {
14449 CUdeviceptr c_bfs;
14450
14451 hc_cuModuleGetGlobal (&c_bfs, &c_bytes, c_module, "c_bfs");
14452
14453 device_param->c_bfs = c_bfs;
14454 device_param->c_bytes = c_bytes;
14455
14456 hc_cuMemsetD8 (c_bfs, 0, c_bytes);
14457
14458 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
14459 {
14460 size_t bytes;
14461
14462 CUdeviceptr c_tm;
14463
14464 hc_cuModuleGetGlobal (&c_tm, &bytes, c_module, "c_tm");
14465
14466 device_param->c_tm = c_tm;
14467
14468 hc_cuMemsetD8 (c_tm, 0, bytes);
14469 }
14470 }
14471
14472 hc_cuCtxPopCurrent (NULL);
14473 }
14474
14475 #elif _OCL
14476 for (uint device_id = 0; device_id < devices_cnt; device_id++)
14477 {
14478 /**
14479 * host buffer
14480 */
14481
14482 hc_device_param_t *device_param = &data.devices_param[device_id];
14483
14484 /**
14485 * device properties
14486 */
14487
14488 char *device_name = device_param->device_name;
14489 char *device_version = device_param->device_version;
14490 char *driver_version = device_param->driver_version;
14491
14492 uint gpu_processors = device_param->gpu_processors;
14493 uint gpu_vector_width = device_param->gpu_vector_width;
14494
14495 /**
14496 * create context for each device
14497 */
14498
14499 device_param->context = hc_clCreateContext (NULL, 1, &device_param->device, NULL, NULL);
14500
14501 /**
14502 * create command-queue
14503 */
14504
14505 device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14506
14507 /**
14508 * create input buffers on device
14509 */
14510
14511 uint gpu_threads = GPU_THREADS_AMD;
14512
14513 if (hash_mode == 3200) gpu_threads = 8;
14514 if (hash_mode == 9000) gpu_threads = 8;
14515
14516 uint gpu_power = gpu_processors * gpu_threads * gpu_accel;
14517
14518 uint gpu_blocks = gpu_power * gpu_vector_width;
14519
14520 device_param->gpu_threads = gpu_threads;
14521 device_param->gpu_power_user = gpu_power;
14522 device_param->gpu_blocks_user = gpu_blocks;
14523
14524 gpu_blocks_all += gpu_blocks;
14525
14526 uint size_pws = gpu_power * sizeof (pw_t);
14527
14528 uint size_tmps = 4;
14529
14530 switch (hash_mode)
14531 {
14532 case 400: size_tmps = gpu_blocks * sizeof (phpass_tmp_t); break;
14533 case 500: size_tmps = gpu_blocks * sizeof (md5crypt_tmp_t); break;
14534 case 501: size_tmps = gpu_blocks * sizeof (md5crypt_tmp_t); break;
14535 case 1600: size_tmps = gpu_blocks * sizeof (md5crypt_tmp_t); break;
14536 case 1800: size_tmps = gpu_blocks * sizeof (sha512crypt_tmp_t); break;
14537 case 2100: size_tmps = gpu_blocks * sizeof (dcc2_tmp_t); break;
14538 case 2500: size_tmps = gpu_blocks * sizeof (wpa_tmp_t); break;
14539 case 3200: size_tmps = gpu_blocks * sizeof (bcrypt_tmp_t); break;
14540 case 5200: size_tmps = gpu_blocks * sizeof (pwsafe3_tmp_t); break;
14541 case 5800: size_tmps = gpu_blocks * sizeof (androidpin_tmp_t); break;
14542 case 6211:
14543 case 6212:
14544 case 6213: size_tmps = gpu_blocks * sizeof (tc_tmp_t); break;
14545 case 6221:
14546 case 6222:
14547 case 6223: size_tmps = gpu_blocks * sizeof (tc64_tmp_t); break;
14548 case 6231:
14549 case 6232:
14550 case 6233: size_tmps = gpu_blocks * sizeof (tc_tmp_t); break;
14551 case 6241:
14552 case 6242:
14553 case 6243: size_tmps = gpu_blocks * sizeof (tc_tmp_t); break;
14554 case 6300: size_tmps = gpu_blocks * sizeof (md5crypt_tmp_t); break;
14555 case 6400: size_tmps = gpu_blocks * sizeof (sha256aix_tmp_t); break;
14556 case 6500: size_tmps = gpu_blocks * sizeof (sha512aix_tmp_t); break;
14557 case 6600: size_tmps = gpu_blocks * sizeof (agilekey_tmp_t); break;
14558 case 6700: size_tmps = gpu_blocks * sizeof (sha1aix_tmp_t); break;
14559 case 6800: size_tmps = gpu_blocks * sizeof (lastpass_tmp_t); break;
14560 case 7100: size_tmps = gpu_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
14561 case 7200: size_tmps = gpu_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
14562 case 7400: size_tmps = gpu_blocks * sizeof (sha256crypt_tmp_t); break;
14563 case 7900: size_tmps = gpu_blocks * sizeof (drupal7_tmp_t); break;
14564 case 8200: size_tmps = gpu_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
14565 case 8800: size_tmps = gpu_blocks * sizeof (androidfde_tmp_t); break;
14566 case 8900: size_tmps = gpu_blocks * sizeof (scrypt_tmp_t); break;
14567 case 9000: size_tmps = gpu_blocks * sizeof (pwsafe2_tmp_t); break;
14568 case 9100: size_tmps = gpu_blocks * sizeof (lotus8_tmp_t); break;
14569 case 9200: size_tmps = gpu_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
14570 case 9300: size_tmps = gpu_blocks * sizeof (scrypt_tmp_t); break;
14571 case 9400: size_tmps = gpu_blocks * sizeof (office2007_tmp_t); break;
14572 case 9500: size_tmps = gpu_blocks * sizeof (office2010_tmp_t); break;
14573 case 9600: size_tmps = gpu_blocks * sizeof (office2013_tmp_t); break;
14574 case 10000: size_tmps = gpu_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
14575 case 10200: size_tmps = gpu_blocks * sizeof (cram_md5_t); break;
14576 case 10300: size_tmps = gpu_blocks * sizeof (saph_sha1_tmp_t); break;
14577 case 10500: size_tmps = gpu_blocks * sizeof (pdf14_tmp_t); break;
14578 case 10700: size_tmps = gpu_blocks * sizeof (pdf17l8_tmp_t); break;
14579 case 10900: size_tmps = gpu_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
14580 case 11300: size_tmps = gpu_blocks * sizeof (bitcoin_wallet_tmp_t); break;
14581 case 11600: size_tmps = gpu_blocks * sizeof (seven_zip_tmp_t); break;
14582 case 11900: size_tmps = gpu_blocks * sizeof (pbkdf2_md5_tmp_t); break;
14583 case 12000: size_tmps = gpu_blocks * sizeof (pbkdf2_sha1_tmp_t); break;
14584 case 12100: size_tmps = gpu_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
14585 case 12200: size_tmps = gpu_blocks * sizeof (ecryptfs_tmp_t); break;
14586 case 12300: size_tmps = gpu_blocks * sizeof (oraclet_tmp_t); break;
14587 case 12400: size_tmps = gpu_blocks * sizeof (bsdicrypt_tmp_t); break;
14588 case 12500: size_tmps = gpu_blocks * sizeof (rar3_tmp_t); break;
14589 case 12700: size_tmps = gpu_blocks * sizeof (mywallet_tmp_t); break;
14590 case 12800: size_tmps = gpu_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
14591 };
14592
14593 uint size_hooks = 4;
14594
14595 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
14596 {
14597 // insert correct hook size
14598 }
14599
14600 // we can optimize some stuff here...
14601
14602 device_param->size_pws = size_pws;
14603 device_param->size_tmps = size_tmps;
14604 device_param->size_hooks = size_hooks;
14605
14606 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
14607 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
14608
14609 device_param->size_root_css = size_root_css;
14610 device_param->size_markov_css = size_markov_css;
14611
14612 uint size_results = GPU_THREADS_AMD * sizeof (uint);
14613
14614 device_param->size_results = size_results;
14615
14616 uint size_rules = gpu_rules_cnt * sizeof (gpu_rule_t);
14617 uint size_rules_c = GPU_RULES * sizeof (gpu_rule_t);
14618 uint size_plains = digests_cnt * sizeof (plain_t);
14619 uint size_salts = salts_cnt * sizeof (salt_t);
14620 uint size_esalts = salts_cnt * esalt_size;
14621
14622 device_param->size_plains = size_plains;
14623 device_param->size_digests = size_digests;
14624 device_param->size_shown = size_shown;
14625 device_param->size_salts = size_salts;
14626
14627 uint size_combs = GPU_COMBS * sizeof (comb_t);
14628 uint size_bfs = GPU_BFS * sizeof (bf_t);
14629 uint size_tm = 32 * sizeof (bs_word_t);
14630
14631 uint64_t size_scryptV = 1;
14632
14633 if ((hash_mode == 8900) || (hash_mode == 9300))
14634 {
14635 #define SHADER_PER_MP 8
14636 #define WAVEFRONTS 64
14637
14638 uint tmto_start = 2;
14639 uint tmto_stop = 1024;
14640
14641 if (scrypt_tmto)
14642 {
14643 tmto_start = 1 << scrypt_tmto;
14644 tmto_stop = tmto_start + 1;
14645 }
14646
14647 for (uint tmto = tmto_start; tmto < tmto_stop; tmto <<= 1)
14648 {
14649 // todo -- make sure all salts get the new tmto value
14650
14651 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
14652
14653 size_scryptV /= tmto;
14654
14655 size_scryptV *= gpu_processors * WAVEFRONTS * SHADER_PER_MP;
14656
14657 if (size_scryptV > (device_param->gpu_maxmem_alloc / 2)) continue;
14658
14659 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
14660 {
14661 data.salts_buf[salts_pos].scrypt_tmto = tmto;
14662 data.salts_buf[salts_pos].scrypt_phy = gpu_processors * WAVEFRONTS * SHADER_PER_MP;
14663 }
14664
14665 break;
14666 }
14667
14668 if (data.salts_buf[0].scrypt_tmto == 0)
14669 {
14670 log_error ("ERROR: can't allocate enough GPU memory");
14671
14672 return -1;
14673 }
14674
14675 if (quiet == 0) log_info ("");
14676 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u\n", data.salts_buf[0].scrypt_tmto);
14677 }
14678
14679 /**
14680 * kernel find
14681 */
14682
14683 uint vliw = get_vliw_by_device_name (device_name);
14684
14685 struct stat st;
14686
14687 char kernel_file[256];
14688
14689 memset (kernel_file, 0, sizeof (kernel_file));
14690
14691 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14692
14693 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
14694
14695 #ifdef BINARY_KERNEL
14696 if (force_jit_compilation == 0)
14697 {
14698 if (attack_exec == ATTACK_EXEC_ON_GPU)
14699 {
14700 if (attack_kern == ATTACK_KERN_STRAIGHT)
14701 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);
14702 else if (attack_kern == ATTACK_KERN_COMBI)
14703 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);
14704 else if (attack_kern == ATTACK_KERN_BF)
14705 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);
14706 }
14707 else
14708 {
14709 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);
14710
14711 if ((hash_mode == 8900) || (hash_mode == 9300))
14712 {
14713 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);
14714 }
14715 }
14716
14717 if (stat (kernel_file, &st) == -1)
14718 {
14719 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, kernel_file);
14720
14721 char module_file[256];
14722
14723 memset (module_file, 0, sizeof (module_file));
14724
14725 if (attack_exec == ATTACK_EXEC_ON_GPU)
14726 {
14727 if (attack_kern == ATTACK_KERN_STRAIGHT)
14728 snprintf (module_file, sizeof (module_file) - 1, "%s/kernels/4098/m%05d_a0.VLIW%d.llvmir", install_dir, (int) kern_type, vliw);
14729 else if (attack_kern == ATTACK_KERN_COMBI)
14730 snprintf (module_file, sizeof (module_file) - 1, "%s/kernels/4098/m%05d_a1.VLIW%d.llvmir", install_dir, (int) kern_type, vliw);
14731 else if (attack_kern == ATTACK_KERN_BF)
14732 snprintf (module_file, sizeof (module_file) - 1, "%s/kernels/4098/m%05d_a3.VLIW%d.llvmir", install_dir, (int) kern_type, vliw);
14733 }
14734 else
14735 {
14736 snprintf (module_file, sizeof (module_file) - 1, "%s/kernels/4098/m%05d.VLIW%d.llvmir", install_dir, (int) kern_type, vliw);
14737
14738 if ((hash_mode == 8900) || (hash_mode == 9300))
14739 {
14740 snprintf (module_file, sizeof (module_file) - 1, "%s/kernels/4098/m%05d_%d_%d_%d_%d.VLIW%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, vliw);
14741 }
14742 }
14743
14744 load_kernel (module_file, 1, kernel_lengths, kernel_sources);
14745
14746 cl_program program = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
14747
14748 local_free (kernel_sources[0]);
14749
14750 hc_clBuildProgram (program, 1, &device_param->device, "-cl-std=CL1.2", NULL, NULL);
14751
14752 size_t binary_size;
14753
14754 clGetProgramInfo (program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14755
14756 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
14757
14758 clGetProgramInfo (program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14759
14760 writeProgramBin (kernel_file, binary, binary_size);
14761
14762 local_free (binary);
14763
14764 stat (kernel_file, &st); // to reload filesize
14765 }
14766 }
14767 else
14768 {
14769 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, install_dir, kernel_file);
14770
14771 if (stat (kernel_file, &st) == -1)
14772 {
14773 log_error ("ERROR: %s: %s", kernel_file, strerror (errno));
14774
14775 return -1;
14776 }
14777 }
14778
14779 #else
14780
14781 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, install_dir, kernel_file);
14782
14783 if (stat (kernel_file, &st) == -1)
14784 {
14785 log_error ("ERROR: %s: %s", kernel_file, strerror (errno));
14786
14787 return -1;
14788 }
14789
14790 #endif
14791
14792 load_kernel (kernel_file, 1, kernel_lengths, kernel_sources);
14793
14794 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, kernel_file, st.st_size);
14795
14796 #ifdef BINARY_KERNEL
14797 if (force_jit_compilation == 0)
14798 {
14799 device_param->program = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
14800 }
14801 else
14802 {
14803 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
14804 }
14805 #else
14806 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
14807 #endif
14808
14809 local_free (kernel_lengths);
14810
14811 local_free (kernel_sources[0]);
14812
14813 local_free (kernel_sources)
14814
14815 /**
14816 * kernel mp find
14817 */
14818
14819 if (attack_mode != ATTACK_MODE_STRAIGHT)
14820 {
14821 char kernel_mp_file[256];
14822
14823 memset (kernel_mp_file, 0, sizeof (kernel_mp_file));
14824
14825 size_t *kernel_mp_lengths = (size_t *) mymalloc (sizeof (size_t));
14826
14827 const unsigned char **kernel_mp_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
14828
14829 #ifdef BINARY_KERNEL
14830 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
14831 {
14832 snprintf (kernel_mp_file, sizeof (kernel_mp_file) - 1, "%s/kernels/4098/markov_be_v%d.%s_%s_%s_%d.kernel", install_dir, gpu_vector_width, device_name, device_version, driver_version, COMPTIME);
14833 }
14834 else
14835 {
14836 snprintf (kernel_mp_file, sizeof (kernel_mp_file) - 1, "%s/kernels/4098/markov_le_v%d.%s_%s_%s_%d.kernel", install_dir, gpu_vector_width, device_name, device_version, driver_version, COMPTIME);
14837 }
14838
14839 if (stat (kernel_mp_file, &st) == -1)
14840 {
14841 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, kernel_mp_file);
14842
14843 char module_mp_file[256];
14844
14845 memset (module_mp_file, 0, sizeof (module_mp_file));
14846
14847 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
14848 {
14849 snprintf (module_mp_file, sizeof (module_mp_file) - 1, "%s/kernels/4098/markov_be_v%d.llvmir", install_dir, gpu_vector_width);
14850 }
14851 else
14852 {
14853 snprintf (module_mp_file, sizeof (module_mp_file) - 1, "%s/kernels/4098/markov_le_v%d.llvmir", install_dir, gpu_vector_width);
14854 }
14855
14856 load_kernel (module_mp_file, 1, kernel_mp_lengths, kernel_mp_sources);
14857
14858 cl_program program_mp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_mp_lengths, (const unsigned char **) kernel_mp_sources, NULL);
14859
14860 local_free (kernel_mp_sources[0]);
14861
14862 hc_clBuildProgram (program_mp, 1, &device_param->device, "-cl-std=CL1.2", NULL, NULL);
14863
14864 size_t binary_mp_size;
14865
14866 clGetProgramInfo (program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_mp_size, NULL);
14867
14868 unsigned char *binary_mp = (unsigned char *) mymalloc (binary_mp_size);
14869
14870 clGetProgramInfo (program_mp, CL_PROGRAM_BINARIES, sizeof (binary_mp), &binary_mp, NULL);
14871
14872 writeProgramBin (kernel_mp_file, binary_mp, binary_mp_size);
14873
14874 local_free (binary_mp);
14875
14876 stat (kernel_mp_file, &st); // to reload filesize
14877 }
14878
14879 #else
14880 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
14881 {
14882 snprintf (kernel_mp_file, sizeof (kernel_mp_file) - 1, "%s/amd/markov_be_v%d.cl", install_dir, gpu_vector_width);
14883 }
14884 else
14885 {
14886 snprintf (kernel_mp_file, sizeof (kernel_mp_file) - 1, "%s/amd/markov_le_v%d.cl", install_dir, gpu_vector_width);
14887 }
14888
14889 if (stat (kernel_mp_file, &st) == -1)
14890 {
14891 log_error ("ERROR: %s: %s", kernel_mp_file, strerror (errno));
14892
14893 return -1;
14894 }
14895
14896 #endif
14897
14898 load_kernel (kernel_mp_file, 1, kernel_mp_lengths, kernel_mp_sources);
14899
14900 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, kernel_mp_file, st.st_size);
14901
14902 #ifdef BINARY_KERNEL
14903 device_param->program_mp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_mp_lengths, (const unsigned char **) kernel_mp_sources, NULL);
14904 #else
14905 device_param->program_mp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_mp_sources, NULL);
14906 #endif
14907
14908 local_free (kernel_mp_lengths);
14909
14910 local_free (kernel_mp_sources[0]);
14911
14912 local_free (kernel_mp_sources);
14913 }
14914
14915 /**
14916 * kernel amp find
14917 */
14918
14919 if (attack_exec == ATTACK_EXEC_ON_GPU)
14920 {
14921 // nothing to do
14922 }
14923 else
14924 {
14925 char kernel_amp_file[256];
14926
14927 memset (kernel_amp_file, 0, sizeof (kernel_amp_file));
14928
14929 size_t *kernel_amp_lengths = (size_t *) mymalloc (sizeof (size_t));
14930
14931 const unsigned char **kernel_amp_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
14932
14933 #ifdef BINARY_KERNEL
14934 snprintf (kernel_amp_file, sizeof (kernel_amp_file) - 1, "%s/kernels/4098/amp_a%d_v%d.%s_%s_%s_%d.kernel", install_dir, attack_kern, gpu_vector_width, device_name, device_version, driver_version, COMPTIME);
14935
14936 if (stat (kernel_amp_file, &st) == -1)
14937 {
14938 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, kernel_amp_file);
14939
14940 char module_amp_file[256];
14941
14942 memset (module_amp_file, 0, sizeof (module_amp_file));
14943
14944 snprintf (module_amp_file, sizeof (module_amp_file) - 1, "%s/kernels/4098/amp_a%d_v%d.llvmir", install_dir, attack_kern, gpu_vector_width);
14945
14946 load_kernel (module_amp_file, 1, kernel_amp_lengths, kernel_amp_sources);
14947
14948 cl_program program_amp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_amp_lengths, (const unsigned char **) kernel_amp_sources, NULL);
14949
14950 local_free (kernel_amp_sources[0]);
14951
14952 hc_clBuildProgram (program_amp, 1, &device_param->device, "-cl-std=CL1.2", NULL, NULL);
14953
14954 size_t binary_amp_size;
14955
14956 clGetProgramInfo (program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_amp_size, NULL);
14957
14958 unsigned char *binary_amp = (unsigned char *) mymalloc (binary_amp_size);
14959
14960 clGetProgramInfo (program_amp, CL_PROGRAM_BINARIES, sizeof (binary_amp), &binary_amp, NULL);
14961
14962 writeProgramBin (kernel_amp_file, binary_amp, binary_amp_size);
14963
14964 local_free (binary_amp);
14965
14966 stat (kernel_amp_file, &st); // to reload filesize
14967 }
14968 #else
14969 snprintf (kernel_amp_file, sizeof (kernel_amp_file) - 1, "%s/amd/amp_a%d_v%d.cl", install_dir, attack_kern, gpu_vector_width);
14970
14971 if (stat (kernel_amp_file, &st) == -1)
14972 {
14973 log_error ("ERROR: %s: %s", kernel_amp_file, strerror (errno));
14974
14975 return -1;
14976 }
14977 #endif
14978
14979 load_kernel (kernel_amp_file, 1, kernel_amp_lengths, kernel_amp_sources);
14980
14981 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, kernel_amp_file, st.st_size);
14982
14983 #ifdef BINARY_KERNEL
14984 device_param->program_amp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_amp_lengths, (const unsigned char **) kernel_amp_sources, NULL);
14985 #else
14986 device_param->program_amp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_amp_sources, NULL);
14987 #endif
14988
14989 local_free (kernel_amp_lengths);
14990
14991 local_free (kernel_amp_sources[0]);
14992
14993 local_free (kernel_amp_sources);
14994 }
14995
14996 /**
14997 * kernel compile
14998 */
14999
15000 char *build_opts = NULL;
15001
15002 #ifdef BINARY_KERNEL
15003
15004 if (force_jit_compilation == 0)
15005 {
15006 // nothing to do
15007 }
15008 else if (force_jit_compilation == 1500)
15009 {
15010 build_opts = (char *) mymalloc (256);
15011
15012 sprintf (build_opts, "-I . -I amd/ -D VLIW%d -x clc++ -cl-std=CL1.2 -DDESCRYPT_SALT=%d", vliw, data.salts_buf[0].salt_buf[0]);
15013 }
15014 else if (force_jit_compilation == 8900)
15015 {
15016 build_opts = (char *) mymalloc (256);
15017
15018 sprintf (build_opts, "-I . -I amd/ -D VLIW%d -x clc++ -cl-std=CL1.2 -DSCRYPT_N=%d -DSCRYPT_R=%d -DSCRYPT_P=%d -DSCRYPT_TMTO=%d", vliw, data.salts_buf[0].scrypt_N, data.salts_buf[0].scrypt_r, data.salts_buf[0].scrypt_p, data.salts_buf[0].scrypt_tmto);
15019 }
15020
15021 #else
15022
15023 build_opts = (char *) mymalloc (256);
15024
15025 sprintf (build_opts, "-I . -I amd/ -D VLIW%d -x clc++ -cl-std=CL1.2", vliw);
15026
15027 #endif
15028
15029 clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
15030
15031 size_t ret_val_size = 0;
15032
15033 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
15034
15035 if (ret_val_size > 1)
15036 {
15037 char *build_log = (char *) malloc (ret_val_size + 1);
15038
15039 memset (build_log, 0, ret_val_size + 1);
15040
15041 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
15042
15043 puts (build_log);
15044
15045 free (build_log);
15046 }
15047
15048 if (attack_mode != ATTACK_MODE_STRAIGHT)
15049 {
15050 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
15051 }
15052
15053 if (attack_exec == ATTACK_EXEC_ON_GPU)
15054 {
15055 // nothing to do
15056 }
15057 else
15058 {
15059 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
15060 }
15061
15062 /**
15063 * amp is not independent
15064 */
15065
15066 if (attack_exec == ATTACK_EXEC_ON_GPU)
15067 {
15068 // nothing to do
15069 }
15070 else
15071 {
15072 device_param->kernel_amp = hc_clCreateKernel (device_param->program_amp, "amp");
15073 }
15074
15075 /**
15076 * global buffers
15077 */
15078
15079 device_param->d_pws_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15080 device_param->d_pws_amp_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15081 device_param->d_tmps = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
15082 device_param->d_hooks = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
15083 device_param->d_bitmap_s1_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15084 device_param->d_bitmap_s1_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15085 device_param->d_bitmap_s1_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15086 device_param->d_bitmap_s1_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15087 device_param->d_bitmap_s2_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15088 device_param->d_bitmap_s2_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15089 device_param->d_bitmap_s2_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15090 device_param->d_bitmap_s2_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15091 device_param->d_plain_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
15092 device_param->d_digests_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
15093 device_param->d_digests_shown = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
15094 device_param->d_salt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
15095 device_param->d_result = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
15096 device_param->d_scryptV_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
15097
15098 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_a, CL_TRUE, 0, bitmap_size, bitmap_s1_a, 0, NULL, NULL);
15099 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_b, CL_TRUE, 0, bitmap_size, bitmap_s1_b, 0, NULL, NULL);
15100 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_c, CL_TRUE, 0, bitmap_size, bitmap_s1_c, 0, NULL, NULL);
15101 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_d, CL_TRUE, 0, bitmap_size, bitmap_s1_d, 0, NULL, NULL);
15102 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_a, CL_TRUE, 0, bitmap_size, bitmap_s2_a, 0, NULL, NULL);
15103 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_b, CL_TRUE, 0, bitmap_size, bitmap_s2_b, 0, NULL, NULL);
15104 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_c, CL_TRUE, 0, bitmap_size, bitmap_s2_c, 0, NULL, NULL);
15105 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_d, CL_TRUE, 0, bitmap_size, bitmap_s2_d, 0, NULL, NULL);
15106 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
15107 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
15108 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
15109
15110 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
15111 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
15112 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
15113 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
15114 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
15115 run_kernel_bzero (device_param, device_param->d_result, size_results);
15116
15117 /**
15118 * special buffers
15119 */
15120
15121 if (attack_kern == ATTACK_KERN_STRAIGHT)
15122 {
15123 device_param->d_rules = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15124 device_param->d_rules_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15125
15126 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, gpu_rules_buf, 0, NULL, NULL);
15127
15128 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
15129 }
15130 else if (attack_kern == ATTACK_KERN_COMBI)
15131 {
15132 device_param->d_combs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15133 device_param->d_combs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15134 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15135 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15136
15137 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
15138 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
15139 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15140 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15141 }
15142 else if (attack_kern == ATTACK_KERN_BF)
15143 {
15144 device_param->d_bfs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15145 device_param->d_bfs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15146 device_param->d_tm_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15147 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15148 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15149
15150 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
15151 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
15152 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
15153 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15154 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15155 }
15156
15157 if (size_esalts)
15158 {
15159 device_param->d_esalt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15160
15161 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15162 }
15163
15164 /**
15165 * main host data
15166 */
15167
15168 uint *result = (uint *) mymalloc (size_results);
15169
15170 memset (result, 0, size_results);
15171
15172 device_param->result = result;
15173
15174 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15175
15176 memset (pws_buf, 0, size_pws);
15177
15178 device_param->pws_buf = pws_buf;
15179
15180 pw_cache_t *pw_caches = (pw_cache_t *) mycalloc (64, sizeof (pw_cache_t));
15181
15182 for (int i = 0; i < 64; i++)
15183 {
15184 pw_caches[i].pw_buf.pw_len = i;
15185 pw_caches[i].cnt = 0;
15186 }
15187
15188 device_param->pw_caches = pw_caches;
15189
15190 comb_t *combs_buf = (comb_t *) mycalloc (GPU_COMBS, sizeof (comb_t));
15191
15192 device_param->combs_buf = combs_buf;
15193
15194 void *hooks_buf = mymalloc (size_hooks);
15195
15196 device_param->hooks_buf = hooks_buf;
15197
15198 switch (device_param->gpu_vector_width)
15199 {
15200 case 1: device_param->pw_transpose = pw_transpose_to_hi1;
15201 device_param->pw_add = pw_add_to_hc1;
15202 break;
15203 case 2: device_param->pw_transpose = pw_transpose_to_hi2;
15204 device_param->pw_add = pw_add_to_hc2;
15205 break;
15206 case 4: device_param->pw_transpose = pw_transpose_to_hi4;
15207 device_param->pw_add = pw_add_to_hc4;
15208 break;
15209 }
15210
15211 /**
15212 * kernel args
15213 */
15214
15215 device_param->kernel_params_buf32[21] = bitmap_mask;
15216 device_param->kernel_params_buf32[22] = bitmap_shift1;
15217 device_param->kernel_params_buf32[23] = bitmap_shift2;
15218 device_param->kernel_params_buf32[24] = 0; // salt_pos
15219 device_param->kernel_params_buf32[25] = 0; // loop_pos
15220 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15221 device_param->kernel_params_buf32[27] = 0; // gpu_rules_cnt
15222 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15223 device_param->kernel_params_buf32[29] = 0; // digests_offset
15224 device_param->kernel_params_buf32[30] = 0; // combs_mode
15225 device_param->kernel_params_buf32[31] = 0; // gid_max
15226
15227 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_ON_GPU)
15228 ? &device_param->d_pws_buf
15229 : &device_param->d_pws_amp_buf;
15230 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15231 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15232 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15233 device_param->kernel_params[ 4] = &device_param->d_tmps;
15234 device_param->kernel_params[ 5] = &device_param->d_hooks;
15235 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15236 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15237 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15238 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15239 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15240 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15241 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15242 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15243 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15244 device_param->kernel_params[15] = &device_param->d_digests_buf;
15245 device_param->kernel_params[16] = &device_param->d_digests_shown;
15246 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15247 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15248 device_param->kernel_params[19] = &device_param->d_result;
15249 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15250 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15251 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15252 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15253 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15254 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15255 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15256 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15257 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15258 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15259 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15260 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15261
15262 device_param->kernel_params_mp_buf64[3] = 0;
15263 device_param->kernel_params_mp_buf32[4] = 0;
15264 device_param->kernel_params_mp_buf32[5] = 0;
15265 device_param->kernel_params_mp_buf32[6] = 0;
15266 device_param->kernel_params_mp_buf32[7] = 0;
15267 device_param->kernel_params_mp_buf32[8] = 0;
15268
15269 device_param->kernel_params_mp[0] = NULL;
15270 device_param->kernel_params_mp[1] = NULL;
15271 device_param->kernel_params_mp[2] = NULL;
15272 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15273 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15274 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15275 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15276 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15277 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15278
15279 device_param->kernel_params_mp_l_buf64[3] = 0;
15280 device_param->kernel_params_mp_l_buf32[4] = 0;
15281 device_param->kernel_params_mp_l_buf32[5] = 0;
15282 device_param->kernel_params_mp_l_buf32[6] = 0;
15283 device_param->kernel_params_mp_l_buf32[7] = 0;
15284 device_param->kernel_params_mp_l_buf32[8] = 0;
15285 device_param->kernel_params_mp_l_buf32[9] = 0;
15286
15287 device_param->kernel_params_mp_l[0] = NULL;
15288 device_param->kernel_params_mp_l[1] = NULL;
15289 device_param->kernel_params_mp_l[2] = NULL;
15290 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15291 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15292 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15293 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15294 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15295 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15296 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15297
15298 device_param->kernel_params_mp_r_buf64[3] = 0;
15299 device_param->kernel_params_mp_r_buf32[4] = 0;
15300 device_param->kernel_params_mp_r_buf32[5] = 0;
15301 device_param->kernel_params_mp_r_buf32[6] = 0;
15302 device_param->kernel_params_mp_r_buf32[7] = 0;
15303 device_param->kernel_params_mp_r_buf32[8] = 0;
15304
15305 device_param->kernel_params_mp_r[0] = NULL;
15306 device_param->kernel_params_mp_r[1] = NULL;
15307 device_param->kernel_params_mp_r[2] = NULL;
15308 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
15309 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
15310 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
15311 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
15312 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
15313 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
15314
15315 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
15316 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
15317
15318 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
15319 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
15320 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
15321 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
15322 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
15323 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
15324 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
15325
15326 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
15327
15328 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
15329 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
15330
15331 /**
15332 * kernel name
15333 */
15334
15335 char kernel_name[64];
15336
15337 memset (kernel_name, 0, sizeof (kernel_name));
15338
15339 if (attack_exec == ATTACK_EXEC_ON_GPU)
15340 {
15341 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15342 {
15343 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
15344
15345 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
15346
15347 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
15348
15349 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
15350
15351 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
15352
15353 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
15354 }
15355 else
15356 {
15357 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
15358
15359 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
15360
15361 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
15362
15363 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
15364
15365 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
15366
15367 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
15368 }
15369
15370 if (data.attack_mode == ATTACK_MODE_BF)
15371 {
15372 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15373 {
15374 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
15375
15376 device_param->kernel_tb = hc_clCreateKernel (device_param->program, kernel_name);
15377
15378 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
15379
15380 device_param->kernel_tm = hc_clCreateKernel (device_param->program, kernel_name);
15381 }
15382 }
15383 }
15384 else
15385 {
15386 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
15387
15388 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
15389
15390 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
15391
15392 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
15393
15394 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
15395
15396 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
15397
15398 if (opts_type & OPTS_TYPE_HOOK12)
15399 {
15400 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
15401
15402 device_param->kernel12 = hc_clCreateKernel (device_param->program, kernel_name);
15403 }
15404
15405 if (opts_type & OPTS_TYPE_HOOK23)
15406 {
15407 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
15408
15409 device_param->kernel23 = hc_clCreateKernel (device_param->program, kernel_name);
15410 }
15411 }
15412
15413 for (uint i = 0; i <= 20; i++)
15414 {
15415 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
15416 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
15417 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
15418
15419 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
15420 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
15421 }
15422
15423 for (uint i = 21; i <= 31; i++)
15424 {
15425 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
15426 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
15427 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
15428
15429 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
15430 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
15431 }
15432
15433 if (attack_mode == ATTACK_MODE_BF)
15434 {
15435 device_param->kernel_mp_l = hc_clCreateKernel (device_param->program_mp, "l_markov");
15436 device_param->kernel_mp_r = hc_clCreateKernel (device_param->program_mp, "r_markov");
15437
15438 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15439 {
15440 hc_clSetKernelArg (device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
15441
15442 hc_clSetKernelArg (device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
15443 hc_clSetKernelArg (device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
15444 }
15445 }
15446 else if (attack_mode == ATTACK_MODE_HYBRID1)
15447 {
15448 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
15449 }
15450 else if (attack_mode == ATTACK_MODE_HYBRID2)
15451 {
15452 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
15453 }
15454
15455 if (attack_exec == ATTACK_EXEC_ON_GPU)
15456 {
15457 // nothing to do
15458 }
15459 else
15460 {
15461 for (uint i = 0; i < 5; i++)
15462 {
15463 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
15464 }
15465
15466 for (uint i = 5; i < 7; i++)
15467 {
15468 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
15469 }
15470 }
15471
15472 /**
15473 * Store initial fanspeed if gpu_temp_retain is enabled
15474 */
15475
15476 if (gpu_temp_disable == 0)
15477 {
15478 if (gpu_temp_retain != 0)
15479 {
15480 hc_thread_mutex_lock (mux_adl);
15481
15482 if (data.hm_device[device_id].fan_supported == 1)
15483 {
15484 if (gpu_temp_retain_chgd == 0)
15485 {
15486 uint cur_temp = 0;
15487 uint default_temp = 0;
15488
15489 int ADL_rc = hc_ADL_Overdrive6_TargetTemperatureData_Get (data.hm_dll, data.hm_device[device_id].adapter_index, (int *) &cur_temp, (int *) &default_temp);
15490
15491 if (ADL_rc == ADL_OK)
15492 {
15493 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
15494
15495 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
15496
15497 // special case with multi gpu setups: always use minimum retain
15498
15499 if (gpu_temp_retain_set == 0)
15500 {
15501 gpu_temp_retain = gpu_temp_retain_target;
15502 gpu_temp_retain_set = 1;
15503 }
15504 else
15505 {
15506 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
15507 }
15508
15509 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
15510 }
15511 }
15512
15513 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
15514
15515 temp_retain_fanspeed_value[device_id] = fan_speed;
15516
15517 if (fan_speed == -1)
15518 {
15519 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
15520
15521 temp_retain_fanspeed_value[device_id] = 0;
15522 }
15523 }
15524
15525 hc_thread_mutex_unlock (mux_adl);
15526 }
15527 }
15528
15529 /**
15530 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
15531 */
15532
15533 if (powertune_enable == 1)
15534 {
15535 hc_thread_mutex_lock (mux_adl);
15536
15537 if (data.hm_device[device_id].od_version == 6)
15538 {
15539 int ADL_rc;
15540
15541 // check powertune capabilities first, if not available then skip device
15542
15543 int powertune_supported = 0;
15544
15545 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll, data.hm_device[device_id].adapter_index, &powertune_supported)) != ADL_OK)
15546 {
15547 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
15548
15549 return (-1);
15550 }
15551
15552 if (powertune_supported != 0)
15553 {
15554 // powercontrol settings
15555
15556 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
15557
15558 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll, data.hm_device[device_id].adapter_index, &powertune)) == ADL_OK)
15559 {
15560 ADL_rc = hc_ADL_Overdrive_PowerControl_Get (data.hm_dll, data.hm_device[device_id].adapter_index, &od_power_control_status[device_id]);
15561 }
15562
15563 if (ADL_rc != ADL_OK)
15564 {
15565 log_error ("ERROR: Failed to get current ADL PowerControl settings");
15566
15567 return (-1);
15568 }
15569
15570 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll, data.hm_device[device_id].adapter_index, powertune.iMaxValue)) != ADL_OK)
15571 {
15572 log_error ("ERROR: Failed to set new ADL PowerControl values");
15573
15574 return (-1);
15575 }
15576
15577 // clocks
15578
15579 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
15580
15581 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
15582
15583 if ((ADL_rc = hc_ADL_Overdrive_StateInfo_Get (data.hm_dll, data.hm_device[device_id].adapter_index, ADL_OD6_GETSTATEINFO_CUSTOM_PERFORMANCE, &od_clock_mem_status[device_id])) != ADL_OK)
15584 {
15585 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
15586
15587 return (-1);
15588 }
15589
15590 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
15591
15592 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
15593
15594 if ((ADL_rc = hc_ADL_Overdrive_Capabilities_Get (data.hm_dll, data.hm_device[device_id].adapter_index, &caps)) != ADL_OK)
15595 {
15596 log_error ("ERROR: Failed to get ADL device capabilities");
15597
15598 return (-1);
15599 }
15600
15601 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
15602 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
15603
15604 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
15605 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
15606
15607 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
15608 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
15609
15610 // warning if profile has to low max values
15611
15612 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
15613 {
15614 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
15615 }
15616
15617 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
15618 {
15619 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
15620 }
15621
15622 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
15623
15624 performance_state->iNumberOfPerformanceLevels = 2;
15625
15626 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
15627 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
15628 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
15629 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
15630
15631 if ((ADL_rc = hc_ADL_Overdrive_State_Set (data.hm_dll, data.hm_device[device_id].adapter_index, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
15632 {
15633 log_info ("ERROR: Failed to set ADL performance state");
15634
15635 return (-1);
15636 }
15637
15638 local_free (performance_state);
15639 }
15640 }
15641
15642 hc_thread_mutex_unlock (mux_adl);
15643 }
15644 }
15645
15646 /* Temporary fix:
15647 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
15648 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
15649 * were not working @ full speed (setting hc_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
15650 * Driver / ADL bug?
15651 */
15652
15653 if (powertune_enable == 1)
15654 {
15655 hc_thread_mutex_lock (mux_adl);
15656
15657 for (uint i = 0; i < devices_cnt; i++)
15658 {
15659 if (data.hm_device[i].od_version == 6)
15660 {
15661 // set powertune value only
15662
15663 int powertune_supported = 0;
15664
15665 int ADL_rc = 0;
15666
15667 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll, data.hm_device[i].adapter_index, &powertune_supported)) != ADL_OK)
15668 {
15669 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
15670
15671 return (-1);
15672 }
15673
15674 if (powertune_supported != 0)
15675 {
15676 // powertune set
15677 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
15678
15679 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll, data.hm_device[i].adapter_index, &powertune)) != ADL_OK)
15680 {
15681 log_error ("ERROR: Failed to get current ADL PowerControl settings");
15682
15683 return (-1);
15684 }
15685
15686 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll, data.hm_device[i].adapter_index, powertune.iMaxValue)) != ADL_OK)
15687 {
15688 log_error ("ERROR: Failed to set new ADL PowerControl values");
15689
15690 return (-1);
15691 }
15692 }
15693 }
15694 }
15695
15696 hc_thread_mutex_unlock (mux_adl);
15697 }
15698 #endif
15699
15700 data.gpu_blocks_all = gpu_blocks_all;
15701
15702 #ifdef _OCL
15703 if (gpu_async == 0) gpu_async = 1; // get rid of the warning
15704 #endif
15705
15706 if (data.quiet == 0) log_info ("");
15707
15708 /**
15709 * Inform user which algorithm is checked and at which workload setting
15710 */
15711
15712 if (benchmark == 1)
15713 {
15714 quiet = 0;
15715
15716 data.quiet = quiet;
15717
15718 char *hash_type = strhashtype (data.hash_mode); // not a bug
15719
15720 log_info ("Hashtype: %s", hash_type);
15721 log_info ("Workload: %u loops, %u accel", gpu_loops, gpu_accel);
15722 log_info ("");
15723 }
15724
15725 /**
15726 * keep track of the progress
15727 */
15728
15729 data.words_progress_done = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
15730 data.words_progress_rejected = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
15731 data.words_progress_restored = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
15732
15733 /**
15734 * open filehandles
15735 */
15736
15737 #if _WIN
15738 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
15739 {
15740 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
15741
15742 return (-1);
15743 }
15744
15745 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
15746 {
15747 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
15748
15749 return (-1);
15750 }
15751
15752 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
15753 {
15754 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
15755
15756 return (-1);
15757 }
15758 #endif
15759
15760 /**
15761 * dictionary pad
15762 */
15763
15764 segment_size *= (1024 * 1024);
15765
15766 data.segment_size = segment_size;
15767
15768 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
15769
15770 wl_data->buf = (char *) mymalloc (segment_size);
15771 wl_data->avail = segment_size;
15772 wl_data->incr = segment_size;
15773 wl_data->cnt = 0;
15774 wl_data->pos = 0;
15775
15776 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
15777
15778 data.wordlist_mode = wordlist_mode;
15779
15780 cs_t *css_buf = NULL;
15781 uint css_cnt = 0;
15782 uint dictcnt = 0;
15783 uint maskcnt = 1;
15784 char **masks = NULL;
15785 char **dictfiles = NULL;
15786
15787 uint mask_from_file = 0;
15788
15789 if (attack_mode == ATTACK_MODE_STRAIGHT)
15790 {
15791 if (wordlist_mode == WL_MODE_FILE)
15792 {
15793 int wls_left = myargc - (optind + 1);
15794
15795 for (int i = 0; i < wls_left; i++)
15796 {
15797 char *l0_filename = myargv[optind + 1 + i];
15798
15799 struct stat l0_stat;
15800
15801 if (stat (l0_filename, &l0_stat) == -1)
15802 {
15803 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
15804
15805 return (-1);
15806 }
15807
15808 uint is_dir = S_ISDIR (l0_stat.st_mode);
15809
15810 if (is_dir == 0)
15811 {
15812 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15813
15814 dictcnt++;
15815
15816 dictfiles[dictcnt - 1] = l0_filename;
15817 }
15818 else
15819 {
15820 // do not allow --keyspace w/ a directory
15821
15822 if (keyspace == 1)
15823 {
15824 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15825
15826 return (-1);
15827 }
15828
15829 char **dictionary_files = NULL;
15830
15831 dictionary_files = scan_directory (l0_filename);
15832
15833 if (dictionary_files != NULL)
15834 {
15835 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15836
15837 for (int d = 0; dictionary_files[d] != NULL; d++)
15838 {
15839 char *l1_filename = dictionary_files[d];
15840
15841 struct stat l1_stat;
15842
15843 if (stat (l1_filename, &l1_stat) == -1)
15844 {
15845 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15846
15847 return (-1);
15848 }
15849
15850 if (S_ISREG (l1_stat.st_mode))
15851 {
15852 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15853
15854 dictcnt++;
15855
15856 dictfiles[dictcnt - 1] = strdup (l1_filename);
15857 }
15858 }
15859 }
15860
15861 local_free (dictionary_files);
15862 }
15863 }
15864
15865 if (dictcnt < 1)
15866 {
15867 log_error ("ERROR: No usable dictionary file found.");
15868
15869 return (-1);
15870 }
15871 }
15872 else if (wordlist_mode == WL_MODE_STDIN)
15873 {
15874 dictcnt = 1;
15875 }
15876 }
15877 else if (attack_mode == ATTACK_MODE_COMBI)
15878 {
15879 // display
15880
15881 char *dictfile1 = myargv[optind + 1 + 0];
15882 char *dictfile2 = myargv[optind + 1 + 1];
15883
15884 // find the bigger dictionary and use as base
15885
15886 FILE *fp1;
15887 FILE *fp2;
15888
15889 struct stat tmp_stat;
15890
15891 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
15892 {
15893 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15894
15895 return (-1);
15896 }
15897
15898 if (stat (dictfile1, &tmp_stat) == -1)
15899 {
15900 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15901
15902 fclose (fp1);
15903
15904 return (-1);
15905 }
15906
15907 if (S_ISDIR (tmp_stat.st_mode))
15908 {
15909 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
15910
15911 fclose (fp1);
15912
15913 return (-1);
15914 }
15915
15916 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
15917 {
15918 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15919
15920 fclose (fp1);
15921
15922 return (-1);
15923 }
15924
15925 if (stat (dictfile2, &tmp_stat) == -1)
15926 {
15927 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15928
15929 fclose (fp1);
15930 fclose (fp2);
15931
15932 return (-1);
15933 }
15934
15935 if (S_ISDIR (tmp_stat.st_mode))
15936 {
15937 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
15938
15939 fclose (fp1);
15940 fclose (fp2);
15941
15942 return (-1);
15943 }
15944
15945 data.combs_cnt = 1;
15946
15947 data.quiet = 1;
15948
15949 const uint64_t words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15950
15951 data.quiet = quiet;
15952
15953 if (words1_cnt == 0)
15954 {
15955 log_error ("ERROR: %s: empty file", dictfile1);
15956
15957 fclose (fp1);
15958 fclose (fp2);
15959
15960 return (-1);
15961 }
15962
15963 data.combs_cnt = 1;
15964
15965 data.quiet = 1;
15966
15967 const uint64_t words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15968
15969 data.quiet = quiet;
15970
15971 if (words2_cnt == 0)
15972 {
15973 log_error ("ERROR: %s: empty file", dictfile2);
15974
15975 fclose (fp1);
15976 fclose (fp2);
15977
15978 return (-1);
15979 }
15980
15981 fclose (fp1);
15982 fclose (fp2);
15983
15984 data.dictfile = dictfile1;
15985 data.dictfile2 = dictfile2;
15986
15987 if (words1_cnt >= words2_cnt)
15988 {
15989 data.combs_cnt = words2_cnt;
15990 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15991
15992 dictfiles = &data.dictfile;
15993
15994 dictcnt = 1;
15995 }
15996 else
15997 {
15998 data.combs_cnt = words1_cnt;
15999 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16000
16001 dictfiles = &data.dictfile2;
16002
16003 dictcnt = 1;
16004
16005 // we also have to switch wordlist related rules!
16006
16007 char *tmpc = data.rule_buf_l;
16008
16009 data.rule_buf_l = data.rule_buf_r;
16010 data.rule_buf_r = tmpc;
16011
16012 int tmpi = data.rule_len_l;
16013
16014 data.rule_len_l = data.rule_len_r;
16015 data.rule_len_r = tmpi;
16016 }
16017 }
16018 else if (attack_mode == ATTACK_MODE_BF)
16019 {
16020 char *mask = NULL;
16021
16022 maskcnt = 0;
16023
16024 if (benchmark == 0)
16025 {
16026 mask = myargv[optind + 1];
16027
16028 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16029
16030 if ((optind + 2) <= myargc)
16031 {
16032 struct stat file_stat;
16033
16034 if (stat (mask, &file_stat) == -1)
16035 {
16036 maskcnt = 1;
16037
16038 masks[maskcnt - 1] = mystrdup (mask);
16039 }
16040 else
16041 {
16042 int wls_left = myargc - (optind + 1);
16043
16044 uint masks_avail = INCR_MASKS;
16045
16046 for (int i = 0; i < wls_left; i++)
16047 {
16048 if (i != 0)
16049 {
16050 mask = myargv[optind + 1 + i];
16051
16052 if (stat (mask, &file_stat) == -1)
16053 {
16054 log_error ("ERROR: %s: %s", mask, strerror (errno));
16055
16056 return (-1);
16057 }
16058 }
16059
16060 uint is_file = S_ISREG (file_stat.st_mode);
16061
16062 if (is_file == 1)
16063 {
16064 FILE *mask_fp;
16065
16066 if ((mask_fp = fopen (mask, "r")) == NULL)
16067 {
16068 log_error ("ERROR: %s: %s", mask, strerror (errno));
16069
16070 return (-1);
16071 }
16072
16073 char line_buf[BUFSIZ];
16074
16075 while (!feof (mask_fp))
16076 {
16077 memset (line_buf, 0, BUFSIZ);
16078
16079 int line_len = fgetl (mask_fp, line_buf);
16080
16081 if (line_len == 0) continue;
16082
16083 if (line_buf[0] == '#') continue;
16084
16085 if (masks_avail == maskcnt)
16086 {
16087 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16088
16089 masks_avail += INCR_MASKS;
16090 }
16091
16092 masks[maskcnt] = mystrdup (line_buf);
16093
16094 maskcnt++;
16095 }
16096
16097 fclose (mask_fp);
16098 }
16099 else
16100 {
16101 log_error ("ERROR: %s: unsupported file-type", mask);
16102
16103 return (-1);
16104 }
16105 }
16106
16107 mask_from_file = 1;
16108 }
16109 }
16110 else
16111 {
16112 custom_charset_1 = (char *) "?l?d?u";
16113 custom_charset_2 = (char *) "?l?d";
16114 custom_charset_3 = (char *) "?l?d*!$@_";
16115
16116 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16117 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16118 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16119
16120 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16121
16122 wordlist_mode = WL_MODE_MASK;
16123
16124 data.wordlist_mode = wordlist_mode;
16125
16126 increment = 1;
16127
16128 maskcnt = 1;
16129 }
16130 }
16131 else
16132 {
16133 /**
16134 * generate full masks and charsets
16135 */
16136
16137 masks = (char **) mymalloc (sizeof (char *));
16138
16139 switch (hash_mode)
16140 {
16141 case 1731: pw_min = 5;
16142 pw_max = 5;
16143 mask = mystrdup ("?b?b?b?b?b");
16144 break;
16145 case 12500: pw_min = 5;
16146 pw_max = 5;
16147 mask = mystrdup ("?b?b?b?b?b");
16148 break;
16149 default: pw_min = 7;
16150 pw_max = 7;
16151 mask = mystrdup ("?b?b?b?b?b?b?b");
16152 break;
16153 }
16154
16155 maskcnt = 1;
16156
16157 masks[maskcnt - 1] = mystrdup (mask);
16158
16159 wordlist_mode = WL_MODE_MASK;
16160
16161 data.wordlist_mode = wordlist_mode;
16162
16163 increment = 1;
16164 }
16165
16166 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16167
16168 if (increment)
16169 {
16170 if (increment_min > pw_min) pw_min = increment_min;
16171
16172 if (increment_max < pw_max) pw_max = increment_max;
16173 }
16174 }
16175 else if (attack_mode == ATTACK_MODE_HYBRID1)
16176 {
16177 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16178
16179 // display
16180
16181 char *mask = myargv[myargc - 1];
16182
16183 maskcnt = 0;
16184
16185 masks = (char **) mymalloc (1 * sizeof (char *));
16186
16187 // mod
16188
16189 struct stat file_stat;
16190
16191 if (stat (mask, &file_stat) == -1)
16192 {
16193 maskcnt = 1;
16194
16195 masks[maskcnt - 1] = mystrdup (mask);
16196 }
16197 else
16198 {
16199 uint is_file = S_ISREG (file_stat.st_mode);
16200
16201 if (is_file == 1)
16202 {
16203 FILE *mask_fp;
16204
16205 if ((mask_fp = fopen (mask, "r")) == NULL)
16206 {
16207 log_error ("ERROR: %s: %s", mask, strerror (errno));
16208
16209 return (-1);
16210 }
16211
16212 char line_buf[BUFSIZ];
16213
16214 uint masks_avail = 1;
16215
16216 while (!feof (mask_fp))
16217 {
16218 memset (line_buf, 0, BUFSIZ);
16219
16220 int line_len = fgetl (mask_fp, line_buf);
16221
16222 if (line_len == 0) continue;
16223
16224 if (line_buf[0] == '#') continue;
16225
16226 if (masks_avail == maskcnt)
16227 {
16228 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16229
16230 masks_avail += INCR_MASKS;
16231 }
16232
16233 masks[maskcnt] = mystrdup (line_buf);
16234
16235 maskcnt++;
16236 }
16237
16238 fclose (mask_fp);
16239
16240 mask_from_file = 1;
16241 }
16242 else
16243 {
16244 maskcnt = 1;
16245
16246 masks[maskcnt - 1] = mystrdup (mask);
16247 }
16248 }
16249
16250 // base
16251
16252 int wls_left = myargc - (optind + 2);
16253
16254 for (int i = 0; i < wls_left; i++)
16255 {
16256 char *filename = myargv[optind + 1 + i];
16257
16258 struct stat file_stat;
16259
16260 if (stat (filename, &file_stat) == -1)
16261 {
16262 log_error ("ERROR: %s: %s", filename, strerror (errno));
16263
16264 return (-1);
16265 }
16266
16267 uint is_dir = S_ISDIR (file_stat.st_mode);
16268
16269 if (is_dir == 0)
16270 {
16271 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16272
16273 dictcnt++;
16274
16275 dictfiles[dictcnt - 1] = filename;
16276 }
16277 else
16278 {
16279 // do not allow --keyspace w/ a directory
16280
16281 if (keyspace == 1)
16282 {
16283 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16284
16285 return (-1);
16286 }
16287
16288 char **dictionary_files = NULL;
16289
16290 dictionary_files = scan_directory (filename);
16291
16292 if (dictionary_files != NULL)
16293 {
16294 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16295
16296 for (int d = 0; dictionary_files[d] != NULL; d++)
16297 {
16298 char *l1_filename = dictionary_files[d];
16299
16300 struct stat l1_stat;
16301
16302 if (stat (l1_filename, &l1_stat) == -1)
16303 {
16304 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16305
16306 return (-1);
16307 }
16308
16309 if (S_ISREG (l1_stat.st_mode))
16310 {
16311 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16312
16313 dictcnt++;
16314
16315 dictfiles[dictcnt - 1] = strdup (l1_filename);
16316 }
16317 }
16318 }
16319
16320 local_free (dictionary_files);
16321 }
16322 }
16323
16324 if (dictcnt < 1)
16325 {
16326 log_error ("ERROR: No usable dictionary file found.");
16327
16328 return (-1);
16329 }
16330
16331 if (increment)
16332 {
16333 maskcnt = 0;
16334
16335 uint mask_min = increment_min; // we can't reject smaller masks here
16336 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16337
16338 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16339 {
16340 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16341
16342 if (cur_mask == NULL) break;
16343
16344 masks[maskcnt] = cur_mask;
16345
16346 maskcnt++;
16347
16348 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16349 }
16350 }
16351 }
16352 else if (attack_mode == ATTACK_MODE_HYBRID2)
16353 {
16354 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16355
16356 // display
16357
16358 char *mask = myargv[optind + 1 + 0];
16359
16360 maskcnt = 0;
16361
16362 masks = (char **) mymalloc (1 * sizeof (char *));
16363
16364 // mod
16365
16366 struct stat file_stat;
16367
16368 if (stat (mask, &file_stat) == -1)
16369 {
16370 maskcnt = 1;
16371
16372 masks[maskcnt - 1] = mystrdup (mask);
16373 }
16374 else
16375 {
16376 uint is_file = S_ISREG (file_stat.st_mode);
16377
16378 if (is_file == 1)
16379 {
16380 FILE *mask_fp;
16381
16382 if ((mask_fp = fopen (mask, "r")) == NULL)
16383 {
16384 log_error ("ERROR: %s: %s", mask, strerror (errno));
16385
16386 return (-1);
16387 }
16388
16389 char line_buf[BUFSIZ];
16390
16391 uint masks_avail = 1;
16392
16393 while (!feof (mask_fp))
16394 {
16395 memset (line_buf, 0, BUFSIZ);
16396
16397 int line_len = fgetl (mask_fp, line_buf);
16398
16399 if (line_len == 0) continue;
16400
16401 if (line_buf[0] == '#') continue;
16402
16403 if (masks_avail == maskcnt)
16404 {
16405 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16406
16407 masks_avail += INCR_MASKS;
16408 }
16409
16410 masks[maskcnt] = mystrdup (line_buf);
16411
16412 maskcnt++;
16413 }
16414
16415 fclose (mask_fp);
16416
16417 mask_from_file = 1;
16418 }
16419 else
16420 {
16421 maskcnt = 1;
16422
16423 masks[maskcnt - 1] = mystrdup (mask);
16424 }
16425 }
16426
16427 // base
16428
16429 int wls_left = myargc - (optind + 2);
16430
16431 for (int i = 0; i < wls_left; i++)
16432 {
16433 char *filename = myargv[optind + 2 + i];
16434
16435 struct stat file_stat;
16436
16437 if (stat (filename, &file_stat) == -1)
16438 {
16439 log_error ("ERROR: %s: %s", filename, strerror (errno));
16440
16441 return (-1);
16442 }
16443
16444 uint is_dir = S_ISDIR (file_stat.st_mode);
16445
16446 if (is_dir == 0)
16447 {
16448 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16449
16450 dictcnt++;
16451
16452 dictfiles[dictcnt - 1] = filename;
16453 }
16454 else
16455 {
16456 // do not allow --keyspace w/ a directory
16457
16458 if (keyspace == 1)
16459 {
16460 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16461
16462 return (-1);
16463 }
16464
16465 char **dictionary_files = NULL;
16466
16467 dictionary_files = scan_directory (filename);
16468
16469 if (dictionary_files != NULL)
16470 {
16471 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16472
16473 for (int d = 0; dictionary_files[d] != NULL; d++)
16474 {
16475 char *l1_filename = dictionary_files[d];
16476
16477 struct stat l1_stat;
16478
16479 if (stat (l1_filename, &l1_stat) == -1)
16480 {
16481 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16482
16483 return (-1);
16484 }
16485
16486 if (S_ISREG (l1_stat.st_mode))
16487 {
16488 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16489
16490 dictcnt++;
16491
16492 dictfiles[dictcnt - 1] = strdup (l1_filename);
16493 }
16494 }
16495 }
16496
16497 local_free (dictionary_files);
16498 }
16499 }
16500
16501 if (dictcnt < 1)
16502 {
16503 log_error ("ERROR: No usable dictionary file found.");
16504
16505 return (-1);
16506 }
16507
16508 if (increment)
16509 {
16510 maskcnt = 0;
16511
16512 uint mask_min = increment_min; // we can't reject smaller masks here
16513 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16514
16515 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16516 {
16517 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16518
16519 if (cur_mask == NULL) break;
16520
16521 masks[maskcnt] = cur_mask;
16522
16523 maskcnt++;
16524
16525 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16526 }
16527 }
16528 }
16529
16530 data.pw_min = pw_min;
16531 data.pw_max = pw_max;
16532
16533 /**
16534 * weak hash check
16535 */
16536
16537 if (weak_hash_threshold >= salts_cnt)
16538 {
16539 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
16540
16541 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
16542 {
16543 weak_hash_check (&data.devices_param[0], salt_pos, gpu_loops);
16544 }
16545 }
16546
16547 // Display hack, guarantee that there is at least one \r before real start
16548
16549 if (data.quiet == 0) log_info_nn ("");
16550
16551 /**
16552 * status and monitor threads
16553 */
16554
16555 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
16556
16557 hc_thread_t i_thread = 0;
16558
16559 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16560 {
16561 hc_thread_create (i_thread, thread_keypress, &benchmark);
16562 }
16563
16564 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
16565
16566 uint ni_threads_cnt = 0;
16567
16568 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
16569
16570 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
16571
16572 ni_threads_cnt++;
16573
16574 /**
16575 * Outfile remove
16576 */
16577
16578 if (keyspace == 0)
16579 {
16580 if (outfile_check_timer != 0)
16581 {
16582 if (data.outfile_check_directory != NULL)
16583 {
16584 if ((hash_mode != 5200) &&
16585 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
16586 (hash_mode != 9000))
16587 {
16588 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
16589
16590 ni_threads_cnt++;
16591 }
16592 else
16593 {
16594 outfile_check_timer = 0;
16595 }
16596 }
16597 else
16598 {
16599 outfile_check_timer = 0;
16600 }
16601 }
16602 }
16603
16604 /**
16605 * Inform the user if we got some hashes remove because of the pot file remove feature
16606 */
16607
16608 if (data.quiet == 0)
16609 {
16610 if (potfile_remove_cracks > 0)
16611 {
16612 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
16613 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
16614 }
16615 }
16616
16617 data.outfile_check_timer = outfile_check_timer;
16618
16619 /**
16620 * main loop
16621 */
16622
16623 char **induction_dictionaries = NULL;
16624
16625 int induction_dictionaries_cnt = 0;
16626
16627 hcstat_table_t *root_table_buf = NULL;
16628 hcstat_table_t *markov_table_buf = NULL;
16629
16630 uint initial_restore_done = 0;
16631
16632 data.maskcnt = maskcnt;
16633
16634 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
16635 {
16636 if (data.devices_status == STATUS_CRACKED) break;
16637
16638 data.devices_status = STATUS_INIT;
16639
16640 if (maskpos > rd->maskpos)
16641 {
16642 rd->dictpos = 0;
16643 }
16644
16645 rd->maskpos = maskpos;
16646 data.maskpos = maskpos;
16647
16648 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
16649 {
16650 char *mask = masks[maskpos];
16651
16652 if (mask_from_file == 1)
16653 {
16654 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
16655
16656 char *str_ptr;
16657 uint str_pos;
16658
16659 uint mask_offset = 0;
16660
16661 uint separator_cnt;
16662
16663 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
16664 {
16665 str_ptr = strstr (mask + mask_offset, ",");
16666
16667 if (str_ptr == NULL) break;
16668
16669 str_pos = str_ptr - mask;
16670
16671 // escaped separator, i.e. "\,"
16672
16673 if (str_pos > 0)
16674 {
16675 if (mask[str_pos - 1] == '\\')
16676 {
16677 separator_cnt --;
16678
16679 mask_offset = str_pos + 1;
16680
16681 continue;
16682 }
16683 }
16684
16685 // reset the offset
16686
16687 mask_offset = 0;
16688
16689 mask[str_pos] = '\0';
16690
16691 switch (separator_cnt)
16692 {
16693 case 0:
16694 mp_reset_usr (mp_usr, 0);
16695
16696 custom_charset_1 = mask;
16697 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16698 break;
16699
16700 case 1:
16701 mp_reset_usr (mp_usr, 1);
16702
16703 custom_charset_2 = mask;
16704 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16705 break;
16706
16707 case 2:
16708 mp_reset_usr (mp_usr, 2);
16709
16710 custom_charset_3 = mask;
16711 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16712 break;
16713
16714 case 3:
16715 mp_reset_usr (mp_usr, 3);
16716
16717 custom_charset_4 = mask;
16718 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
16719 break;
16720 }
16721
16722 mask = mask + str_pos + 1;
16723 }
16724 }
16725
16726 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16727 {
16728 if (maskpos > 0)
16729 {
16730 local_free (css_buf);
16731 local_free (data.root_css_buf);
16732 local_free (data.markov_css_buf);
16733
16734 local_free (masks[maskpos - 1]);
16735 }
16736
16737 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16738
16739 data.mask = mask;
16740 data.css_cnt = css_cnt;
16741 data.css_buf = css_buf;
16742
16743 uint uniq_tbls[SP_PW_MAX][CHARSIZ];
16744
16745 memset (uniq_tbls, 0, sizeof (uniq_tbls));
16746
16747 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16748
16749 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16750 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16751
16752 sp_setup_tbl (install_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16753
16754 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16755
16756 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16757 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16758
16759 data.root_css_buf = root_css_buf;
16760 data.markov_css_buf = markov_css_buf;
16761
16762 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16763
16764 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16765
16766 local_free (root_table_buf);
16767 local_free (markov_table_buf);
16768
16769 // args
16770
16771 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16772 {
16773 hc_device_param_t *device_param = &data.devices_param[device_id];
16774
16775 device_param->kernel_params_mp[0] = &device_param->d_combs;
16776 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
16777 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
16778
16779 device_param->kernel_params_mp_buf64[3] = 0;
16780 device_param->kernel_params_mp_buf32[4] = css_cnt;
16781 device_param->kernel_params_mp_buf32[5] = 0;
16782 device_param->kernel_params_mp_buf32[6] = 0;
16783 device_param->kernel_params_mp_buf32[7] = 0;
16784
16785 if (attack_mode == ATTACK_MODE_HYBRID1)
16786 {
16787 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
16788 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16789 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16790 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16791 }
16792 else if (attack_mode == ATTACK_MODE_HYBRID2)
16793 {
16794 device_param->kernel_params_mp_buf32[5] = 0;
16795 device_param->kernel_params_mp_buf32[6] = 0;
16796 device_param->kernel_params_mp_buf32[7] = 0;
16797 }
16798
16799 #ifdef _CUDA
16800 hc_cuCtxPushCurrent (device_param->context);
16801
16802 hc_cuMemcpyHtoD (device_param->d_root_css_buf, root_css_buf, device_param->size_root_css);
16803 hc_cuMemcpyHtoD (device_param->d_markov_css_buf, markov_css_buf, device_param->size_markov_css);
16804
16805 hc_cuCtxPopCurrent (&device_param->context);
16806 #elif _OCL
16807 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp[i]);
16808 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp[i]);
16809 for (uint i = 4; i < 8; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp[i]);
16810
16811 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);
16812 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);
16813 #endif
16814 }
16815 }
16816 else if (attack_mode == ATTACK_MODE_BF)
16817 {
16818 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16819
16820 if (increment)
16821 {
16822 for (uint i = 0; i < dictcnt; i++)
16823 {
16824 local_free (dictfiles[i]);
16825 }
16826
16827 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16828 {
16829 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
16830
16831 if (l1_filename == NULL) break;
16832
16833 dictcnt++;
16834
16835 dictfiles[dictcnt - 1] = l1_filename;
16836 }
16837 }
16838 else
16839 {
16840 dictcnt++;
16841
16842 dictfiles[dictcnt - 1] = mask;
16843 }
16844
16845 if (dictcnt == 0)
16846 {
16847 log_error ("ERROR: Mask is too small");
16848
16849 return (-1);
16850 }
16851 }
16852 }
16853
16854 free (induction_dictionaries);
16855
16856 // induction_dictionaries_cnt = 0; // implied
16857
16858 if (attack_mode != ATTACK_MODE_BF)
16859 {
16860 if (keyspace == 0)
16861 {
16862 induction_dictionaries = scan_directory (induction_directory);
16863
16864 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16865 }
16866 }
16867
16868 if (induction_dictionaries_cnt)
16869 {
16870 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16871 }
16872
16873 /**
16874 * prevent the user from using --keyspace together w/ maskfile and or dictfile
16875 */
16876 if (keyspace == 1)
16877 {
16878 if ((maskcnt > 1) || (dictcnt > 1))
16879 {
16880 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
16881
16882 return (-1);
16883 }
16884 }
16885
16886 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
16887 {
16888 char *subid = logfile_generate_subid ();
16889
16890 data.subid = subid;
16891
16892 logfile_sub_msg ("START");
16893
16894 data.devices_status = STATUS_INIT;
16895
16896 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (uint64_t));
16897 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (uint64_t));
16898 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (uint64_t));
16899
16900 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
16901
16902 data.cpt_pos = 0;
16903
16904 data.cpt_start = time (NULL);
16905
16906 data.cpt_total = 0;
16907
16908 if (data.restore == 0)
16909 {
16910 rd->words_cur = skip;
16911
16912 skip = 0;
16913
16914 data.skip = 0;
16915 }
16916
16917 data.ms_paused = 0;
16918
16919 data.words_cur = rd->words_cur;
16920
16921 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16922 {
16923 hc_device_param_t *device_param = &data.devices_param[device_id];
16924
16925 device_param->speed_pos = 0;
16926
16927 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (uint64_t));
16928 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
16929 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
16930
16931 device_param->gpu_power = device_param->gpu_power_user;
16932 device_param->gpu_blocks = device_param->gpu_blocks_user;
16933
16934 device_param->outerloop_pos = 0;
16935 device_param->outerloop_left = 0;
16936 device_param->innerloop_pos = 0;
16937 device_param->innerloop_left = 0;
16938
16939 // some more resets:
16940
16941 memset (device_param->pw_caches, 0, 64 * sizeof (pw_cache_t));
16942
16943 memset (device_param->pws_buf, 0, device_param->size_pws);
16944
16945 device_param->pw_cnt = 0;
16946 device_param->pws_cnt = 0;
16947
16948 device_param->words_off = 0;
16949 device_param->words_done = 0;
16950 }
16951
16952 data.gpu_blocks_div = 0;
16953
16954 // figure out some workload
16955
16956 if (attack_mode == ATTACK_MODE_STRAIGHT)
16957 {
16958 if (data.wordlist_mode == WL_MODE_FILE)
16959 {
16960 char *dictfile = NULL;
16961
16962 if (induction_dictionaries_cnt)
16963 {
16964 dictfile = induction_dictionaries[0];
16965 }
16966 else
16967 {
16968 dictfile = dictfiles[dictpos];
16969 }
16970
16971 data.dictfile = dictfile;
16972
16973 logfile_sub_string (dictfile);
16974
16975 for (uint i = 0; i < rp_files_cnt; i++)
16976 {
16977 logfile_sub_var_string ("rulefile", rp_files[i]);
16978 }
16979
16980 FILE *fd2 = fopen (dictfile, "rb");
16981
16982 if (fd2 == NULL)
16983 {
16984 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16985
16986 return (-1);
16987 }
16988
16989 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16990
16991 fclose (fd2);
16992
16993 if (data.words_cnt == 0)
16994 {
16995 if (data.devices_status == STATUS_CRACKED) break;
16996 if (data.devices_status == STATUS_ABORTED) break;
16997
16998 dictpos++;
16999
17000 continue;
17001 }
17002 }
17003 }
17004 else if (attack_mode == ATTACK_MODE_COMBI)
17005 {
17006 char *dictfile = data.dictfile;
17007 char *dictfile2 = data.dictfile2;
17008
17009 logfile_sub_string (dictfile);
17010 logfile_sub_string (dictfile2);
17011
17012 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17013 {
17014 FILE *fd2 = fopen (dictfile, "rb");
17015
17016 if (fd2 == NULL)
17017 {
17018 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17019
17020 return (-1);
17021 }
17022
17023 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17024
17025 fclose (fd2);
17026 }
17027 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17028 {
17029 FILE *fd2 = fopen (dictfile2, "rb");
17030
17031 if (fd2 == NULL)
17032 {
17033 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17034
17035 return (-1);
17036 }
17037
17038 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17039
17040 fclose (fd2);
17041 }
17042
17043 if (data.words_cnt == 0)
17044 {
17045 if (data.devices_status == STATUS_CRACKED) break;
17046 if (data.devices_status == STATUS_ABORTED) break;
17047
17048 dictpos++;
17049
17050 continue;
17051 }
17052 }
17053 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17054 {
17055 char *dictfile = NULL;
17056
17057 if (induction_dictionaries_cnt)
17058 {
17059 dictfile = induction_dictionaries[0];
17060 }
17061 else
17062 {
17063 dictfile = dictfiles[dictpos];
17064 }
17065
17066 data.dictfile = dictfile;
17067
17068 char *mask = data.mask;
17069
17070 logfile_sub_string (dictfile);
17071 logfile_sub_string (mask);
17072
17073 FILE *fd2 = fopen (dictfile, "rb");
17074
17075 if (fd2 == NULL)
17076 {
17077 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17078
17079 return (-1);
17080 }
17081
17082 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17083
17084 fclose (fd2);
17085
17086 if (data.words_cnt == 0)
17087 {
17088 if (data.devices_status == STATUS_CRACKED) break;
17089 if (data.devices_status == STATUS_ABORTED) break;
17090
17091 dictpos++;
17092
17093 continue;
17094 }
17095 }
17096 else if (attack_mode == ATTACK_MODE_BF)
17097 {
17098 local_free (css_buf);
17099 local_free (data.root_css_buf);
17100 local_free (data.markov_css_buf);
17101
17102 char *mask = dictfiles[dictpos];
17103
17104 logfile_sub_string (mask);
17105
17106 // base
17107
17108 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17109
17110 if (opts_type & OPTS_TYPE_PT_UNICODE)
17111 {
17112 uint css_cnt_unicode = css_cnt * 2;
17113
17114 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17115
17116 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17117 {
17118 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17119
17120 css_buf_unicode[j + 1].cs_buf[0] = 0;
17121 css_buf_unicode[j + 1].cs_len = 1;
17122 }
17123
17124 free (css_buf);
17125
17126 css_buf = css_buf_unicode;
17127 css_cnt = css_cnt_unicode;
17128 }
17129
17130 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17131
17132 uint mask_min = pw_min;
17133 uint mask_max = pw_max;
17134
17135 if (opts_type & OPTS_TYPE_PT_UNICODE)
17136 {
17137 mask_min *= 2;
17138 mask_max *= 2;
17139 }
17140
17141 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17142 {
17143 if (css_cnt < mask_min)
17144 {
17145 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
17146 }
17147
17148 if (css_cnt > mask_max)
17149 {
17150 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
17151 }
17152
17153 // skip to next mask
17154
17155 dictpos++;
17156
17157 rd->dictpos = dictpos;
17158
17159 logfile_sub_msg ("STOP");
17160
17161 continue;
17162 }
17163
17164 uint save_css_cnt = css_cnt;
17165
17166 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17167 {
17168 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17169 {
17170 uint salt_len = (uint) data.salts_buf[0].salt_len;
17171 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17172
17173 uint css_cnt_salt = css_cnt + salt_len;
17174
17175 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17176
17177 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17178
17179 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17180 {
17181 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17182 css_buf_salt[j].cs_len = 1;
17183 }
17184
17185 free (css_buf);
17186
17187 css_buf = css_buf_salt;
17188 css_cnt = css_cnt_salt;
17189 }
17190 }
17191
17192 data.mask = mask;
17193 data.css_cnt = css_cnt;
17194 data.css_buf = css_buf;
17195
17196 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17197
17198 uint uniq_tbls[SP_PW_MAX][CHARSIZ];
17199
17200 memset (uniq_tbls, 0, sizeof (uniq_tbls));
17201
17202 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17203
17204 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17205 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17206
17207 sp_setup_tbl (install_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17208
17209 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17210
17211 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17212 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17213
17214 data.root_css_buf = root_css_buf;
17215 data.markov_css_buf = markov_css_buf;
17216
17217 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17218
17219 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17220
17221 local_free (root_table_buf);
17222 local_free (markov_table_buf);
17223
17224 // copy + args
17225
17226 uint css_cnt_l = css_cnt;
17227 uint css_cnt_r;
17228
17229 if (attack_exec == ATTACK_EXEC_ON_GPU)
17230 {
17231 if (save_css_cnt < 6)
17232 {
17233 css_cnt_r = 1;
17234 }
17235 else if (save_css_cnt == 6)
17236 {
17237 css_cnt_r = 2;
17238 }
17239 else
17240 {
17241 if (opts_type & OPTS_TYPE_PT_UNICODE)
17242 {
17243 if (save_css_cnt == 8 || save_css_cnt == 10)
17244 {
17245 css_cnt_r = 2;
17246 }
17247 else
17248 {
17249 css_cnt_r = 4;
17250 }
17251 }
17252 else
17253 {
17254 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17255 {
17256 css_cnt_r = 3;
17257 }
17258 else
17259 {
17260 css_cnt_r = 4;
17261 }
17262 }
17263 }
17264 }
17265 else
17266 {
17267 css_cnt_r = 1;
17268
17269 /* unfinished code?
17270 int sum = css_buf[css_cnt_r - 1].cs_len;
17271
17272 for (uint i = 1; i < 4 && i < css_cnt; i++)
17273 {
17274 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17275
17276 css_cnt_r++;
17277
17278 sum *= css_buf[css_cnt_r - 1].cs_len;
17279 }
17280 */
17281 }
17282
17283 css_cnt_l -= css_cnt_r;
17284
17285 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17286
17287 for (uint device_id = 0; device_id < devices_cnt; device_id++)
17288 {
17289 hc_device_param_t *device_param = &data.devices_param[device_id];
17290
17291 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17292 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17293 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17294
17295 device_param->kernel_params_mp_l_buf64[3] = 0;
17296 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17297 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17298 device_param->kernel_params_mp_l_buf32[6] = 0;
17299 device_param->kernel_params_mp_l_buf32[7] = 0;
17300 device_param->kernel_params_mp_l_buf32[8] = 0;
17301
17302 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17303 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17304 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17305 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17306
17307 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17308 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17309 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17310
17311 device_param->kernel_params_mp_r_buf64[3] = 0;
17312 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17313 device_param->kernel_params_mp_r_buf32[5] = 0;
17314 device_param->kernel_params_mp_r_buf32[6] = 0;
17315 device_param->kernel_params_mp_r_buf32[7] = 0;
17316
17317 #ifdef _CUDA
17318 hc_cuCtxPushCurrent (device_param->context);
17319
17320 hc_cuMemcpyHtoD (device_param->d_root_css_buf, root_css_buf, device_param->size_root_css);
17321 hc_cuMemcpyHtoD (device_param->d_markov_css_buf, markov_css_buf, device_param->size_markov_css);
17322
17323 hc_cuCtxPopCurrent (&device_param->context);
17324 #elif _OCL
17325 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]);
17326 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]);
17327 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]);
17328
17329 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]);
17330 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]);
17331 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]);
17332
17333 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);
17334 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);
17335 #endif
17336 }
17337 }
17338
17339 uint64_t words_base = data.words_cnt;
17340
17341 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17342 {
17343 if (data.gpu_rules_cnt)
17344 {
17345 words_base /= data.gpu_rules_cnt;
17346 }
17347 }
17348 else if (data.attack_kern == ATTACK_KERN_COMBI)
17349 {
17350 if (data.combs_cnt)
17351 {
17352 words_base /= data.combs_cnt;
17353 }
17354 }
17355 else if (data.attack_kern == ATTACK_KERN_BF)
17356 {
17357 if (data.bfs_cnt)
17358 {
17359 words_base /= data.bfs_cnt;
17360 }
17361 }
17362
17363 data.words_base = words_base;
17364
17365 if (keyspace == 1)
17366 {
17367 log_info ("%llu", (unsigned long long int) words_base);
17368
17369 return (0);
17370 }
17371
17372 if (data.words_cur > data.words_base)
17373 {
17374 log_error ("ERROR: restore value greater keyspace");
17375
17376 return (-1);
17377 }
17378
17379 if (data.words_cur)
17380 {
17381 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17382 {
17383 for (uint i = 0; i < data.salts_cnt; i++)
17384 {
17385 data.words_progress_restored[i] = data.words_cur * data.gpu_rules_cnt;
17386 }
17387 }
17388 else if (data.attack_kern == ATTACK_KERN_COMBI)
17389 {
17390 for (uint i = 0; i < data.salts_cnt; i++)
17391 {
17392 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
17393 }
17394 }
17395 else if (data.attack_kern == ATTACK_KERN_BF)
17396 {
17397 for (uint i = 0; i < data.salts_cnt; i++)
17398 {
17399 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
17400 }
17401 }
17402 }
17403
17404 /*
17405 * Inform user about possible slow speeds
17406 */
17407
17408 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17409 {
17410 if (data.words_base < gpu_blocks_all)
17411 {
17412 if (quiet == 0)
17413 {
17414 log_info ("");
17415 log_info ("ATTENTION!");
17416 log_info (" The wordlist or mask you are using is too small.");
17417 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your GPU(s).");
17418 log_info (" The cracking speed will drop.");
17419 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
17420 log_info ("");
17421 }
17422 }
17423 }
17424
17425 /*
17426 * Update loopback file
17427 */
17428
17429 if (loopback == 1)
17430 {
17431 time_t now;
17432
17433 time (&now);
17434
17435 uint random_num = get_random_num (0, 9999);
17436
17437 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
17438
17439 data.loopback_file = loopback_file;
17440 }
17441
17442 /*
17443 * Update dictionary statistic
17444 */
17445
17446 if (keyspace == 0)
17447 {
17448 dictstat_fp = fopen (dictstat, "wb");
17449
17450 if (dictstat_fp)
17451 {
17452 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
17453
17454 fclose (dictstat_fp);
17455 }
17456 }
17457
17458 data.devices_status = STATUS_RUNNING;
17459
17460 if (initial_restore_done == 0)
17461 {
17462 if (data.restore_disable == 0) cycle_restore ();
17463
17464 initial_restore_done = 1;
17465 }
17466
17467 hc_timer_set (&data.timer_running);
17468
17469 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17470 {
17471 if ((quiet == 0) && (status == 0) && (benchmark == 0))
17472 {
17473 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
17474 if (quiet == 0) fflush (stdout);
17475 }
17476 }
17477 else if (wordlist_mode == WL_MODE_STDIN)
17478 {
17479 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
17480 if (data.quiet == 0) log_info ("");
17481 }
17482
17483 time_t runtime_start;
17484
17485 time (&runtime_start);
17486
17487 data.runtime_start = runtime_start;
17488
17489 /**
17490 * create cracker threads
17491 */
17492
17493 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (devices_cnt, sizeof (hc_thread_t));
17494
17495 for (uint device_id = 0; device_id < devices_cnt; device_id++)
17496 {
17497 hc_device_param_t *device_param = &devices_param[device_id];
17498
17499 device_param->device_id = device_id;
17500
17501 if (wordlist_mode == WL_MODE_STDIN)
17502 {
17503 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
17504 }
17505 else
17506 {
17507 hc_thread_create (c_threads[device_id], thread_calc, device_param);
17508 }
17509 }
17510
17511 // wait for crack threads to exit
17512
17513 hc_thread_wait (devices_cnt, c_threads);
17514
17515
17516 local_free (c_threads);
17517
17518 data.restore = 0;
17519
17520 // finalize task
17521
17522 logfile_sub_var_uint ("status-after-work", data.devices_status);
17523
17524 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17525
17526 if (data.devices_status == STATUS_CRACKED) break;
17527 if (data.devices_status == STATUS_ABORTED) break;
17528
17529 if (data.devices_status == STATUS_BYPASS)
17530 {
17531 data.devices_status = STATUS_RUNNING;
17532 }
17533
17534 if (induction_dictionaries_cnt)
17535 {
17536 unlink (induction_dictionaries[0]);
17537 }
17538
17539 free (induction_dictionaries);
17540
17541 if (attack_mode != ATTACK_MODE_BF)
17542 {
17543 induction_dictionaries = scan_directory (induction_directory);
17544
17545 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17546 }
17547
17548 if (benchmark == 0)
17549 {
17550 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
17551 {
17552 if (quiet == 0) clear_prompt ();
17553
17554 if (quiet == 0) log_info ("");
17555
17556 if (status == 1)
17557 {
17558 status_display ();
17559 }
17560 else
17561 {
17562 if (quiet == 0) status_display ();
17563 }
17564
17565 if (quiet == 0) log_info ("");
17566 }
17567 }
17568
17569 if (attack_mode == ATTACK_MODE_BF)
17570 {
17571 dictpos++;
17572
17573 rd->dictpos = dictpos;
17574 }
17575 else
17576 {
17577 if (induction_dictionaries_cnt)
17578 {
17579 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17580 }
17581 else
17582 {
17583 dictpos++;
17584
17585 rd->dictpos = dictpos;
17586 }
17587 }
17588
17589 time_t runtime_stop;
17590
17591 time (&runtime_stop);
17592
17593 data.runtime_stop = runtime_stop;
17594
17595 logfile_sub_uint (runtime_start);
17596 logfile_sub_uint (runtime_stop);
17597
17598 logfile_sub_msg ("STOP");
17599
17600 global_free (subid);
17601 }
17602
17603 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17604
17605 if (data.devices_status == STATUS_CRACKED) break;
17606 if (data.devices_status == STATUS_ABORTED) break;
17607 if (data.devices_status == STATUS_QUIT) break;
17608
17609 if (data.devices_status == STATUS_BYPASS)
17610 {
17611 data.devices_status = STATUS_RUNNING;
17612 }
17613 }
17614
17615 // 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
17616
17617 if (attack_mode == ATTACK_MODE_STRAIGHT)
17618 {
17619 if (data.wordlist_mode == WL_MODE_FILE)
17620 {
17621 if (data.dictfile == NULL)
17622 {
17623 if (dictfiles != NULL)
17624 {
17625 data.dictfile = dictfiles[0];
17626
17627 hc_timer_set (&data.timer_running);
17628 }
17629 }
17630 }
17631 }
17632 // NOTE: combi is okay because it is already set beforehand
17633 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
17634 {
17635 if (data.dictfile == NULL)
17636 {
17637 if (dictfiles != NULL)
17638 {
17639 hc_timer_set (&data.timer_running);
17640
17641 data.dictfile = dictfiles[0];
17642 }
17643 }
17644 }
17645 else if (attack_mode == ATTACK_MODE_BF)
17646 {
17647 if (data.mask == NULL)
17648 {
17649 hc_timer_set (&data.timer_running);
17650
17651 data.mask = masks[0];
17652 }
17653 }
17654
17655 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17656 {
17657 data.devices_status = STATUS_EXHAUSTED;
17658 }
17659
17660 // if cracked / aborted remove last induction dictionary
17661
17662 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
17663 {
17664 struct stat induct_stat;
17665
17666 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
17667 {
17668 unlink (induction_dictionaries[file_pos]);
17669 }
17670 }
17671
17672 // wait for non-interactive threads
17673
17674 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
17675 {
17676 hc_thread_wait (1, &ni_threads[thread_idx]);
17677 }
17678
17679 local_free (ni_threads);
17680
17681 // wait for interactive threads
17682
17683 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17684 {
17685 hc_thread_wait (1, &i_thread);
17686 }
17687
17688 // we dont need restore file anymore
17689 if (data.restore_disable == 0)
17690 {
17691 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
17692 {
17693 unlink (eff_restore_file);
17694 unlink (new_restore_file);
17695 }
17696 else
17697 {
17698 cycle_restore ();
17699 }
17700 }
17701
17702 // finally save left hashes
17703
17704 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
17705 {
17706 save_hash ();
17707 }
17708
17709 /**
17710 * Clean up
17711 */
17712
17713 if (benchmark == 1)
17714 {
17715 status_benchmark ();
17716
17717 log_info ("");
17718 }
17719 else
17720 {
17721 if (quiet == 0) clear_prompt ();
17722
17723 if (quiet == 0) log_info ("");
17724
17725 if (status == 1)
17726 {
17727 status_display ();
17728 }
17729 else
17730 {
17731 if (quiet == 0) status_display ();
17732 }
17733
17734 if (quiet == 0) log_info ("");
17735 }
17736
17737 for (uint device_id = 0; device_id < devices_cnt; device_id++)
17738 {
17739 hc_device_param_t *device_param = &data.devices_param[device_id];
17740
17741 local_free (device_param->result);
17742
17743 local_free (device_param->pw_caches);
17744
17745 local_free (device_param->combs_buf);
17746
17747 local_free (device_param->hooks_buf);
17748
17749 #ifdef _CUDA
17750 hc_cuCtxPushCurrent (device_param->context);
17751
17752 if (device_param->pws_buf) myfree (device_param->pws_buf);
17753 if (device_param->d_pws_buf) hc_cuMemFree (device_param->d_pws_buf);
17754 if (device_param->d_pws_amp_buf) hc_cuMemFree (device_param->d_pws_amp_buf);
17755 if (device_param->d_rules) hc_cuMemFree (device_param->d_rules);
17756 if (device_param->d_combs) hc_cuMemFree (device_param->d_combs);
17757 if (device_param->d_bfs) hc_cuMemFree (device_param->d_bfs);
17758 if (device_param->d_bitmap_s1_a) hc_cuMemFree (device_param->d_bitmap_s1_a);
17759 if (device_param->d_bitmap_s1_b) hc_cuMemFree (device_param->d_bitmap_s1_b);
17760 if (device_param->d_bitmap_s1_c) hc_cuMemFree (device_param->d_bitmap_s1_c);
17761 if (device_param->d_bitmap_s1_d) hc_cuMemFree (device_param->d_bitmap_s1_d);
17762 if (device_param->d_bitmap_s2_a) hc_cuMemFree (device_param->d_bitmap_s2_a);
17763 if (device_param->d_bitmap_s2_b) hc_cuMemFree (device_param->d_bitmap_s2_b);
17764 if (device_param->d_bitmap_s2_c) hc_cuMemFree (device_param->d_bitmap_s2_c);
17765 if (device_param->d_bitmap_s2_d) hc_cuMemFree (device_param->d_bitmap_s2_d);
17766 if (device_param->d_plain_bufs) hc_cuMemFree (device_param->d_plain_bufs);
17767 if (device_param->d_digests_buf) hc_cuMemFree (device_param->d_digests_buf);
17768 if (device_param->d_digests_shown) hc_cuMemFree (device_param->d_digests_shown);
17769 if (device_param->d_salt_bufs) hc_cuMemFree (device_param->d_salt_bufs);
17770 if (device_param->d_esalt_bufs) hc_cuMemFree (device_param->d_esalt_bufs);
17771 if (device_param->d_tmps) hc_cuMemFree (device_param->d_tmps);
17772 if (device_param->d_hooks) hc_cuMemFree (device_param->d_hooks);
17773 if (device_param->d_result) hc_cuMemFree (device_param->d_result);
17774 if (device_param->d_scryptV_buf) hc_cuMemFree (device_param->d_scryptV_buf);
17775 if (device_param->d_root_css_buf) hc_cuMemFree (device_param->d_root_css_buf);
17776 if (device_param->d_markov_css_buf) hc_cuMemFree (device_param->d_markov_css_buf);
17777
17778 if (device_param->stream) hc_cuStreamDestroy (device_param->stream);
17779 if (device_param->module) hc_cuModuleUnload (device_param->module);
17780
17781 hc_cuCtxPopCurrent (&device_param->context);
17782
17783 if (device_param->context) hc_cuCtxDestroy (device_param->context);
17784
17785 #elif _OCL
17786 local_free (device_param->device_name);
17787
17788 local_free (device_param->device_version);
17789
17790 local_free (device_param->driver_version);
17791
17792 if (device_param->pws_buf) myfree (device_param->pws_buf);
17793 if (device_param->d_pws_buf) hc_clReleaseMemObject (device_param->d_pws_buf);
17794 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (device_param->d_pws_amp_buf);
17795 if (device_param->d_rules) hc_clReleaseMemObject (device_param->d_rules);
17796 if (device_param->d_rules_c) hc_clReleaseMemObject (device_param->d_rules_c);
17797 if (device_param->d_combs) hc_clReleaseMemObject (device_param->d_combs);
17798 if (device_param->d_combs_c) hc_clReleaseMemObject (device_param->d_combs_c);
17799 if (device_param->d_bfs) hc_clReleaseMemObject (device_param->d_bfs);
17800 if (device_param->d_bfs_c) hc_clReleaseMemObject (device_param->d_bfs_c);
17801 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (device_param->d_bitmap_s1_a);
17802 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (device_param->d_bitmap_s1_b);
17803 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (device_param->d_bitmap_s1_c);
17804 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (device_param->d_bitmap_s1_d);
17805 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (device_param->d_bitmap_s2_a);
17806 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (device_param->d_bitmap_s2_b);
17807 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (device_param->d_bitmap_s2_c);
17808 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (device_param->d_bitmap_s2_d);
17809 if (device_param->d_plain_bufs) hc_clReleaseMemObject (device_param->d_plain_bufs);
17810 if (device_param->d_digests_buf) hc_clReleaseMemObject (device_param->d_digests_buf);
17811 if (device_param->d_digests_shown) hc_clReleaseMemObject (device_param->d_digests_shown);
17812 if (device_param->d_salt_bufs) hc_clReleaseMemObject (device_param->d_salt_bufs);
17813 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (device_param->d_esalt_bufs);
17814 if (device_param->d_tmps) hc_clReleaseMemObject (device_param->d_tmps);
17815 if (device_param->d_hooks) hc_clReleaseMemObject (device_param->d_hooks);
17816 if (device_param->d_result) hc_clReleaseMemObject (device_param->d_result);
17817 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (device_param->d_scryptV_buf);
17818 if (device_param->d_root_css_buf) hc_clReleaseMemObject (device_param->d_root_css_buf);
17819 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (device_param->d_markov_css_buf);
17820
17821 if (device_param->kernel1) hc_clReleaseKernel (device_param->kernel1);
17822 if (device_param->kernel12) hc_clReleaseKernel (device_param->kernel12);
17823 if (device_param->kernel2) hc_clReleaseKernel (device_param->kernel2);
17824 if (device_param->kernel23) hc_clReleaseKernel (device_param->kernel23);
17825 if (device_param->kernel3) hc_clReleaseKernel (device_param->kernel3);
17826 if (device_param->kernel_mp) hc_clReleaseKernel (device_param->kernel_mp);
17827 if (device_param->kernel_mp_l) hc_clReleaseKernel (device_param->kernel_mp_l);
17828 if (device_param->kernel_mp_r) hc_clReleaseKernel (device_param->kernel_mp_r);
17829
17830 if (device_param->program) hc_clReleaseProgram (device_param->program);
17831 if (device_param->program_mp) hc_clReleaseProgram (device_param->program_mp);
17832 if (device_param->command_queue) hc_clReleaseCommandQueue (device_param->command_queue);
17833 if (device_param->context) hc_clReleaseContext (device_param->context);
17834 #endif
17835 }
17836
17837 #ifdef _OCL
17838 #ifndef OSX
17839
17840 // reset default fan speed
17841
17842 if (gpu_temp_disable == 0)
17843 {
17844 if (gpu_temp_retain != 0)
17845 {
17846 hc_thread_mutex_lock (mux_adl);
17847
17848 for (uint i = 0; i < data.devices_cnt; i++)
17849 {
17850 if (data.hm_device[i].fan_supported == 1)
17851 {
17852 int fanspeed = temp_retain_fanspeed_value[i];
17853
17854 if (fanspeed == -1) continue;
17855
17856 int rc = hm_set_fanspeed_with_device_id (i, fanspeed);
17857
17858 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", i);
17859 }
17860 }
17861
17862 hc_thread_mutex_unlock (mux_adl);
17863 }
17864 }
17865
17866 // reset power tuning
17867
17868 if (powertune_enable == 1)
17869 {
17870 hc_thread_mutex_lock (mux_adl);
17871
17872 for (uint i = 0; i < data.devices_cnt; i++)
17873 {
17874 if (data.hm_device[i].od_version == 6)
17875 {
17876 // check powertune capabilities first, if not available then skip device
17877
17878 int powertune_supported = 0;
17879
17880 if ((hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll, data.hm_device[i].adapter_index, &powertune_supported)) != ADL_OK)
17881 {
17882 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
17883
17884 return (-1);
17885 }
17886
17887 if (powertune_supported != 0)
17888 {
17889 // powercontrol settings
17890
17891 if ((hc_ADL_Overdrive_PowerControl_Set (data.hm_dll, data.hm_device[i].adapter_index, od_power_control_status[i])) != ADL_OK)
17892 {
17893 log_info ("ERROR: Failed to restore the ADL PowerControl values");
17894
17895 return (-1);
17896 }
17897
17898 // clocks
17899
17900 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
17901
17902 performance_state->iNumberOfPerformanceLevels = 2;
17903
17904 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[i].state.aLevels[0].iEngineClock;
17905 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[i].state.aLevels[1].iEngineClock;
17906 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[i].state.aLevels[0].iMemoryClock;
17907 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[i].state.aLevels[1].iMemoryClock;
17908
17909 if ((hc_ADL_Overdrive_State_Set (data.hm_dll, data.hm_device[i].adapter_index, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
17910 {
17911 log_info ("ERROR: Failed to restore ADL performance state");
17912
17913 return (-1);
17914 }
17915
17916 local_free (performance_state);
17917 }
17918 }
17919 }
17920
17921 hc_thread_mutex_unlock (mux_adl);
17922 }
17923
17924 #endif
17925 #endif
17926
17927 if (gpu_temp_disable == 0)
17928 {
17929 #ifdef _CUDA
17930 #ifdef LINUX
17931 hc_NVML_nvmlShutdown ();
17932 #endif
17933
17934 #ifdef WIN
17935 NvAPI_Unload ();
17936 #endif
17937 #endif
17938
17939 #ifdef _OCL
17940 #ifndef OSX
17941 hc_ADL_Main_Control_Destroy (data.hm_dll);
17942
17943 hm_close (data.hm_dll);
17944 #endif
17945 #endif
17946 }
17947
17948 // free memory
17949
17950 local_free (masks);
17951
17952 local_free (dictstat_base);
17953
17954 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17955 {
17956 pot_t *pot_ptr = &pot[pot_pos];
17957
17958 hash_t *hash = &pot_ptr->hash;
17959
17960 local_free (hash->digest);
17961
17962 if (isSalted)
17963 {
17964 local_free (hash->salt);
17965 }
17966 }
17967
17968 local_free (pot);
17969
17970 local_free (all_gpu_rules_cnt);
17971 local_free (all_gpu_rules_buf);
17972
17973 local_free (wl_data->buf);
17974 local_free (wl_data);
17975
17976 local_free (bitmap_s1_a);
17977 local_free (bitmap_s1_b);
17978 local_free (bitmap_s1_c);
17979 local_free (bitmap_s1_d);
17980 local_free (bitmap_s2_a);
17981 local_free (bitmap_s2_b);
17982 local_free (bitmap_s2_c);
17983 local_free (bitmap_s2_d);
17984
17985 #ifdef _OCL
17986 #ifndef OSX
17987 local_free (temp_retain_fanspeed_value);
17988 local_free (od_clock_mem_status);
17989 local_free (od_power_control_status);
17990 #endif
17991 #endif
17992
17993 global_free (devices_param);
17994
17995 global_free (gpu_rules_buf);
17996
17997 global_free (root_css_buf);
17998 global_free (markov_css_buf);
17999
18000 global_free (digests_buf);
18001 global_free (digests_shown);
18002 global_free (digests_shown_tmp);
18003
18004 global_free (salts_buf);
18005 global_free (salts_shown);
18006
18007 global_free (esalts_buf);
18008
18009 global_free (words_progress_done);
18010 global_free (words_progress_rejected);
18011 global_free (words_progress_restored);
18012
18013 if (pot_fp) fclose (pot_fp);
18014
18015 if (data.devices_status == STATUS_QUIT) break;
18016 }
18017
18018 // destroy others mutex
18019
18020 hc_thread_mutex_delete (mux_dispatcher);
18021 hc_thread_mutex_delete (mux_counter);
18022 hc_thread_mutex_delete (mux_display);
18023 hc_thread_mutex_delete (mux_adl);
18024
18025 // free memory
18026
18027 local_free (eff_restore_file);
18028 local_free (new_restore_file);
18029
18030 local_free (rd);
18031
18032 // loopback
18033
18034 local_free (loopback_file);
18035
18036 if (loopback == 1) unlink (loopback_file);
18037
18038 // induction directory
18039
18040 if (induction_dir == NULL)
18041 {
18042 if (attack_mode != ATTACK_MODE_BF)
18043 {
18044 if (rmdir (induction_directory) == -1)
18045 {
18046 if (errno == ENOENT)
18047 {
18048 // good, we can ignore
18049 }
18050 else if (errno == ENOTEMPTY)
18051 {
18052 // good, we can ignore
18053 }
18054 else
18055 {
18056 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
18057
18058 return (-1);
18059 }
18060 }
18061
18062 local_free (induction_directory);
18063 }
18064 }
18065
18066 // outfile-check directory
18067
18068 if (outfile_check_dir == NULL)
18069 {
18070 if (rmdir (outfile_check_directory) == -1)
18071 {
18072 if (errno == ENOENT)
18073 {
18074 // good, we can ignore
18075 }
18076 else if (errno == ENOTEMPTY)
18077 {
18078 // good, we can ignore
18079 }
18080 else
18081 {
18082 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
18083
18084 return (-1);
18085 }
18086 }
18087
18088 local_free (outfile_check_directory);
18089 }
18090
18091 time_t proc_stop;
18092
18093 time (&proc_stop);
18094
18095 logfile_top_uint (proc_start);
18096 logfile_top_uint (proc_stop);
18097
18098 logfile_top_msg ("STOP");
18099
18100 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18101 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18102
18103 if (data.devices_status == STATUS_ABORTED) return 2;
18104 if (data.devices_status == STATUS_QUIT) return 2;
18105 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18106 if (data.devices_status == STATUS_EXHAUSTED) return 1;
18107 if (data.devices_status == STATUS_CRACKED) return 0;
18108
18109 return -1;
18110 }
Hashcat additions to support pwdhash