projects / hashcat.git / blob
? search:


c0f1908584d82523d8f482562f17890fe105eabb
[hashcat.git] / src / oclHashcat.c
1 /**
2 * Author......: Jens Steube <jens.steube@gmail.com>
3 * License.....: MIT
4 */
5
6 #include <common.h>
7 #include <shared.h>
8 #include <rp_gpu_on_cpu.h>
9 #include <getopt.h>
10
11 const char *PROGNAME = "oclHashcat";
12 const char *VERSION_TXT = "2.01";
13 const uint VERSION_BIN = 201;
14 const uint RESTORE_MIN = 201;
15
16 #define INCR_RULES 10000
17 #define INCR_SALTS 100000
18 #define INCR_MASKS 1000
19 #define INCR_POT 1000
20
21 // comment-out for kernel source mode
22
23 //#define BINARY_KERNEL
24
25 #define USAGE 0
26 #define VERSION 0
27 #define QUIET 0
28 #define MARKOV_THRESHOLD 0
29 #define MARKOV_DISABLE 0
30 #define MARKOV_CLASSIC 0
31 #define BENCHMARK 0
32 #define BENCHMARK_MODE 1
33 #define RESTORE 0
34 #define RESTORE_TIMER 60
35 #define RESTORE_DISABLE 0
36 #define STATUS 0
37 #define STATUS_TIMER 10
38 #define STATUS_AUTOMAT 0
39 #define LOOPBACK 0
40 #define WEAK_HASH_THRESHOLD 100
41 #define SHOW 0
42 #define LEFT 0
43 #define USERNAME 0
44 #define REMOVE 0
45 #define REMOVE_TIMER 60
46 #define SKIP 0
47 #define LIMIT 0
48 #define KEYSPACE 0
49 #define POTFILE_DISABLE 0
50 #define DEBUG_MODE 0
51 #define RP_GEN 0
52 #define RP_GEN_FUNC_MIN 1
53 #define RP_GEN_FUNC_MAX 4
54 #define RP_GEN_SEED 0
55 #define RULE_BUF_L ":"
56 #define RULE_BUF_R ":"
57 #define FORCE 0
58 #define RUNTIME 0
59 #define HEX_CHARSET 0
60 #define HEX_SALT 0
61 #define HEX_WORDLIST 0
62 #define OUTFILE_FORMAT 3
63 #define OUTFILE_AUTOHEX 1
64 #define OUTFILE_CHECK_TIMER 5
65 #define ATTACK_MODE 0
66 #define HASH_MODE 0
67 #define SEGMENT_SIZE 32
68 #define INCREMENT 0
69 #define INCREMENT_MIN 1
70 #define INCREMENT_MAX PW_MAX
71 #define SEPARATOR ':'
72 #define BITMAP_MIN 16
73 #define BITMAP_MAX 24
74 #define GPU_TEMP_DISABLE 0
75 #define GPU_TEMP_ABORT 90
76 #define GPU_TEMP_RETAIN 80
77 #define WORKLOAD_PROFILE 2
78 #define GPU_ACCEL 0
79 #define GPU_LOOPS 0
80 #define GPU_RULES 1024
81 #define GPU_COMBS 1024
82 #define GPU_BFS 1024
83 #define GPU_THREADS 64
84 #define POWERTUNE_ENABLE 0
85 #define LOGFILE_DISABLE 0
86 #define SCRYPT_TMTO 0
87
88 #define WL_MODE_STDIN 1
89 #define WL_MODE_FILE 2
90 #define WL_MODE_MASK 3
91
92 #define HL_MODE_FILE 4
93 #define HL_MODE_ARG 5
94
95 #define HLFMT_HASHCAT 0
96 #define HLFMT_PWDUMP 1
97 #define HLFMT_PASSWD 2
98 #define HLFMT_SHADOW 3
99 #define HLFMT_DCC 4
100 #define HLFMT_DCC2 5
101 #define HLFMT_NETNTLM1 7
102 #define HLFMT_NETNTLM2 8
103 #define HLFMT_NSLDAP 9
104 #define HLFMT_NSLDAPS 10
105 #define HLFMTS_CNT 11
106
107 #define ATTACK_MODE_STRAIGHT 0
108 #define ATTACK_MODE_COMBI 1
109 #define ATTACK_MODE_TOGGLE 2
110 #define ATTACK_MODE_BF 3
111 #define ATTACK_MODE_PERM 4
112 #define ATTACK_MODE_TABLE 5
113 #define ATTACK_MODE_HYBRID1 6
114 #define ATTACK_MODE_HYBRID2 7
115 #define ATTACK_MODE_NONE 100
116
117 #define ATTACK_KERN_STRAIGHT 0
118 #define ATTACK_KERN_COMBI 1
119 #define ATTACK_KERN_BF 3
120 #define ATTACK_KERN_NONE 100
121
122 #define ATTACK_EXEC_ON_CPU 10
123 #define ATTACK_EXEC_ON_GPU 11
124
125 #define COMBINATOR_MODE_BASE_LEFT 10001
126 #define COMBINATOR_MODE_BASE_RIGHT 10002
127
128 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
129 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
130
131 #define MAX_CUT_TRIES 4
132
133 #define MAX_DICTSTAT 10000
134
135 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 128
136
137 #define global_free(attr) \
138 { \
139 myfree ((void *) data.attr); \
140 \
141 data.attr = NULL; \
142 }
143
144 #define local_free(attr) \
145 { \
146 myfree ((void *) attr); \
147 \
148 attr = NULL; \
149 }
150
151 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
152 {
153 900,
154 0,
155 5100,
156 100,
157 1400,
158 10800,
159 1700,
160 5000,
161 10100,
162 6000,
163 6100,
164 6900,
165 11700,
166 11800,
167 400,
168 8900,
169 11900,
170 12000,
171 10900,
172 12100,
173 23,
174 2500,
175 5300,
176 5400,
177 5500,
178 5600,
179 7300,
180 7500,
181 8300,
182 11100,
183 11200,
184 11400,
185 121,
186 2611,
187 2711,
188 2811,
189 8400,
190 11,
191 2612,
192 7900,
193 21,
194 11000,
195 124,
196 10000,
197 3711,
198 7600,
199 12,
200 131,
201 132,
202 1731,
203 200,
204 300,
205 3100,
206 112,
207 12300,
208 8000,
209 141,
210 1441,
211 1600,
212 12600,
213 1421,
214 101,
215 111,
216 1711,
217 3000,
218 1000,
219 1100,
220 2100,
221 12800,
222 1500,
223 12400,
224 500,
225 3200,
226 7400,
227 1800,
228 122,
229 1722,
230 7100,
231 6300,
232 6700,
233 6400,
234 6500,
235 2400,
236 2410,
237 5700,
238 9200,
239 9300,
240 22,
241 501,
242 5800,
243 8100,
244 8500,
245 7200,
246 9900,
247 7700,
248 7800,
249 10300,
250 8600,
251 8700,
252 9100,
253 133,
254 11600,
255 12500,
256 6211,
257 6221,
258 6231,
259 6241,
260 8800,
261 12200,
262 9700,
263 9710,
264 9800,
265 9810,
266 9400,
267 9500,
268 9600,
269 10400,
270 10410,
271 10500,
272 10600,
273 10700,
274 9000,
275 5200,
276 6800,
277 6600,
278 8200,
279 11300,
280 12700
281 };
282
283 /**
284 * types
285 */
286
287 static void (*get_next_word_func) (char *, uint32_t, uint32_t *, uint32_t *);
288
289 /**
290 * globals
291 */
292
293 static unsigned int full01 = 0x01010101;
294 static unsigned int full80 = 0x80808080;
295
296 int SUPPRESS_OUTPUT = 0;
297
298 hc_thread_mutex_t mux_adl;
299 hc_thread_mutex_t mux_counter;
300 hc_thread_mutex_t mux_dispatcher;
301 hc_thread_mutex_t mux_display;
302
303 hc_global_data_t data;
304
305 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
306
307 const char *USAGE_MINI[] =
308 {
309 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
310 "",
311 "Try --help for more help.",
312 NULL
313 };
314
315 const char *USAGE_BIG[] =
316 {
317 "%s, advanced password recovery",
318 "",
319 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
320 "",
321 "=======",
322 "Options",
323 "=======",
324 "",
325 "* General:",
326 "",
327 " -m, --hash-type=NUM Hash-type, see references below",
328 " -a, --attack-mode=NUM Attack-mode, see references below",
329 " -V, --version Print version",
330 " -h, --help Print help",
331 " --quiet Suppress output",
332 "",
333 "* Benchmark:",
334 "",
335 " -b, --benchmark Run benchmark",
336 " --benchmark-mode=NUM Benchmark-mode, see references below",
337 "",
338 "* Misc:",
339 "",
340 " --hex-charset Assume charset is given in hex",
341 " --hex-salt Assume salt is given in hex",
342 " --hex-wordlist Assume words in wordlist is given in hex",
343 " --force Ignore warnings",
344 " --status Enable automatic update of the status-screen",
345 " --status-timer=NUM Seconds between status-screen update",
346 " --status-automat Display the status view in a machine readable format",
347 " --loopback Add new plains to induct directory",
348 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
349 "",
350 "* Markov:",
351 "",
352 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
353 " --markov-disable Disables markov-chains, emulates classic brute-force",
354 " --markov-classic Enables classic markov-chains, no per-position enhancement",
355 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
356 "",
357 "* Session:",
358 "",
359 " --runtime=NUM Abort session after NUM seconds of runtime",
360 " --session=STR Define specific session name",
361 " --restore Restore session from --session",
362 " --restore-disable Do not write restore file",
363 "",
364 "* Files:",
365 "",
366 " -o, --outfile=FILE Define outfile for recovered hash",
367 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
368 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
369 " --outfile-check-timer=NUM Seconds between outfile checks",
370 " -p, --separator=CHAR Separator char for hashlists and outfile",
371 " --show Show cracked passwords only",
372 " --left Show un-cracked passwords only",
373 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
374 " --remove Enable remove of hash once it is cracked",
375 " --remove-timer=NUM Update input hash file each NUM seconds",
376 " --potfile-disable Do not write potfile",
377 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
378 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
379 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
380 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
381 " --logfile-disable Disable the logfile",
382 " --truecrypt-keyfiles=FILE Keyfiles used, seperate with comma",
383 "",
384 "* Resources:",
385 "",
386 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
387 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
388 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
389 " --cpu-affinity=STR Locks to CPU devices, seperate with comma",
390 " -d, --gpu-devices=STR Devices to use, separate with comma",
391 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
392 " -n, --gpu-accel=NUM Workload tuning: 1, 8, 40, 80, 160",
393 " -u, --gpu-loops=NUM Workload fine-tuning: 8 - 1024",
394 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
395 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
396 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
397 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
398 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
399 "",
400 "* Distributed:",
401 "",
402 " -s, --skip=NUM Skip number of words",
403 " -l, --limit=NUM Limit number of words",
404 " --keyspace Show keyspace base:mod values and quit",
405 "",
406 "* Rules:",
407 "",
408 " -j, --rule-left=RULE Single rule applied to each word from left dict",
409 " -k, --rule-right=RULE Single rule applied to each word from right dict",
410 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
411 " -g, --generate-rules=NUM Generate NUM random rules",
412 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
413 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
414 " --generate-rules-seed=NUM Force RNG seed to NUM",
415 "",
416 "* Custom charsets:",
417 "",
418 " -1, --custom-charset1=CS User-defined charsets",
419 " -2, --custom-charset2=CS Example:",
420 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
421 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
422 "",
423 "* Increment:",
424 "",
425 " -i, --increment Enable increment mode",
426 " --increment-min=NUM Start incrementing at NUM",
427 " --increment-max=NUM Stop incrementing at NUM",
428 "",
429 "==========",
430 "References",
431 "==========",
432 "",
433 "* Workload Profile:",
434 "",
435 " 1 = Reduced performance profile (low latency desktop)",
436 " 2 = Default performance profile",
437 " 3 = Tuned performance profile (high latency desktop)",
438 "",
439 "* Benchmark Settings:",
440 "",
441 " 0 = Manual Tuning",
442 " 1 = Performance Tuning, default",
443 "",
444 "* Outfile Formats:",
445 "",
446 " 1 = hash[:salt]",
447 " 2 = plain",
448 " 3 = hash[:salt]:plain",
449 " 4 = hex_plain",
450 " 5 = hash[:salt]:hex_plain",
451 " 6 = plain:hex_plain",
452 " 7 = hash[:salt]:plain:hex_plain",
453 " 8 = crackpos",
454 " 9 = hash[:salt]:crackpos",
455 " 10 = plain:crackpos",
456 " 11 = hash[:salt]:plain:crackpos",
457 " 12 = hex_plain:crackpos",
458 " 13 = hash[:salt]:hex_plain:crackpos",
459 " 14 = plain:hex_plain:crackpos",
460 " 15 = hash[:salt]:plain:hex_plain:crackpos",
461 "",
462 "* Debug mode output formats (for hybrid mode only, by using rules):",
463 "",
464 " 1 = save finding rule",
465 " 2 = save original word",
466 " 3 = save original word and finding rule",
467 " 4 = save original word, finding rule and modified plain",
468 "",
469 "* Built-in charsets:",
470 "",
471 " ?l = abcdefghijklmnopqrstuvwxyz",
472 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
473 " ?d = 0123456789",
474 " ?s = !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~",
475 " ?a = ?l?u?d?s",
476 " ?b = 0x00 - 0xff",
477 "",
478 "* Attack modes:",
479 "",
480 " 0 = Straight",
481 " 1 = Combination",
482 " 3 = Brute-force",
483 " 6 = Hybrid dict + mask",
484 " 7 = Hybrid mask + dict",
485 "",
486 "* Hash types:",
487 "",
488 "[[ Roll-your-own: Raw Hashes ]]",
489 "",
490 " 900 = MD4",
491 " 0 = MD5",
492 " 5100 = Half MD5",
493 " 100 = SHA1",
494 " 10800 = SHA-384",
495 " 1400 = SHA-256",
496 " 1700 = SHA-512",
497 " 5000 = SHA-3(Keccak)",
498 " 10100 = SipHash",
499 " 6000 = RipeMD160",
500 " 6100 = Whirlpool",
501 " 6900 = GOST R 34.11-94",
502 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
503 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
504 "",
505 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
506 "",
507 " 10 = md5($pass.$salt)",
508 " 20 = md5($salt.$pass)",
509 " 30 = md5(unicode($pass).$salt)",
510 " 40 = md5($salt.unicode($pass))",
511 " 3800 = md5($salt.$pass.$salt)",
512 " 3710 = md5($salt.md5($pass))",
513 " 2600 = md5(md5($pass)",
514 " 4300 = md5(strtoupper(md5($pass)))",
515 " 4400 = md5(sha1($pass))",
516 " 110 = sha1($pass.$salt)",
517 " 120 = sha1($salt.$pass)",
518 " 130 = sha1(unicode($pass).$salt)",
519 " 140 = sha1($salt.unicode($pass))",
520 " 4500 = sha1(sha1($pass)",
521 " 4700 = sha1(md5($pass))",
522 " 4900 = sha1($salt.$pass.$salt)",
523 " 1410 = sha256($pass.$salt)",
524 " 1420 = sha256($salt.$pass)",
525 " 1430 = sha256(unicode($pass).$salt)",
526 " 1440 = sha256($salt.unicode($pass))",
527 " 1710 = sha512($pass.$salt)",
528 " 1720 = sha512($salt.$pass)",
529 " 1730 = sha512(unicode($pass).$salt)",
530 " 1740 = sha512($salt.unicode($pass))",
531 "",
532 "[[ Roll-your-own: Authenticated Hashes ]]",
533 "",
534 " 50 = HMAC-MD5 (key = $pass)",
535 " 60 = HMAC-MD5 (key = $salt)",
536 " 150 = HMAC-SHA1 (key = $pass)",
537 " 160 = HMAC-SHA1 (key = $salt)",
538 " 1450 = HMAC-SHA256 (key = $pass)",
539 " 1460 = HMAC-SHA256 (key = $salt)",
540 " 1750 = HMAC-SHA512 (key = $pass)",
541 " 1760 = HMAC-SHA512 (key = $salt)",
542 "",
543 "[[ Generic KDF ]]",
544 "",
545 " 400 = phpass",
546 " 8900 = scrypt",
547 " 11900 = PBKDF2-HMAC-MD5",
548 " 12000 = PBKDF2-HMAC-SHA1",
549 " 10900 = PBKDF2-HMAC-SHA256",
550 " 12100 = PBKDF2-HMAC-SHA512",
551 "",
552 "[[ Network protocols, Challenge-Response ]]",
553 "",
554 " 23 = Skype",
555 " 2500 = WPA/WPA2",
556 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
557 " 5300 = IKE-PSK MD5",
558 " 5400 = IKE-PSK SHA1",
559 " 5500 = NetNTLMv1",
560 " 5500 = NetNTLMv1 + ESS",
561 " 5600 = NetNTLMv2",
562 " 7300 = IPMI2 RAKP HMAC-SHA1",
563 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
564 " 8300 = DNSSEC (NSEC3)",
565 " 10200 = Cram MD5",
566 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
567 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
568 " 11400 = SIP digest authentication (MD5)",
569 "",
570 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
571 "",
572 " 121 = SMF (Simple Machines Forum)",
573 " 400 = phpBB3",
574 " 2611 = vBulletin < v3.8.5",
575 " 2711 = vBulletin > v3.8.5",
576 " 2811 = MyBB",
577 " 2811 = IPB (Invison Power Board)",
578 " 8400 = WBB3 (Woltlab Burning Board)",
579 " 11 = Joomla < 2.5.18",
580 " 400 = Joomla > 2.5.18",
581 " 400 = Wordpress",
582 " 2612 = PHPS",
583 " 7900 = Drupal7",
584 " 21 = osCommerce",
585 " 21 = xt:Commerce",
586 " 11000 = PrestaShop",
587 " 124 = Django (SHA-1)",
588 " 10000 = Django (PBKDF2-SHA256)",
589 " 3711 = Mediawiki B type",
590 " 7600 = Redmine",
591 "",
592 "[[ Database Server ]]",
593 "",
594 " 12 = PostgreSQL",
595 " 131 = MSSQL(2000)",
596 " 132 = MSSQL(2005)",
597 " 1731 = MSSQL(2012)",
598 " 1731 = MSSQL(2014)",
599 " 200 = MySQL323",
600 " 300 = MySQL4.1/MySQL5",
601 " 3100 = Oracle H: Type (Oracle 7+)",
602 " 112 = Oracle S: Type (Oracle 11+)",
603 " 12300 = Oracle T: Type (Oracle 12+)",
604 " 8000 = Sybase ASE",
605 "",
606 "[[ HTTP, SMTP, LDAP Server]]",
607 "",
608 " 141 = EPiServer 6.x < v4",
609 " 1441 = EPiServer 6.x > v4",
610 " 1600 = Apache $apr1$",
611 " 12600 = ColdFusion 10+",
612 " 1421 = hMailServer",
613 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
614 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
615 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
616 "",
617 "[[ Checksums ]]",
618 "",
619 " 11500 = CRC32",
620 "",
621 "[[ Operating-Systems ]]",
622 "",
623 " 3000 = LM",
624 " 1000 = NTLM",
625 " 1100 = Domain Cached Credentials (DCC), MS Cache",
626 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
627 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
628 " 1500 = descrypt, DES(Unix), Traditional DES",
629 " 12400 = BSDiCrypt, Extended DES",
630 " 500 = md5crypt $1$, MD5(Unix)",
631 " 3200 = bcrypt $2*$, Blowfish(Unix)",
632 " 7400 = sha256crypt $5$, SHA256(Unix)",
633 " 1800 = sha512crypt $6$, SHA512(Unix)",
634 " 122 = OSX v10.4",
635 " 122 = OSX v10.5",
636 " 122 = OSX v10.6",
637 " 1722 = OSX v10.7",
638 " 7100 = OSX v10.8",
639 " 7100 = OSX v10.9",
640 " 7100 = OSX v10.10",
641 " 6300 = AIX {smd5}",
642 " 6700 = AIX {ssha1}",
643 " 6400 = AIX {ssha256}",
644 " 6500 = AIX {ssha512}",
645 " 2400 = Cisco-PIX",
646 " 2410 = Cisco-ASA",
647 " 500 = Cisco-IOS $1$",
648 " 5700 = Cisco-IOS $4$",
649 " 9200 = Cisco-IOS $8$",
650 " 9300 = Cisco-IOS $9$",
651 " 22 = Juniper Netscreen/SSG (ScreenOS)",
652 " 501 = Juniper IVE",
653 " 5800 = Android PIN",
654 " 8100 = Citrix Netscaler",
655 " 8500 = RACF",
656 " 7200 = GRUB 2",
657 " 9900 = Radmin2",
658 "",
659 "[[ Enterprise Application Software (EAS) ]]",
660 "",
661 " 7700 = SAP CODVN B (BCODE)",
662 " 7800 = SAP CODVN F/G (PASSCODE)",
663 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
664 " 8600 = Lotus Notes/Domino 5",
665 " 8700 = Lotus Notes/Domino 6",
666 " 9100 = Lotus Notes/Domino 8",
667 " 133 = PeopleSoft",
668 "",
669 "[[ Archives ]]",
670 "",
671 " 11600 = 7-Zip",
672 " 12500 = RAR3-hp",
673 "",
674 "[[ Full-Disk encryptions (FDE) ]]",
675 "",
676 " 62XY = TrueCrypt 5.0+",
677 " X = 1 = PBKDF2-HMAC-RipeMD160",
678 " X = 2 = PBKDF2-HMAC-SHA512",
679 " X = 3 = PBKDF2-HMAC-Whirlpool",
680 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
681 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
682 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
683 " Y = 3 = XTS 1536 bit (Ciphers: All)",
684 " 8800 = Android FDE < v4.3",
685 " 12200 = eCryptfs",
686 "",
687 "[[ Documents ]]",
688 "",
689 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
690 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
691 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
692 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
693 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
694 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
695 " 9400 = MS Office 2007",
696 " 9500 = MS Office 2010",
697 " 9600 = MS Office 2013",
698 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
699 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
700 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
701 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
702 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
703 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
704 "",
705 "[[ Password Managers ]]",
706 "",
707 " 9000 = Password Safe v2",
708 " 5200 = Password Safe v3",
709 " 6800 = Lastpass",
710 " 6600 = 1Password, agilekeychain",
711 " 8200 = 1Password, cloudkeychain",
712 " 11300 = Bitcoin/Litecoin wallet.dat",
713 " 12700 = Blockchain, My Wallet",
714 "",
715 NULL
716 };
717
718 /**
719 * oclHashcat specific functions
720 */
721
722 void status_display_automat ()
723 {
724 FILE *out = stdout;
725
726 fprintf (out, "STATUS\t%u\t", data.devices_status);
727
728 /**
729 * speed new
730 */
731
732 fprintf (out, "SPEED\t");
733
734 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
735 {
736 hc_device_param_t *device_param = &data.devices_param[device_id];
737
738 uint64_t speed_cnt = 0;
739 float speed_ms = 0;
740
741 for (int i = 0; i < SPEED_CACHE; i++)
742 {
743 float rec_ms;
744
745 hc_timer_get (device_param->speed_rec[i], rec_ms);
746
747 if (rec_ms > SPEED_MAXAGE) continue;
748
749 speed_cnt += device_param->speed_cnt[i];
750 speed_ms += device_param->speed_ms[i];
751 }
752
753 speed_cnt /= SPEED_CACHE;
754 speed_ms /= SPEED_CACHE;
755
756 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
757 }
758
759 /**
760 * words_cur
761 */
762
763 uint64_t words_cur = get_lowest_words_done ();
764
765 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
766
767 /**
768 * counter
769 */
770
771 uint salts_left = data.salts_cnt - data.salts_done;
772
773 if (salts_left == 0) salts_left = 1;
774
775 uint64_t progress_total = data.words_cnt * salts_left;
776
777 uint64_t all_done = 0;
778 uint64_t all_rejected = 0;
779 uint64_t all_restored = 0;
780
781 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
782 {
783 if (salts_left > 1)
784 {
785 // otherwise the final cracked status shows 0/XXX progress
786
787 if (data.salts_shown[salt_pos] == 1) continue;
788 }
789
790 all_done += data.words_progress_done[salt_pos];
791 all_rejected += data.words_progress_rejected[salt_pos];
792 all_restored += data.words_progress_restored[salt_pos];
793 }
794
795 uint64_t progress_cur = all_restored + all_done + all_rejected;
796 uint64_t progress_end = progress_total;
797
798 uint64_t progress_skip = 0;
799
800 if (data.skip)
801 {
802 progress_skip = MIN (data.skip, data.words_base) * salts_left;
803
804 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.gpu_rules_cnt;
805 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
806 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
807 }
808
809 if (data.limit)
810 {
811 progress_end = MIN (data.limit, data.words_base) * salts_left;
812
813 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.gpu_rules_cnt;
814 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
815 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
816 }
817
818 uint64_t progress_cur_relative_skip = progress_cur - progress_skip;
819 uint64_t progress_end_relative_skip = progress_end - progress_skip;
820
821 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
822
823 /**
824 * cracks
825 */
826
827 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
828 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
829
830 /**
831 * temperature
832 */
833
834 /*
835 if (data.gpu_temp_disable == 0)
836 {
837 fprintf (out, "TEMP\t");
838
839 hc_thread_mutex_lock (mux_adl);
840
841 for (uint i = 0; i < data.devices_cnt; i++)
842 {
843 int temp = hm_get_temperature_with_device_id (i);
844
845 fprintf (out, "%d\t", temp);
846 }
847
848 hc_thread_mutex_unlock (mux_adl);
849 }
850 */
851
852 #ifdef _WIN
853 fputc ('\r', out);
854 fputc ('\n', out);
855 #endif
856
857 #ifdef _POSIX
858 fputc ('\n', out);
859 #endif
860
861 fflush (out);
862 }
863
864 void status_display ()
865 {
866 if (data.devices_status == STATUS_INIT) return;
867 if (data.devices_status == STATUS_STARTING) return;
868 if (data.devices_status == STATUS_BYPASS) return;
869
870 if (data.status_automat == 1)
871 {
872 status_display_automat ();
873
874 return;
875 }
876
877 char tmp_buf[1000];
878
879 uint tmp_len = 0;
880
881 log_info ("Session.Name...: %s", data.session);
882
883 char *status_type = strstatus (data.devices_status);
884
885 uint hash_mode = data.hash_mode;
886
887 char *hash_type = strhashtype (hash_mode); // not a bug
888
889 log_info ("Status.........: %s", status_type);
890
891 /**
892 * show rules
893 */
894
895 if (data.rp_files_cnt)
896 {
897 uint i;
898
899 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
900 {
901 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
902 }
903
904 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
905
906 log_info ("Rules.Type.....: %s", tmp_buf);
907
908 tmp_len = 0;
909 }
910
911 if (data.rp_gen)
912 {
913 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
914
915 if (data.rp_gen_seed)
916 {
917 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
918 }
919 }
920
921 /**
922 * show input
923 */
924
925 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
926 {
927 if (data.wordlist_mode == WL_MODE_FILE)
928 {
929 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
930 }
931 else if (data.wordlist_mode == WL_MODE_STDIN)
932 {
933 log_info ("Input.Mode.....: Pipe");
934 }
935 }
936 else if (data.attack_mode == ATTACK_MODE_COMBI)
937 {
938 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
939 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
940 }
941 else if (data.attack_mode == ATTACK_MODE_BF)
942 {
943 char *mask = data.mask;
944
945 if (mask != NULL)
946 {
947 uint mask_len = data.css_cnt;
948
949 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
950
951 if (mask_len > 0)
952 {
953 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
954 {
955 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
956 {
957 mask_len -= data.salts_buf[0].salt_len;
958 }
959 }
960
961 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
962
963 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
964 }
965
966 if (data.maskcnt > 1)
967 {
968 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
969
970 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
971 }
972
973 log_info ("Input.Mode.....: %s", tmp_buf);
974 }
975
976 tmp_len = 0;
977 }
978 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
979 {
980 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
981 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
982 }
983 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
984 {
985 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
986 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
987 }
988
989 if (data.digests_cnt == 1)
990 {
991 if (data.hash_mode == 2500)
992 {
993 wpa_t *wpa = (wpa_t *) data.esalts_buf;
994
995 uint pke[25];
996
997 char *pke_ptr = (char *) pke;
998
999 for (uint i = 0; i < 25; i++)
1000 {
1001 pke[i] = byte_swap_32 (wpa->pke[i]);
1002 }
1003
1004 char mac1[6];
1005 char mac2[6];
1006
1007 memcpy (mac1, pke_ptr + 23, 6);
1008 memcpy (mac2, pke_ptr + 29, 6);
1009
1010 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1011 (char *) data.salts_buf[0].salt_buf,
1012 mac1[0] & 0xff,
1013 mac1[1] & 0xff,
1014 mac1[2] & 0xff,
1015 mac1[3] & 0xff,
1016 mac1[4] & 0xff,
1017 mac1[5] & 0xff,
1018 mac2[0] & 0xff,
1019 mac2[1] & 0xff,
1020 mac2[2] & 0xff,
1021 mac2[3] & 0xff,
1022 mac2[4] & 0xff,
1023 mac2[5] & 0xff);
1024 }
1025 else if (data.hash_mode == 5200)
1026 {
1027 log_info ("Hash.Target....: File (%s)", data.hashfile);
1028 }
1029 else if (data.hash_mode == 9000)
1030 {
1031 log_info ("Hash.Target....: File (%s)", data.hashfile);
1032 }
1033 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1034 {
1035 log_info ("Hash.Target....: File (%s)", data.hashfile);
1036 }
1037 else
1038 {
1039 char out_buf[4096];
1040
1041 ascii_digest (out_buf, 0, 0);
1042
1043 // limit length
1044 if (strlen (out_buf) > 40)
1045 {
1046 out_buf[41] = '.';
1047 out_buf[42] = '.';
1048 out_buf[43] = '.';
1049 out_buf[44] = 0;
1050 }
1051
1052 log_info ("Hash.Target....: %s", out_buf);
1053 }
1054 }
1055 else
1056 {
1057 if (data.hash_mode == 3000)
1058 {
1059 char out_buf1[4096];
1060 char out_buf2[4096];
1061
1062 ascii_digest (out_buf1, 0, 0);
1063 ascii_digest (out_buf2, 0, 1);
1064
1065 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1066 }
1067 else
1068 {
1069 log_info ("Hash.Target....: File (%s)", data.hashfile);
1070 }
1071 }
1072
1073 log_info ("Hash.Type......: %s", hash_type);
1074
1075 /**
1076 * speed new
1077 */
1078
1079 uint64_t speed_cnt[DEVICES_MAX];
1080 float speed_ms[DEVICES_MAX];
1081
1082 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1083 {
1084 hc_device_param_t *device_param = &data.devices_param[device_id];
1085
1086 // we need to clear values (set to 0) because in case the gpu does
1087 // not get new candidates it idles around but speed display would
1088 // show it as working.
1089 // if we instantly set it to 0 after reading it happens that the
1090 // speed can be shown as zero if the users refreshs to fast.
1091 // therefore, we add a timestamp when a stat was recorded and if its
1092 // to old we will not use it
1093
1094 speed_cnt[device_id] = 0;
1095 speed_ms[device_id] = 0;
1096
1097 for (int i = 0; i < SPEED_CACHE; i++)
1098 {
1099 float rec_ms;
1100
1101 hc_timer_get (device_param->speed_rec[i], rec_ms);
1102
1103 if (rec_ms > SPEED_MAXAGE) continue;
1104
1105 speed_cnt[device_id] += device_param->speed_cnt[i];
1106 speed_ms[device_id] += device_param->speed_ms[i];
1107 }
1108
1109 speed_cnt[device_id] /= SPEED_CACHE;
1110 speed_ms[device_id] /= SPEED_CACHE;
1111 }
1112
1113 float hashes_all_ms = 0;
1114
1115 float hashes_dev_ms[DEVICES_MAX];
1116
1117 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1118 {
1119 hashes_dev_ms[device_id] = 0;
1120
1121 if (speed_ms[device_id])
1122 {
1123 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1124
1125 hashes_all_ms += hashes_dev_ms[device_id];
1126 }
1127 }
1128
1129 /**
1130 * timers
1131 */
1132
1133 float ms_running = 0;
1134
1135 hc_timer_get (data.timer_running, ms_running);
1136
1137 float ms_paused = data.ms_paused;
1138
1139 if (data.devices_status == STATUS_PAUSED)
1140 {
1141 float ms_paused_tmp = 0;
1142
1143 hc_timer_get (data.timer_paused, ms_paused_tmp);
1144
1145 ms_paused += ms_paused_tmp;
1146 }
1147
1148 #ifdef WIN
1149
1150 __time64_t sec_run = ms_running / 1000;
1151
1152 #else
1153
1154 time_t sec_run = ms_running / 1000;
1155
1156 #endif
1157
1158 if (sec_run)
1159 {
1160 char display_run[32];
1161
1162 struct tm tm_run;
1163
1164 struct tm *tmp;
1165
1166 #ifdef WIN
1167
1168 tmp = _gmtime64 (&sec_run);
1169
1170 #else
1171
1172 tmp = gmtime (&sec_run);
1173
1174 #endif
1175
1176 if (tmp != NULL)
1177 {
1178 memcpy (&tm_run, tmp, sizeof (struct tm));
1179
1180 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1181
1182 char *start = ctime (&data.proc_start);
1183
1184 size_t start_len = strlen (start);
1185
1186 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1187 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1188
1189 log_info ("Time.Started...: %s (%s)", start, display_run);
1190 }
1191 }
1192 else
1193 {
1194 log_info ("Time.Started...: 0 secs");
1195 }
1196
1197 /**
1198 * counters
1199 */
1200
1201 uint salts_left = data.salts_cnt - data.salts_done;
1202
1203 if (salts_left == 0) salts_left = 1;
1204
1205 uint64_t progress_total = data.words_cnt * salts_left;
1206
1207 uint64_t all_done = 0;
1208 uint64_t all_rejected = 0;
1209 uint64_t all_restored = 0;
1210
1211 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1212 {
1213 if (salts_left > 1)
1214 {
1215 // otherwise the final cracked status shows 0/XXX progress
1216
1217 if (data.salts_shown[salt_pos] == 1) continue;
1218 }
1219
1220 all_done += data.words_progress_done[salt_pos];
1221 all_rejected += data.words_progress_rejected[salt_pos];
1222 all_restored += data.words_progress_restored[salt_pos];
1223 }
1224
1225 uint64_t progress_cur = all_restored + all_done + all_rejected;
1226 uint64_t progress_end = progress_total;
1227
1228 uint64_t progress_skip = 0;
1229
1230 if (data.skip)
1231 {
1232 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1233
1234 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.gpu_rules_cnt;
1235 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1236 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1237 }
1238
1239 if (data.limit)
1240 {
1241 progress_end = MIN (data.limit, data.words_base) * salts_left;
1242
1243 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.gpu_rules_cnt;
1244 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1245 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1246 }
1247
1248 uint64_t progress_cur_relative_skip = progress_cur - progress_skip;
1249 uint64_t progress_end_relative_skip = progress_end - progress_skip;
1250
1251 float speed_ms_real = ms_running - ms_paused;
1252 uint64_t speed_plains_real = all_done;
1253
1254 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1255 {
1256 if (data.devices_status != STATUS_CRACKED)
1257 {
1258 uint64_t words_per_ms = 0;
1259
1260 if (speed_plains_real && speed_ms_real)
1261 {
1262 words_per_ms = speed_plains_real / speed_ms_real;
1263 }
1264
1265 #ifdef WIN
1266 __time64_t sec_etc = 0;
1267 #else
1268 time_t sec_etc = 0;
1269 #endif
1270
1271 if (words_per_ms)
1272 {
1273 uint64_t progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1274
1275 uint64_t ms_left = progress_left_relative_skip / words_per_ms;
1276
1277 sec_etc = ms_left / 1000;
1278 }
1279
1280 if (sec_etc == 0)
1281 {
1282 log_info ("Time.Estimated.: 0 secs");
1283 }
1284 else if ((uint64_t) sec_etc > ETC_MAX)
1285 {
1286 log_info ("Time.Estimated.: > 10 Years");
1287 }
1288 else
1289 {
1290 char display_etc[32];
1291
1292 struct tm tm_etc;
1293
1294 struct tm *tmp;
1295
1296 #ifdef WIN
1297
1298 tmp = _gmtime64 (&sec_etc);
1299
1300 #else
1301
1302 tmp = gmtime (&sec_etc);
1303
1304 #endif
1305
1306 if (tmp != NULL)
1307 {
1308 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1309
1310 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1311
1312 time_t now;
1313
1314 time (&now);
1315
1316 now += sec_etc;
1317
1318 char *etc = ctime (&now);
1319
1320 size_t etc_len = strlen (etc);
1321
1322 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1323 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1324
1325 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1326 }
1327 }
1328 }
1329 }
1330
1331 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1332 {
1333 char display_dev_cur[16];
1334
1335 memset (display_dev_cur, 0, sizeof (display_dev_cur));
1336
1337 strncpy (display_dev_cur, "0.00", 4);
1338
1339 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1340
1341 log_info ("Speed.GPU.#%d...: %9sH/s", device_id + 1, display_dev_cur);
1342 }
1343
1344 char display_all_cur[16];
1345
1346 memset (display_all_cur, 0, sizeof (display_all_cur));
1347
1348 strncpy (display_all_cur, "0.00", 4);
1349
1350 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1351
1352 if (data.devices_cnt > 1) log_info ("Speed.GPU.#*...: %9sH/s", display_all_cur);
1353
1354 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1355 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1356
1357 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);
1358
1359 // crack-per-time
1360
1361 if (data.digests_cnt > 100)
1362 {
1363 time_t now = time (NULL);
1364
1365 int cpt_cur_min = 0;
1366 int cpt_cur_hour = 0;
1367 int cpt_cur_day = 0;
1368
1369 for (int i = 0; i < CPT_BUF; i++)
1370 {
1371 const uint cracked = data.cpt_buf[i].cracked;
1372 const time_t timestamp = data.cpt_buf[i].timestamp;
1373
1374 if ((timestamp + 60) > now)
1375 {
1376 cpt_cur_min += cracked;
1377 }
1378
1379 if ((timestamp + 3600) > now)
1380 {
1381 cpt_cur_hour += cracked;
1382 }
1383
1384 if ((timestamp + 86400) > now)
1385 {
1386 cpt_cur_day += cracked;
1387 }
1388 }
1389
1390 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1391 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1392 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1393
1394 if ((data.cpt_start + 86400) < now)
1395 {
1396 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1397 cpt_cur_min,
1398 cpt_cur_hour,
1399 cpt_cur_day,
1400 cpt_avg_min,
1401 cpt_avg_hour,
1402 cpt_avg_day);
1403 }
1404 else if ((data.cpt_start + 3600) < now)
1405 {
1406 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1407 cpt_cur_min,
1408 cpt_cur_hour,
1409 cpt_avg_min,
1410 cpt_avg_hour,
1411 cpt_avg_day);
1412 }
1413 else if ((data.cpt_start + 60) < now)
1414 {
1415 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1416 cpt_cur_min,
1417 cpt_avg_min,
1418 cpt_avg_hour,
1419 cpt_avg_day);
1420 }
1421 else
1422 {
1423 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1424 cpt_avg_min,
1425 cpt_avg_hour,
1426 cpt_avg_day);
1427 }
1428 }
1429
1430 // Restore point
1431
1432 uint64_t restore_point = get_lowest_words_done ();
1433
1434 uint64_t restore_total = data.words_base;
1435
1436 float percent_restore = 0;
1437
1438 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1439
1440 if (progress_end_relative_skip)
1441 {
1442 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1443 {
1444 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1445 float percent_rejected = 0.0;
1446
1447 if (progress_cur)
1448 {
1449 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1450 }
1451
1452 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);
1453 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1454
1455 if (data.restore_disable == 0)
1456 {
1457 if (percent_finished != 1)
1458 {
1459 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1460 }
1461 }
1462 }
1463 }
1464 else
1465 {
1466 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1467 {
1468 log_info ("Progress.......: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1469 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1470
1471 if (data.restore_disable == 0)
1472 {
1473 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1474 }
1475 }
1476 else
1477 {
1478 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1479 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1480
1481 // --restore not allowed if stdin is used -- really? why?
1482
1483 //if (data.restore_disable == 0)
1484 //{
1485 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1486 //}
1487 }
1488 }
1489
1490 /*
1491 if (data.gpu_temp_disable == 0)
1492 {
1493 hc_thread_mutex_lock (mux_adl);
1494
1495 for (uint i = 0; i < data.devices_cnt; i++)
1496 {
1497 if (data.hm_device[i].fan_supported == 1)
1498 {
1499 const int temperature = hm_get_temperature_with_device_id (i);
1500 const int utilization = hm_get_utilization_with_device_id (i);
1501 const int fanspeed = hm_get_fanspeed_with_device_id (i);
1502
1503 if (vendor_id == VENDOR_ID_AMD)
1504 {
1505 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, %2d%% Fan", i + 1, utilization, temperature, fanspeed);
1506 }
1507
1508 if (vendor_id == VENDOR_ID_NV)
1509 {
1510 #ifdef LINUX
1511 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, %2d%% Fan", i + 1, utilization, temperature, fanspeed);
1512 #else
1513 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, %2drpm Fan", i + 1, utilization, temperature, fanspeed);
1514 #endif
1515 }
1516 }
1517 else
1518 {
1519 const int temperature = hm_get_temperature_with_device_id (i);
1520 const int utilization = hm_get_utilization_with_device_id (i);
1521
1522 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, N/A Fan", i + 1, utilization, temperature);
1523 }
1524 }
1525
1526 hc_thread_mutex_unlock (mux_adl);
1527 }
1528 */
1529 }
1530
1531 static void status_benchmark ()
1532 {
1533 if (data.devices_status == STATUS_INIT) return;
1534 if (data.devices_status == STATUS_STARTING) return;
1535
1536 if (data.words_cnt == 0) return;
1537
1538 uint64_t speed_cnt[DEVICES_MAX];
1539 float speed_ms[DEVICES_MAX];
1540
1541 uint device_id;
1542
1543 for (device_id = 0; device_id < data.devices_cnt; device_id++)
1544 {
1545 hc_device_param_t *device_param = &data.devices_param[device_id];
1546
1547 speed_cnt[device_id] = 0;
1548 speed_ms[device_id] = 0;
1549
1550 for (int i = 0; i < SPEED_CACHE; i++)
1551 {
1552 speed_cnt[device_id] += device_param->speed_cnt[i];
1553 speed_ms[device_id] += device_param->speed_ms[i];
1554 }
1555
1556 speed_cnt[device_id] /= SPEED_CACHE;
1557 speed_ms[device_id] /= SPEED_CACHE;
1558 }
1559
1560 float hashes_all_ms = 0;
1561
1562 float hashes_dev_ms[DEVICES_MAX];
1563
1564 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1565 {
1566 hashes_dev_ms[device_id] = 0;
1567
1568 if (speed_ms[device_id])
1569 {
1570 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1571
1572 hashes_all_ms += hashes_dev_ms[device_id];
1573 }
1574 }
1575
1576 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1577 {
1578 char display_dev_cur[16];
1579
1580 memset (display_dev_cur, 0, sizeof (display_dev_cur));
1581
1582 strncpy (display_dev_cur, "0.00", 4);
1583
1584 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1585
1586 log_info ("Speed.GPU.#%d.: %9sH/s", device_id + 1, display_dev_cur);
1587 }
1588
1589 char display_all_cur[16];
1590
1591 memset (display_all_cur, 0, sizeof (display_all_cur));
1592
1593 strncpy (display_all_cur, "0.00", 4);
1594
1595 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1596
1597 if (data.devices_cnt > 1) log_info ("Speed.GPU.#*.: %9sH/s", display_all_cur);
1598 }
1599
1600 /**
1601 * oclHashcat -only- functions
1602 */
1603
1604 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *install_dir, char *kernel_file)
1605 {
1606 if (attack_exec == ATTACK_EXEC_ON_GPU)
1607 {
1608 if (attack_kern == ATTACK_KERN_STRAIGHT)
1609 snprintf (kernel_file, 255, "%s/OpenCL/m%05d_a0.cl", install_dir, (int) kern_type);
1610 else if (attack_kern == ATTACK_KERN_COMBI)
1611 snprintf (kernel_file, 255, "%s/OpenCL/m%05d_a1.cl", install_dir, (int) kern_type);
1612 else if (attack_kern == ATTACK_KERN_BF)
1613 snprintf (kernel_file, 255, "%s/OpenCL/m%05d_a3.cl", install_dir, (int) kern_type);
1614 }
1615 else
1616 snprintf (kernel_file, 255, "%s/OpenCL/m%05d.cl", install_dir, (int) kern_type);
1617 }
1618
1619 static uint convert_from_hex (char *line_buf, const uint line_len)
1620 {
1621 if (line_len & 1) return (line_len); // not in hex
1622
1623 if (data.hex_wordlist == 1)
1624 {
1625 uint i;
1626 uint j;
1627
1628 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1629 {
1630 line_buf[i] = hex_to_char (&line_buf[j]);
1631 }
1632
1633 memset (line_buf + i, 0, line_len - i);
1634
1635 return (i);
1636 }
1637 else if (line_len >= 6) // $HEX[] = 6
1638 {
1639 if (line_buf[0] != '$') return (line_len);
1640 if (line_buf[1] != 'H') return (line_len);
1641 if (line_buf[2] != 'E') return (line_len);
1642 if (line_buf[3] != 'X') return (line_len);
1643 if (line_buf[4] != '[') return (line_len);
1644 if (line_buf[line_len - 1] != ']') return (line_len);
1645
1646 uint i;
1647 uint j;
1648
1649 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1650 {
1651 line_buf[i] = hex_to_char (&line_buf[j]);
1652 }
1653
1654 memset (line_buf + i, 0, line_len - i);
1655
1656 return (i);
1657 }
1658
1659 return (line_len);
1660 }
1661
1662 static uint count_lines (FILE *fd)
1663 {
1664 uint cnt = 0;
1665
1666 char *buf = (char *) mymalloc (BUFSIZ);
1667
1668 size_t nread_tmp = 0;
1669
1670 char *ptr = buf;
1671
1672 while (!feof (fd))
1673 {
1674 size_t nread = fread (buf, sizeof (char), BUFSIZ, fd);
1675 nread_tmp = nread;
1676
1677 if (nread < 1) continue;
1678
1679 ptr = buf;
1680
1681 do
1682 {
1683 if (*ptr++ == '\n') cnt++;
1684
1685 } while (nread--);
1686 }
1687
1688 // special case (if last line did not contain a newline char ... at the very end of the file)
1689
1690 if (nread_tmp > 3)
1691 {
1692 ptr -= 2;
1693
1694 if (*ptr != '\n')
1695 {
1696 ptr--;
1697
1698 if (*ptr != '\n') // needed ? different on windows systems?
1699 {
1700 cnt++;
1701 }
1702 }
1703 }
1704
1705 myfree (buf);
1706
1707 return cnt;
1708 }
1709
1710 static void clear_prompt ()
1711 {
1712 fputc ('\r', stdout);
1713
1714 for (size_t i = 0; i < strlen (PROMPT); i++)
1715 {
1716 fputc (' ', stdout);
1717 }
1718
1719 fputc ('\r', stdout);
1720
1721 fflush (stdout);
1722 }
1723
1724 static void gidd_to_pw_t (hc_device_param_t *device_param, const uint64_t gidd, pw_t *pw)
1725 {
1726 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1727 }
1728
1729 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1730 {
1731 char *outfile = data.outfile;
1732 uint quiet = data.quiet;
1733 FILE *pot_fp = data.pot_fp;
1734 uint loopback = data.loopback;
1735 uint debug_mode = data.debug_mode;
1736 char *debug_file = data.debug_file;
1737
1738 char debug_rule_buf[BLOCK_SIZE];
1739 int debug_rule_len = 0; // -1 error
1740 uint debug_plain_len = 0;
1741
1742 unsigned char debug_plain_ptr[BLOCK_SIZE];
1743
1744 // hash
1745
1746 char out_buf[4096]; memset (out_buf, 0, sizeof (out_buf));
1747
1748 ascii_digest (out_buf, salt_pos, digest_pos);
1749
1750 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1751
1752 // plain
1753
1754 plain_t plain;
1755
1756 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, idx * sizeof (plain_t), sizeof (plain_t), &plain, 0, NULL, NULL);
1757
1758 uint gidvid = plain.gidvid;
1759 uint il_pos = plain.il_pos;
1760
1761 uint64_t crackpos = device_param->words_off;
1762
1763 uint plain_buf[16];
1764
1765 unsigned char *plain_ptr = (unsigned char *) plain_buf;
1766 unsigned int plain_len = 0;
1767
1768 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1769 {
1770 uint64_t gidd = gidvid;
1771 uint64_t gidm = 0;
1772
1773 pw_t pw;
1774
1775 gidd_to_pw_t (device_param, gidd, &pw);
1776
1777 for (int i = 0, j = gidm; i < 16; i++, j++)
1778 {
1779 plain_buf[i] = pw.hi1[0][j];
1780 }
1781
1782 plain_len = pw.pw_len;
1783
1784 const uint off = device_param->innerloop_pos + il_pos;
1785
1786 if (debug_mode > 0)
1787 {
1788 debug_rule_len = 0;
1789
1790 // save rule
1791 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1792 {
1793 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1794
1795 debug_rule_len = gpu_rule_to_cpu_rule (debug_rule_buf, &data.gpu_rules_buf[off]);
1796 }
1797
1798 // save plain
1799 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1800 {
1801 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1802
1803 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1804
1805 debug_plain_len = plain_len;
1806 }
1807 }
1808
1809 plain_len = apply_rules (data.gpu_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1810
1811 crackpos += gidvid;
1812 crackpos *= data.gpu_rules_cnt;
1813 crackpos += device_param->innerloop_pos + il_pos;
1814
1815 if (plain_len > data.pw_max) plain_len = data.pw_max;
1816 }
1817 else if (data.attack_mode == ATTACK_MODE_COMBI)
1818 {
1819 uint64_t gidd = gidvid;
1820 uint64_t gidm = 0;
1821
1822 pw_t pw;
1823
1824 gidd_to_pw_t (device_param, gidd, &pw);
1825
1826 for (int i = 0, j = gidm; i < 16; i++, j++)
1827 {
1828 plain_buf[i] = pw.hi1[0][j];
1829 }
1830
1831 plain_len = pw.pw_len;
1832
1833 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1834 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1835
1836 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1837 {
1838 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1839 }
1840 else
1841 {
1842 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1843
1844 memcpy (plain_ptr, comb_buf, comb_len);
1845 }
1846
1847 plain_len += comb_len;
1848
1849 crackpos += gidvid;
1850 crackpos *= data.combs_cnt;
1851 crackpos += device_param->innerloop_pos + il_pos;
1852
1853 if (data.pw_max != PW_DICTMAX1)
1854 {
1855 if (plain_len > data.pw_max) plain_len = data.pw_max;
1856 }
1857 }
1858 else if (data.attack_mode == ATTACK_MODE_BF)
1859 {
1860 uint64_t l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1861 uint64_t r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1862
1863 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1864 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1865
1866 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1867 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1868
1869 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1870 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1871
1872 plain_len = data.css_cnt;
1873
1874 crackpos += gidvid;
1875 crackpos *= data.bfs_cnt;
1876 crackpos += device_param->innerloop_pos + il_pos;
1877 }
1878 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1879 {
1880 uint64_t gidd = gidvid;
1881 uint64_t gidm = 0;
1882
1883 pw_t pw;
1884
1885 gidd_to_pw_t (device_param, gidd, &pw);
1886
1887 for (int i = 0, j = gidm; i < 16; i++, j++)
1888 {
1889 plain_buf[i] = pw.hi1[0][j];
1890 }
1891
1892 plain_len = pw.pw_len;
1893
1894 uint64_t off = device_param->kernel_params_mp_buf64[3] + il_pos;
1895
1896 uint start = 0;
1897 uint stop = device_param->kernel_params_mp_buf32[4];
1898
1899 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
1900
1901 plain_len += start + stop;
1902
1903 crackpos += gidvid;
1904 crackpos *= data.combs_cnt;
1905 crackpos += device_param->innerloop_pos + il_pos;
1906
1907 if (data.pw_max != PW_DICTMAX1)
1908 {
1909 if (plain_len > data.pw_max) plain_len = data.pw_max;
1910 }
1911 }
1912 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1913 {
1914 uint64_t gidd = gidvid;
1915 uint64_t gidm = 0;
1916
1917 pw_t pw;
1918
1919 gidd_to_pw_t (device_param, gidd, &pw);
1920
1921 for (int i = 0, j = gidm; i < 16; i++, j++)
1922 {
1923 plain_buf[i] = pw.hi1[0][j];
1924 }
1925
1926 plain_len = pw.pw_len;
1927
1928 uint64_t off = device_param->kernel_params_mp_buf64[3] + il_pos;
1929
1930 uint start = 0;
1931 uint stop = device_param->kernel_params_mp_buf32[4];
1932
1933 memmove (plain_ptr + stop, plain_ptr, plain_len);
1934
1935 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
1936
1937 plain_len += start + stop;
1938
1939 crackpos += gidvid;
1940 crackpos *= data.combs_cnt;
1941 crackpos += device_param->innerloop_pos + il_pos;
1942
1943 if (data.pw_max != PW_DICTMAX1)
1944 {
1945 if (plain_len > data.pw_max) plain_len = data.pw_max;
1946 }
1947 }
1948
1949 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
1950 {
1951 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1952 {
1953 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1954 {
1955 plain_len = plain_len - data.salts_buf[0].salt_len;
1956 }
1957 }
1958
1959 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
1960 {
1961 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
1962 {
1963 plain_ptr[j] = plain_ptr[i];
1964 }
1965
1966 plain_len = plain_len / 2;
1967 }
1968 }
1969
1970 // if enabled, update also the potfile
1971
1972 if (pot_fp)
1973 {
1974 fprintf (pot_fp, "%s:", out_buf);
1975
1976 format_plain (pot_fp, plain_ptr, plain_len, 1);
1977
1978 fputc ('\n', pot_fp);
1979
1980 fflush (pot_fp);
1981 }
1982
1983 // outfile
1984
1985 FILE *out_fp = NULL;
1986
1987 if (outfile != NULL)
1988 {
1989 if ((out_fp = fopen (outfile, "ab")) == NULL)
1990 {
1991 log_error ("ERROR: %s: %s", outfile, strerror (errno));
1992
1993 out_fp = stdout;
1994 }
1995 }
1996 else
1997 {
1998 out_fp = stdout;
1999
2000 if (quiet == 0) clear_prompt ();
2001 }
2002
2003 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2004
2005 if (outfile != NULL)
2006 {
2007 if (out_fp != stdout)
2008 {
2009 fclose (out_fp);
2010 }
2011 }
2012 else
2013 {
2014 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2015 {
2016 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2017 {
2018 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2019 if (quiet == 0) fflush (stdout);
2020 }
2021 }
2022 }
2023
2024 // loopback
2025
2026 if (loopback)
2027 {
2028 char *loopback_file = data.loopback_file;
2029
2030 FILE *fb_fp = NULL;
2031
2032 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2033 {
2034 format_plain (fb_fp, plain_ptr, plain_len, 1);
2035
2036 fputc ('\n', fb_fp);
2037
2038 fclose (fb_fp);
2039 }
2040 }
2041
2042 // (rule) debug mode
2043
2044 // the next check implies that:
2045 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2046 // - debug_mode > 0
2047
2048 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2049 {
2050 if (debug_rule_len < 0) debug_rule_len = 0;
2051
2052 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2053
2054 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2055
2056 if ((quiet == 0) && (debug_file == NULL))
2057 {
2058 fprintf (stdout, "%s", PROMPT);
2059 fflush (stdout);
2060 }
2061 }
2062 }
2063
2064 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2065 {
2066 salt_t *salt_buf = &data.salts_buf[salt_pos];
2067
2068 int found = 0;
2069
2070 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2071
2072 for (uint i = 0; i < GPU_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2073
2074 if (found == 1)
2075 {
2076 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2077
2078 log_info_nn ("");
2079
2080 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);
2081
2082 uint cpt_cracked = 0;
2083
2084 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2085 {
2086 uint idx = salt_buf->digests_offset + digest_pos;
2087
2088 if (data.digests_shown_tmp[idx] == 0) continue;
2089
2090 if (data.digests_shown[idx] == 1) continue;
2091
2092 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2093 {
2094 data.digests_shown[idx] = 1;
2095
2096 data.digests_done++;
2097
2098 cpt_cracked++;
2099
2100 salt_buf->digests_done++;
2101
2102 if (salt_buf->digests_done == salt_buf->digests_cnt)
2103 {
2104 data.salts_shown[salt_pos] = 1;
2105
2106 data.salts_done++;
2107 }
2108 }
2109
2110 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2111
2112 check_hash (device_param, salt_pos, digest_pos);
2113 }
2114
2115 if (cpt_cracked > 0)
2116 {
2117 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2118 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2119
2120 data.cpt_pos++;
2121
2122 data.cpt_total += cpt_cracked;
2123
2124 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2125 }
2126
2127 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2128 {
2129 // we need to reset cracked state on the gpu
2130 // otherwise host thinks again and again the hash was cracked
2131 // and returns invalid password each time
2132
2133 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2134
2135 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);
2136 }
2137
2138 memset (device_param->result, 0, device_param->size_results);
2139
2140 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2141 }
2142 }
2143
2144 static void save_hash ()
2145 {
2146 char *hashfile = data.hashfile;
2147
2148 char new_hashfile[256];
2149 char old_hashfile[256];
2150
2151 memset (new_hashfile, 0, sizeof (new_hashfile));
2152 memset (old_hashfile, 0, sizeof (old_hashfile));
2153
2154 snprintf (new_hashfile, 255, "%s.new", hashfile);
2155 snprintf (old_hashfile, 255, "%s.old", hashfile);
2156
2157 unlink (new_hashfile);
2158
2159 char separator = data.separator;
2160
2161 FILE *fp = fopen (new_hashfile, "wb");
2162
2163 if (fp == NULL)
2164 {
2165 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2166
2167 exit (-1);
2168 }
2169
2170 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2171 {
2172 if (data.salts_shown[salt_pos] == 1) continue;
2173
2174 salt_t *salt_buf = &data.salts_buf[salt_pos];
2175
2176 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2177 {
2178 uint idx = salt_buf->digests_offset + digest_pos;
2179
2180 if (data.digests_shown[idx] == 1) continue;
2181
2182 if (data.hash_mode != 2500)
2183 {
2184 char out_buf[4096];
2185
2186 memset (out_buf, 0, sizeof (out_buf));
2187
2188 if (data.username == 1)
2189 {
2190 user_t *user = data.hash_info[idx]->user;
2191
2192 uint i;
2193
2194 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2195
2196 fputc (separator, fp);
2197 }
2198
2199 ascii_digest (out_buf, salt_pos, digest_pos);
2200
2201 fputs (out_buf, fp);
2202
2203 log_out (fp, "");
2204 }
2205 else
2206 {
2207 hccap_t hccap;
2208
2209 to_hccap_t (&hccap, salt_pos, digest_pos);
2210
2211 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2212 }
2213 }
2214 }
2215
2216 fflush (fp);
2217
2218 fclose (fp);
2219
2220 unlink (old_hashfile);
2221
2222 if (rename (hashfile, old_hashfile) != 0)
2223 {
2224 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2225
2226 exit (-1);
2227 }
2228
2229 unlink (hashfile);
2230
2231 if (rename (new_hashfile, hashfile) != 0)
2232 {
2233 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2234
2235 exit (-1);
2236 }
2237
2238 unlink (old_hashfile);
2239 }
2240
2241 static float find_gpu_blocks_div (const uint64_t total_left, const uint gpu_blocks_all)
2242 {
2243 // function called only in case gpu_blocks_all > words_left)
2244
2245 float gpu_blocks_div = (float) (total_left) / gpu_blocks_all;
2246
2247 gpu_blocks_div += gpu_blocks_div / 100;
2248
2249 uint32_t gpu_blocks_new = (uint32_t) (gpu_blocks_all * gpu_blocks_div);
2250
2251 while (gpu_blocks_new < total_left)
2252 {
2253 gpu_blocks_div += gpu_blocks_div / 100;
2254
2255 gpu_blocks_new = (uint32_t) (gpu_blocks_all * gpu_blocks_div);
2256 }
2257
2258 if (data.quiet == 0)
2259 {
2260 clear_prompt ();
2261
2262 log_info ("");
2263
2264 log_info ("INFO: approaching final keyspace, workload adjusted");
2265
2266 log_info ("");
2267
2268 fprintf (stdout, "%s", PROMPT);
2269
2270 fflush (stdout);
2271 }
2272
2273 if ((gpu_blocks_all * gpu_blocks_div) < 8) return 1;
2274
2275 return gpu_blocks_div;
2276 }
2277
2278 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num)
2279 {
2280 uint num_elements = num;
2281
2282 device_param->kernel_params_buf32[30] = data.combs_mode;
2283 device_param->kernel_params_buf32[31] = num;
2284
2285 uint gpu_threads = device_param->gpu_threads;
2286
2287 while (num_elements % gpu_threads) num_elements++;
2288
2289 cl_kernel kernel = NULL;
2290
2291 switch (kern_run)
2292 {
2293 case KERN_RUN_1: kernel = device_param->kernel1; break;
2294 case KERN_RUN_12: kernel = device_param->kernel12; break;
2295 case KERN_RUN_2: kernel = device_param->kernel2; break;
2296 case KERN_RUN_23: kernel = device_param->kernel23; break;
2297 case KERN_RUN_3: kernel = device_param->kernel3; break;
2298 }
2299
2300 hc_clSetKernelArg (kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2301 hc_clSetKernelArg (kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2302 hc_clSetKernelArg (kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2303 hc_clSetKernelArg (kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2304 hc_clSetKernelArg (kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2305 hc_clSetKernelArg (kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2306 hc_clSetKernelArg (kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2307 hc_clSetKernelArg (kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2308 hc_clSetKernelArg (kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2309 hc_clSetKernelArg (kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2310 hc_clSetKernelArg (kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2311
2312 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2313 {
2314 const size_t global_work_size[3] = { num_elements, 32, 1 };
2315 const size_t local_work_size[3] = { gpu_threads / 32, 32, 1 };
2316
2317 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2318 }
2319 else
2320 {
2321 const size_t global_work_size[3] = { num_elements, 1, 1 };
2322 const size_t local_work_size[3] = { gpu_threads, 1, 1 };
2323
2324 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2325 }
2326
2327 hc_clFlush (device_param->command_queue);
2328
2329 hc_clFinish (device_param->command_queue);
2330 }
2331
2332 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2333 {
2334 uint num_elements = num;
2335
2336 switch (kern_run)
2337 {
2338 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2339 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2340 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2341 }
2342
2343 // causes problems with special threads like in bcrypt
2344 // const uint gpu_threads = device_param->gpu_threads;
2345
2346 const uint gpu_threads = GPU_THREADS;
2347
2348 while (num_elements % gpu_threads) num_elements++;
2349
2350 cl_kernel kernel = NULL;
2351
2352 switch (kern_run)
2353 {
2354 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2355 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2356 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2357 }
2358
2359 switch (kern_run)
2360 {
2361 case KERN_RUN_MP: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2362 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2363 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2364 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2365 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2366 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2367 break;
2368 case KERN_RUN_MP_R: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2369 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2370 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2371 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2372 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2373 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2374 break;
2375 case KERN_RUN_MP_L: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2376 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2377 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2378 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2379 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2380 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2381 hc_clSetKernelArg (kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2382 break;
2383 }
2384
2385 const size_t global_work_size[3] = { num_elements, 1, 1 };
2386 const size_t local_work_size[3] = { gpu_threads, 1, 1 };
2387
2388 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2389
2390 hc_clFlush (device_param->command_queue);
2391
2392 hc_clFinish (device_param->command_queue);
2393 }
2394
2395 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2396 {
2397 uint num_elements = num;
2398
2399 uint gpu_threads = device_param->gpu_threads;
2400
2401 while (num_elements % gpu_threads) num_elements++;
2402
2403 cl_kernel kernel = device_param->kernel_tb;
2404
2405 const size_t global_work_size[3] = { num_elements, 1, 1 };
2406 const size_t local_work_size[3] = { gpu_threads, 1, 1 };
2407
2408 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2409
2410 hc_clFlush (device_param->command_queue);
2411
2412 hc_clFinish (device_param->command_queue);
2413 }
2414
2415 static void run_kernel_tm (hc_device_param_t *device_param)
2416 {
2417 const uint num_elements = 1024; // fixed
2418
2419 const uint gpu_threads = 32;
2420
2421 cl_kernel kernel = device_param->kernel_tm;
2422
2423 const size_t global_work_size[3] = { num_elements, 1, 1 };
2424 const size_t local_work_size[3] = { gpu_threads, 1, 1 };
2425
2426 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2427
2428 hc_clFlush (device_param->command_queue);
2429
2430 hc_clFinish (device_param->command_queue);
2431 }
2432
2433 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2434 {
2435 uint num_elements = num;
2436
2437 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2438 device_param->kernel_params_amp_buf32[6] = num_elements;
2439
2440 // causes problems with special threads like in bcrypt
2441 // const uint gpu_threads = device_param->gpu_threads;
2442
2443 const uint gpu_threads = GPU_THREADS;
2444
2445 while (num_elements % gpu_threads) num_elements++;
2446
2447 cl_kernel kernel = device_param->kernel_amp;
2448
2449 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2450 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2451
2452 const size_t global_work_size[3] = { num_elements, 1, 1 };
2453 const size_t local_work_size[3] = { gpu_threads, 1, 1 };
2454
2455 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2456
2457 hc_clFlush (device_param->command_queue);
2458
2459 hc_clFinish (device_param->command_queue);
2460 }
2461
2462 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2463 {
2464 // not supported with Nvidia
2465 // hc_clEnqueueFillBuffer (device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2466
2467 char *tmp = (char *) mymalloc (size);
2468
2469 memset (tmp, 0, size);
2470
2471 hc_clEnqueueWriteBuffer (device_param->command_queue, buf, CL_TRUE, 0, size, tmp, 0, NULL, NULL);
2472
2473 free (tmp);
2474 }
2475
2476 static int run_rule_engine (const int rule_len, const char *rule_buf)
2477 {
2478 if (rule_len == 0)
2479 {
2480 return 0;
2481 }
2482 else if (rule_len == 1)
2483 {
2484 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2485 }
2486
2487 return 1;
2488 }
2489
2490 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2491 {
2492 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2493 {
2494 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2495 }
2496 else if (data.attack_kern == ATTACK_KERN_COMBI)
2497 {
2498 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);
2499 }
2500 else if (data.attack_kern == ATTACK_KERN_BF)
2501 {
2502 const uint64_t off = device_param->words_off;
2503
2504 device_param->kernel_params_mp_l_buf64[3] = off;
2505
2506 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2507 }
2508 }
2509
2510 static void run_cracker (hc_device_param_t *device_param, const uint pw_cnt, const uint pws_cnt)
2511 {
2512 const uint gpu_loops = data.gpu_loops;
2513
2514 // init speed timer
2515
2516 uint speed_pos = device_param->speed_pos;
2517
2518 #ifdef _POSIX
2519 if (device_param->timer_speed.tv_sec == 0)
2520 {
2521 hc_timer_set (&device_param->timer_speed);
2522 }
2523 #endif
2524
2525 #ifdef _WIN
2526 if (device_param->timer_speed.QuadPart == 0)
2527 {
2528 hc_timer_set (&device_param->timer_speed);
2529 }
2530 #endif
2531
2532 // find higest password length, this is for optimization stuff
2533
2534 uint highest_pw_len = 0;
2535
2536 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2537 {
2538 }
2539 else if (data.attack_kern == ATTACK_KERN_COMBI)
2540 {
2541 }
2542 else if (data.attack_kern == ATTACK_KERN_BF)
2543 {
2544 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
2545 + device_param->kernel_params_mp_l_buf32[5];
2546 }
2547
2548 // bitslice optimization stuff
2549
2550 if (data.attack_mode == ATTACK_MODE_BF)
2551 {
2552 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2553 {
2554 run_kernel_tb (device_param, pws_cnt);
2555 }
2556 }
2557
2558 // iteration type
2559
2560 uint innerloop_step = 0;
2561 uint innerloop_cnt = 0;
2562
2563 if (data.attack_exec == ATTACK_EXEC_ON_GPU) innerloop_step = gpu_loops;
2564 else innerloop_step = 1;
2565
2566 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.gpu_rules_cnt;
2567 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
2568 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
2569
2570 // loop start: most outer loop = salt iteration, then innerloops (if multi)
2571
2572 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2573 {
2574 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2575
2576 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2577
2578 if (data.devices_status == STATUS_CRACKED) break;
2579 if (data.devices_status == STATUS_ABORTED) break;
2580 if (data.devices_status == STATUS_QUIT) break;
2581 if (data.devices_status == STATUS_BYPASS) break;
2582
2583 if (data.salts_shown[salt_pos] == 1) continue;
2584
2585 salt_t *salt_buf = &data.salts_buf[salt_pos];
2586
2587 device_param->kernel_params_buf32[24] = salt_pos;
2588 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
2589 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
2590
2591 FILE *combs_fp = device_param->combs_fp;
2592
2593 if (data.attack_mode == ATTACK_MODE_COMBI)
2594 {
2595 rewind (combs_fp);
2596 }
2597
2598 // innerloops
2599
2600 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
2601 {
2602 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2603
2604 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2605
2606 if (data.devices_status == STATUS_CRACKED) break;
2607 if (data.devices_status == STATUS_ABORTED) break;
2608 if (data.devices_status == STATUS_QUIT) break;
2609 if (data.devices_status == STATUS_BYPASS) break;
2610
2611 uint innerloop_left = innerloop_cnt - innerloop_pos;
2612
2613 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
2614
2615 device_param->innerloop_pos = innerloop_pos;
2616 device_param->innerloop_left = innerloop_left;
2617
2618 device_param->kernel_params_buf32[27] = innerloop_left;
2619
2620 if (innerloop_left == 0) continue;
2621
2622 // initialize amplifiers
2623
2624 if (data.attack_mode == ATTACK_MODE_COMBI)
2625 {
2626 char line_buf[BUFSIZ];
2627
2628 uint i = 0;
2629
2630 while (i < innerloop_left)
2631 {
2632 if (feof (combs_fp)) break;
2633
2634 int line_len = fgetl (combs_fp, line_buf);
2635
2636 if (line_len >= PW_MAX1) continue;
2637
2638 line_len = convert_from_hex (line_buf, line_len);
2639
2640 char *line_buf_new = line_buf;
2641
2642 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
2643 {
2644 char rule_buf_out[BLOCK_SIZE];
2645
2646 memset (rule_buf_out, 0, sizeof (rule_buf_out));
2647
2648 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
2649
2650 if (rule_len_out < 0)
2651 {
2652 data.words_progress_rejected[salt_pos] += pw_cnt;
2653
2654 continue;
2655 }
2656
2657 line_len = rule_len_out;
2658
2659 line_buf_new = rule_buf_out;
2660 }
2661
2662 line_len = MIN (line_len, PW_DICTMAX);
2663
2664 char *ptr = (char *) device_param->combs_buf[i].i;
2665
2666 memcpy (ptr, line_buf_new, line_len);
2667
2668 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
2669
2670 if (data.opts_type & OPTS_TYPE_PT_UPPER)
2671 {
2672 uppercase (ptr, line_len);
2673 }
2674
2675 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2676 {
2677 if (data.opts_type & OPTS_TYPE_PT_ADD80)
2678 {
2679 ptr[line_len] = 0x80;
2680 }
2681
2682 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2683 {
2684 ptr[line_len] = 0x01;
2685 }
2686 }
2687
2688 device_param->combs_buf[i].pw_len = line_len;
2689
2690 i++;
2691 }
2692
2693 for (uint j = i; j < innerloop_left; j++)
2694 {
2695 device_param->combs_buf[j].i[0] = 0;
2696 device_param->combs_buf[j].i[1] = 0;
2697 device_param->combs_buf[j].i[2] = 0;
2698 device_param->combs_buf[j].i[3] = 0;
2699 device_param->combs_buf[j].i[4] = 0;
2700 device_param->combs_buf[j].i[5] = 0;
2701 device_param->combs_buf[j].i[6] = 0;
2702 device_param->combs_buf[j].i[7] = 0;
2703
2704 device_param->combs_buf[j].pw_len = 0;
2705 }
2706
2707 innerloop_left = i;
2708 }
2709 else if (data.attack_mode == ATTACK_MODE_BF)
2710 {
2711 uint64_t off = innerloop_pos;
2712
2713 device_param->kernel_params_mp_r_buf64[3] = off;
2714
2715 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
2716 }
2717 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2718 {
2719 uint64_t off = innerloop_pos;
2720
2721 device_param->kernel_params_mp_buf64[3] = off;
2722
2723 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2724 }
2725 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2726 {
2727 uint64_t off = innerloop_pos;
2728
2729 device_param->kernel_params_mp_buf64[3] = off;
2730
2731 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2732 }
2733
2734 // copy amplifiers
2735
2736 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2737 {
2738 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);
2739 }
2740 else if (data.attack_mode == ATTACK_MODE_COMBI)
2741 {
2742 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);
2743 }
2744 else if (data.attack_mode == ATTACK_MODE_BF)
2745 {
2746 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);
2747 }
2748 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2749 {
2750 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
2751 }
2752 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2753 {
2754 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);
2755 }
2756
2757 if (data.attack_exec == ATTACK_EXEC_ON_GPU)
2758 {
2759 if (data.attack_mode == ATTACK_MODE_BF)
2760 {
2761 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2762 {
2763 const uint size_tm = 32 * sizeof (bs_word_t);
2764
2765 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2766
2767 run_kernel_tm (device_param);
2768
2769 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2770 }
2771 }
2772
2773 if (highest_pw_len < 16)
2774 {
2775 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2776 }
2777 else if (highest_pw_len < 32)
2778 {
2779 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2780 }
2781 else
2782 {
2783 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2784 }
2785 }
2786 else
2787 {
2788 run_kernel_amp (device_param, pws_cnt);
2789
2790 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2791
2792 if (data.opts_type & OPTS_TYPE_HOOK12)
2793 {
2794 run_kernel (KERN_RUN_12, device_param, pws_cnt);
2795 }
2796
2797 uint iter = salt_buf->salt_iter;
2798
2799 for (uint loop_pos = 0; loop_pos < iter; loop_pos += gpu_loops)
2800 {
2801 uint loop_left = iter - loop_pos;
2802
2803 loop_left = MIN (loop_left, gpu_loops);
2804
2805 device_param->kernel_params_buf32[25] = loop_pos;
2806 device_param->kernel_params_buf32[26] = loop_left;
2807
2808 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2809
2810 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2811
2812 if (data.devices_status == STATUS_CRACKED) break;
2813 if (data.devices_status == STATUS_ABORTED) break;
2814 if (data.devices_status == STATUS_QUIT) break;
2815 }
2816
2817 if (data.opts_type & OPTS_TYPE_HOOK23)
2818 {
2819 run_kernel (KERN_RUN_23, device_param, pws_cnt);
2820
2821 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2822
2823 // do something with data
2824
2825 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2826 }
2827
2828 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2829 }
2830
2831 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2832
2833 if (data.devices_status == STATUS_CRACKED) break;
2834 if (data.devices_status == STATUS_ABORTED) break;
2835 if (data.devices_status == STATUS_QUIT) break;
2836
2837 /**
2838 * result
2839 */
2840
2841 hc_thread_mutex_lock (mux_display);
2842
2843 check_cracked (device_param, salt_pos);
2844
2845 hc_thread_mutex_unlock (mux_display);
2846
2847 /**
2848 * progress
2849 */
2850
2851 uint64_t perf_sum_all = (uint64_t) pw_cnt * (uint64_t) innerloop_left;
2852
2853 hc_thread_mutex_lock (mux_counter);
2854
2855 data.words_progress_done[salt_pos] += perf_sum_all;
2856
2857 hc_thread_mutex_unlock (mux_counter);
2858
2859 /**
2860 * speed
2861 */
2862
2863 float speed_ms;
2864
2865 hc_timer_get (device_param->timer_speed, speed_ms);
2866
2867 hc_timer_set (&device_param->timer_speed);
2868
2869 hc_thread_mutex_lock (mux_display);
2870
2871 device_param->speed_cnt[speed_pos] = perf_sum_all;
2872
2873 device_param->speed_ms[speed_pos] = speed_ms;
2874
2875 device_param->speed_rec[speed_pos] = device_param->timer_speed;
2876
2877 hc_thread_mutex_unlock (mux_display);
2878
2879 speed_pos++;
2880
2881 if (speed_pos == SPEED_CACHE)
2882 {
2883 speed_pos = 0;
2884 }
2885 }
2886 }
2887
2888 device_param->speed_pos = speed_pos;
2889 }
2890
2891 static void load_segment (wl_data_t *wl_data, FILE *fd)
2892 {
2893 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
2894
2895 wl_data->pos = 0;
2896
2897 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
2898
2899 wl_data->buf[wl_data->cnt] = 0;
2900
2901 if (wl_data->cnt == 0) return;
2902
2903 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
2904
2905 while (!feof (fd))
2906 {
2907 if (wl_data->cnt == wl_data->avail)
2908 {
2909 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
2910
2911 wl_data->avail += wl_data->incr;
2912 }
2913
2914 const int c = fgetc (fd);
2915
2916 if (c == EOF) break;
2917
2918 wl_data->buf[wl_data->cnt] = (char) c;
2919
2920 wl_data->cnt++;
2921
2922 if (c == '\n') break;
2923 }
2924
2925 // ensure stream ends with a newline
2926
2927 if (wl_data->buf[wl_data->cnt - 1] != '\n')
2928 {
2929 wl_data->cnt++;
2930
2931 wl_data->buf[wl_data->cnt - 1] = '\n';
2932 }
2933
2934 return;
2935 }
2936
2937 static void get_next_word_lm (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
2938 {
2939 char *ptr = buf;
2940
2941 for (uint32_t i = 0; i < sz; i++, ptr++)
2942 {
2943 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
2944
2945 if (i == 7)
2946 {
2947 *off = i;
2948 *len = i;
2949
2950 return;
2951 }
2952
2953 if (*ptr != '\n') continue;
2954
2955 *off = i + 1;
2956
2957 if ((i > 0) && (buf[i - 1] == '\r')) i--;
2958
2959 *len = i;
2960
2961 return;
2962 }
2963
2964 *off = sz;
2965 *len = sz;
2966 }
2967
2968 static void get_next_word_uc (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
2969 {
2970 char *ptr = buf;
2971
2972 for (uint32_t i = 0; i < sz; i++, ptr++)
2973 {
2974 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
2975
2976 if (*ptr != '\n') continue;
2977
2978 *off = i + 1;
2979
2980 if ((i > 0) && (buf[i - 1] == '\r')) i--;
2981
2982 *len = i;
2983
2984 return;
2985 }
2986
2987 *off = sz;
2988 *len = sz;
2989 }
2990
2991 static void get_next_word_std (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
2992 {
2993 char *ptr = buf;
2994
2995 for (uint32_t i = 0; i < sz; i++, ptr++)
2996 {
2997 if (*ptr != '\n') continue;
2998
2999 *off = i + 1;
3000
3001 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3002
3003 *len = i;
3004
3005 return;
3006 }
3007
3008 *off = sz;
3009 *len = sz;
3010 }
3011
3012 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3013 {
3014 while (wl_data->pos < wl_data->cnt)
3015 {
3016 uint off;
3017 uint len;
3018
3019 char *ptr = wl_data->buf + wl_data->pos;
3020
3021 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3022
3023 wl_data->pos += off;
3024
3025 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3026 {
3027 char rule_buf_out[BLOCK_SIZE];
3028
3029 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3030
3031 int rule_len_out = -1;
3032
3033 if (len < BLOCK_SIZE)
3034 {
3035 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3036 }
3037
3038 if (rule_len_out < 0)
3039 {
3040 continue;
3041 }
3042
3043 if (rule_len_out > PW_MAX)
3044 {
3045 continue;
3046 }
3047 }
3048 else
3049 {
3050 if (len > PW_MAX)
3051 {
3052 continue;
3053 }
3054 }
3055
3056 *out_buf = ptr;
3057 *out_len = len;
3058
3059 return;
3060 }
3061
3062 if (feof (fd))
3063 {
3064 fprintf (stderr, "bug!!\n");
3065
3066 return;
3067 }
3068
3069 load_segment (wl_data, fd);
3070
3071 get_next_word (wl_data, fd, out_buf, out_len);
3072 }
3073
3074 #ifdef _POSIX
3075 static uint64_t count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3076 #endif
3077
3078 #ifdef _WIN
3079 static uint64_t count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3080 #endif
3081 {
3082 hc_signal (NULL);
3083
3084 dictstat_t d;
3085
3086 d.cnt = 0;
3087
3088 #ifdef _POSIX
3089 fstat (fileno (fd), &d.stat);
3090 #endif
3091
3092 #ifdef _WIN
3093 _fstat64 (fileno (fd), &d.stat);
3094 #endif
3095
3096 d.stat.st_mode = 0;
3097 d.stat.st_nlink = 0;
3098 d.stat.st_uid = 0;
3099 d.stat.st_gid = 0;
3100 d.stat.st_rdev = 0;
3101 d.stat.st_atime = 0;
3102
3103 #ifdef _POSIX
3104 d.stat.st_blksize = 0;
3105 d.stat.st_blocks = 0;
3106 #endif
3107
3108 if (d.stat.st_size == 0) return 0;
3109
3110 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3111
3112 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3113 {
3114 if (d_cache)
3115 {
3116 uint64_t cnt = d_cache->cnt;
3117
3118 uint64_t keyspace = cnt;
3119
3120 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3121 {
3122 keyspace *= data.gpu_rules_cnt;
3123 }
3124 else if (data.attack_kern == ATTACK_KERN_COMBI)
3125 {
3126 keyspace *= data.combs_cnt;
3127 }
3128
3129 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);
3130 if (data.quiet == 0) log_info ("");
3131
3132 hc_signal (sigHandler_default);
3133
3134 return (keyspace);
3135 }
3136 }
3137
3138 time_t now = 0;
3139 time_t prev = 0;
3140
3141 uint64_t comp = 0;
3142 uint64_t cnt = 0;
3143 uint64_t cnt2 = 0;
3144
3145 while (!feof (fd))
3146 {
3147 load_segment (wl_data, fd);
3148
3149 comp += wl_data->cnt;
3150
3151 uint32_t i = 0;
3152
3153 while (i < wl_data->cnt)
3154 {
3155 uint32_t len;
3156 uint32_t off;
3157
3158 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3159
3160 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3161 {
3162 char rule_buf_out[BLOCK_SIZE];
3163
3164 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3165
3166 int rule_len_out = -1;
3167
3168 if (len < BLOCK_SIZE)
3169 {
3170 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3171 }
3172
3173 if (rule_len_out < 0)
3174 {
3175 len = PW_MAX1;
3176 }
3177 else
3178 {
3179 len = rule_len_out;
3180 }
3181 }
3182
3183 if (len < PW_MAX1)
3184 {
3185 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3186 {
3187 cnt += data.gpu_rules_cnt;
3188 }
3189 else if (data.attack_kern == ATTACK_KERN_COMBI)
3190 {
3191 cnt += data.combs_cnt;
3192 }
3193
3194 d.cnt++;
3195 }
3196
3197 i += off;
3198
3199 cnt2++;
3200 }
3201
3202 time (&now);
3203
3204 if ((now - prev) == 0) continue;
3205
3206 float percent = (float) comp / (float) d.stat.st_size;
3207
3208 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);
3209
3210 time (&prev);
3211 }
3212
3213 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);
3214 if (data.quiet == 0) log_info ("");
3215
3216 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3217
3218 hc_signal (sigHandler_default);
3219
3220 return (cnt);
3221 }
3222
3223 static void pw_transpose_to_hi1 (const pw_t *p1, pw_t *p2)
3224 {
3225 memcpy (p2->hi1, p1->hi1, 64 * sizeof (uint));
3226 }
3227
3228 static uint pw_add_to_hc1 (hc_device_param_t *device_param, const uint8_t *pw_buf, const uint pw_len)
3229 {
3230 if (data.devices_status == STATUS_BYPASS) return 0;
3231
3232 pw_cache_t *pw_cache = device_param->pw_caches + pw_len;
3233
3234 uint cache_cnt = pw_cache->cnt;
3235
3236 uint8_t *pw_hc1 = pw_cache->pw_buf.hc1[cache_cnt];
3237
3238 memcpy (pw_hc1, pw_buf, pw_len);
3239
3240 memset (pw_hc1 + pw_len, 0, 256 - pw_len);
3241
3242 uint pws_cnt = device_param->pws_cnt;
3243
3244 cache_cnt++;
3245
3246 pw_t *pw = device_param->pws_buf + pws_cnt;
3247
3248 device_param->pw_transpose (&pw_cache->pw_buf, pw);
3249
3250 pw->pw_len = pw_len;
3251
3252 pws_cnt++;
3253
3254 device_param->pws_cnt = pws_cnt;
3255 device_param->pw_cnt = pws_cnt * 1;
3256
3257 cache_cnt = 0;
3258
3259 pw_cache->cnt = cache_cnt;
3260
3261 return pws_cnt;
3262 }
3263
3264 static void *thread_monitor (void *p)
3265 {
3266 uint runtime_check = 0;
3267 uint remove_check = 0;
3268 uint status_check = 0;
3269 uint hwmon_check = 0;
3270 uint restore_check = 0;
3271
3272 uint restore_left = data.restore_timer;
3273 uint remove_left = data.remove_timer;
3274 uint status_left = data.status_timer;
3275
3276 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3277
3278 // temperature controller "loopback" values
3279
3280 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3281 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3282
3283 int temp_threshold = 1; // degrees celcius
3284
3285 int fan_speed_min = 15; // in percentage
3286 int fan_speed_max = 100;
3287
3288 time_t last_temp_check_time;
3289
3290 uint sleep_time = 1;
3291
3292 if (data.runtime)
3293 runtime_check = 1;
3294
3295 if (data.restore_timer)
3296 restore_check = 1;
3297
3298 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3299 remove_check = 1;
3300
3301 if (data.status == 1)
3302 status_check = 1;
3303
3304 if (data.gpu_temp_disable == 0)
3305 {
3306 time (&last_temp_check_time);
3307
3308 hwmon_check = 1;
3309 }
3310
3311 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (hwmon_check == 0) && (restore_check == 0))
3312 {
3313 return (p);
3314 }
3315
3316 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3317 {
3318 hc_sleep (sleep_time);
3319
3320 if (data.devices_status != STATUS_RUNNING) continue;
3321
3322 /*
3323 if (hwmon_check == 1)
3324 {
3325 hc_thread_mutex_lock (mux_adl);
3326
3327 time_t temp_check_time;
3328
3329 time (&temp_check_time);
3330
3331 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3332
3333 if (Ta == 0) Ta = 1;
3334
3335 for (uint i = 0; i < data.devices_cnt; i++)
3336 {
3337 const int temperature = hm_get_temperature_with_device_id (i);
3338
3339 if (temperature > (int) data.gpu_temp_abort)
3340 {
3341 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", i + 1);
3342
3343 if (data.devices_status != STATUS_QUIT) myabort ();
3344
3345 break;
3346 }
3347
3348 const int gpu_temp_retain = data.gpu_temp_retain;
3349
3350 if (gpu_temp_retain)
3351 {
3352 if (data.hm_device[i].fan_supported == 1)
3353 {
3354 int temp_cur = temperature;
3355
3356 int temp_diff_new = gpu_temp_retain - temp_cur;
3357
3358 temp_diff_sum[i] = temp_diff_sum[i] + temp_diff_new;
3359
3360 // calculate Ta value (time difference in seconds between the last check and this check)
3361
3362 last_temp_check_time = temp_check_time;
3363
3364 float Kp = 1.8;
3365 float Ki = 0.005;
3366 float Kd = 6;
3367
3368 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3369
3370 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);
3371
3372 if (abs (fan_diff_required) >= temp_threshold)
3373 {
3374 const int fan_speed_cur = hm_get_fanspeed_with_device_id (i);
3375
3376 int fan_speed_level = fan_speed_cur;
3377
3378 if (fan_speed_chgd[i] == 0) fan_speed_level = temp_cur;
3379
3380 int fan_speed_new = fan_speed_level - fan_diff_required;
3381
3382 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3383 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3384
3385 if (fan_speed_new != fan_speed_cur)
3386 {
3387 int freely_change_fan_speed = (fan_speed_chgd[i] == 1);
3388 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3389
3390 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3391 {
3392 hm_set_fanspeed_with_device_id (i, fan_speed_new);
3393
3394 fan_speed_chgd[i] = 1;
3395 }
3396
3397 temp_diff_old[i] = temp_diff_new;
3398 }
3399 }
3400 }
3401 }
3402 }
3403
3404 hc_thread_mutex_unlock (mux_adl);
3405 }
3406 */
3407
3408 if (restore_check == 1)
3409 {
3410 restore_left--;
3411
3412 if (restore_left == 0)
3413 {
3414 if (data.restore_disable == 0) cycle_restore ();
3415
3416 restore_left = data.restore_timer;
3417 }
3418 }
3419
3420 if ((runtime_check == 1) && (data.runtime_start > 0))
3421 {
3422 time_t runtime_cur;
3423
3424 time (&runtime_cur);
3425
3426 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3427
3428 if (runtime_left <= 0)
3429 {
3430 if (data.benchmark == 0)
3431 {
3432 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3433 }
3434
3435 if (data.devices_status != STATUS_QUIT) myabort ();
3436 }
3437 }
3438
3439 if (remove_check == 1)
3440 {
3441 remove_left--;
3442
3443 if (remove_left == 0)
3444 {
3445 if (data.digests_saved != data.digests_done)
3446 {
3447 data.digests_saved = data.digests_done;
3448
3449 save_hash ();
3450 }
3451
3452 remove_left = data.remove_timer;
3453 }
3454 }
3455
3456 if (status_check == 1)
3457 {
3458 status_left--;
3459
3460 if (status_left == 0)
3461 {
3462 hc_thread_mutex_lock (mux_display);
3463
3464 if (data.quiet == 0) clear_prompt ();
3465
3466 if (data.quiet == 0) log_info ("");
3467
3468 status_display ();
3469
3470 if (data.quiet == 0) log_info ("");
3471
3472 hc_thread_mutex_unlock (mux_display);
3473
3474 status_left = data.status_timer;
3475 }
3476 }
3477 }
3478
3479 myfree (fan_speed_chgd);
3480
3481 myfree (temp_diff_old);
3482 myfree (temp_diff_sum);
3483
3484 p = NULL;
3485
3486 return (p);
3487 }
3488
3489 static void *thread_outfile_remove (void *p)
3490 {
3491 // some hash-dependent constants
3492 char *outfile_dir = data.outfile_check_directory;
3493 uint dgst_size = data.dgst_size;
3494 uint isSalted = data.isSalted;
3495 uint esalt_size = data.esalt_size;
3496 uint hash_mode = data.hash_mode;
3497
3498 uint outfile_check_timer = data.outfile_check_timer;
3499
3500 char separator = data.separator;
3501
3502 // some hash-dependent functions
3503 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3504 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3505
3506 // buffers
3507 hash_t hash_buf;
3508
3509 memset (&hash_buf, 0, sizeof (hash_buf));
3510
3511 hash_buf.digest = mymalloc (dgst_size);
3512
3513 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3514
3515 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3516
3517 uint digest_buf[64];
3518
3519 outfile_data_t *out_info = NULL;
3520
3521 char **out_files = NULL;
3522
3523 time_t folder_mtime = 0;
3524
3525 int out_cnt = 0;
3526
3527 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3528
3529 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3530 {
3531 hc_sleep (1);
3532
3533 if (data.devices_status != STATUS_RUNNING) continue;
3534
3535 check_left--;
3536
3537 if (check_left == 0)
3538 {
3539 struct stat outfile_check_stat;
3540
3541 if (stat (outfile_dir, &outfile_check_stat) == 0)
3542 {
3543 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3544
3545 if (is_dir == 1)
3546 {
3547 if (outfile_check_stat.st_mtime > folder_mtime)
3548 {
3549 char **out_files_new = scan_directory (outfile_dir);
3550
3551 int out_cnt_new = count_dictionaries (out_files_new);
3552
3553 outfile_data_t *out_info_new = NULL;
3554
3555 if (out_cnt_new > 0)
3556 {
3557 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3558
3559 for (int i = 0; i < out_cnt_new; i++)
3560 {
3561 out_info_new[i].file_name = out_files_new[i];
3562
3563 // check if there are files that we have seen/checked before (and not changed)
3564
3565 for (int j = 0; j < out_cnt; j++)
3566 {
3567 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
3568 {
3569 struct stat outfile_stat;
3570
3571 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
3572 {
3573 if (outfile_stat.st_ctime == out_info[j].ctime)
3574 {
3575 out_info_new[i].ctime = out_info[j].ctime;
3576 out_info_new[i].seek = out_info[j].seek;
3577 }
3578 }
3579 }
3580 }
3581 }
3582 }
3583
3584 local_free (out_info);
3585 local_free (out_files);
3586
3587 out_files = out_files_new;
3588 out_cnt = out_cnt_new;
3589 out_info = out_info_new;
3590
3591 folder_mtime = outfile_check_stat.st_mtime;
3592 }
3593
3594 for (int j = 0; j < out_cnt; j++)
3595 {
3596 FILE *fp = fopen (out_info[j].file_name, "rb");
3597
3598 if (fp != NULL)
3599 {
3600 //hc_thread_mutex_lock (mux_display);
3601
3602 #ifdef _POSIX
3603 struct stat outfile_stat;
3604
3605 fstat (fileno (fp), &outfile_stat);
3606 #endif
3607
3608 #ifdef _WIN
3609 struct stat64 outfile_stat;
3610
3611 _fstat64 (fileno (fp), &outfile_stat);
3612 #endif
3613
3614 if (outfile_stat.st_ctime > out_info[j].ctime)
3615 {
3616 out_info[j].ctime = outfile_stat.st_ctime;
3617 out_info[j].seek = 0;
3618 }
3619
3620 fseek (fp, out_info[j].seek, SEEK_SET);
3621
3622 while (!feof (fp))
3623 {
3624 char line_buf[BUFSIZ];
3625
3626 memset (line_buf, 0, BUFSIZ);
3627
3628 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
3629
3630 if (ptr == NULL) break;
3631
3632 int line_len = strlen (line_buf);
3633
3634 if (line_len <= 0) continue;
3635
3636 int iter = MAX_CUT_TRIES;
3637
3638 for (uint i = line_len - 1; i && iter; i--, line_len--)
3639 {
3640 if (line_buf[i] != separator) continue;
3641
3642 int parser_status = PARSER_OK;
3643
3644 if ((hash_mode != 2500) && (hash_mode != 6800))
3645 {
3646 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
3647 }
3648
3649 uint found = 0;
3650
3651 if (parser_status == PARSER_OK)
3652 {
3653 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
3654 {
3655 if (data.salts_shown[salt_pos] == 1) continue;
3656
3657 salt_t *salt_buf = &data.salts_buf[salt_pos];
3658
3659 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
3660 {
3661 uint idx = salt_buf->digests_offset + digest_pos;
3662
3663 if (data.digests_shown[idx] == 1) continue;
3664
3665 uint cracked = 0;
3666
3667 if (hash_mode == 6800)
3668 {
3669 if (i == salt_buf->salt_len)
3670 {
3671 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3672 }
3673 }
3674 else if (hash_mode == 2500)
3675 {
3676 // BSSID : MAC1 : MAC2 (:plain)
3677 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
3678 {
3679 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3680
3681 if (!cracked) continue;
3682
3683 // now compare MAC1 and MAC2 too, since we have this additional info
3684 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
3685 char *mac2_pos = mac1_pos + 12 + 1;
3686
3687 wpa_t *wpas = (wpa_t *) data.esalts_buf;
3688 wpa_t *wpa = &wpas[salt_pos];
3689
3690 uint pke[25];
3691
3692 char *pke_ptr = (char *) pke;
3693
3694 for (uint i = 0; i < 25; i++)
3695 {
3696 pke[i] = byte_swap_32 (wpa->pke[i]);
3697 }
3698
3699 unsigned char mac1[6];
3700 unsigned char mac2[6];
3701
3702 memcpy (mac1, pke_ptr + 23, 6);
3703 memcpy (mac2, pke_ptr + 29, 6);
3704
3705 // compare hex string(s) vs binary MAC address(es)
3706
3707 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3708 {
3709 if (mac1[i] != (unsigned char) hex_to_char (&mac1_pos[j]))
3710 {
3711 cracked = 0;
3712 break;
3713 }
3714 }
3715
3716 // early skip ;)
3717 if (!cracked) continue;
3718
3719 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3720 {
3721 if (mac2[i] != (unsigned char) hex_to_char (&mac2_pos[j]))
3722 {
3723 cracked = 0;
3724 break;
3725 }
3726 }
3727 }
3728 }
3729 else
3730 {
3731 char *digests_buf_ptr = (char *) data.digests_buf;
3732
3733 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
3734
3735 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
3736 }
3737
3738 if (cracked == 1)
3739 {
3740 found = 1;
3741
3742 data.digests_shown[idx] = 1;
3743
3744 data.digests_done++;
3745
3746 salt_buf->digests_done++;
3747
3748 if (salt_buf->digests_done == salt_buf->digests_cnt)
3749 {
3750 data.salts_shown[salt_pos] = 1;
3751
3752 data.salts_done++;
3753
3754 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
3755 }
3756 }
3757 }
3758
3759 if (data.devices_status == STATUS_CRACKED) break;
3760 }
3761 }
3762
3763 if (found) break;
3764
3765 if (data.devices_status == STATUS_CRACKED) break;
3766
3767 iter--;
3768 }
3769
3770 if (data.devices_status == STATUS_CRACKED) break;
3771 }
3772
3773 out_info[j].seek = ftell (fp);
3774
3775 //hc_thread_mutex_unlock (mux_display);
3776
3777 fclose (fp);
3778 }
3779 }
3780 }
3781 }
3782
3783 check_left = outfile_check_timer;
3784 }
3785 }
3786
3787 if (esalt_size) local_free (hash_buf.esalt);
3788
3789 if (isSalted) local_free (hash_buf.salt);
3790
3791 local_free (hash_buf.digest);
3792
3793 local_free (out_info);
3794
3795 local_free (out_files);
3796
3797 p = NULL;
3798
3799 return (p);
3800 }
3801
3802 static uint get_work (hc_device_param_t *device_param, const uint64_t max)
3803 {
3804 hc_thread_mutex_lock (mux_dispatcher);
3805
3806 const uint64_t words_cur = data.words_cur;
3807 const uint64_t words_base = (data.limit == 0) ? data.words_base : data.limit;
3808
3809 device_param->words_off = words_cur;
3810
3811 const uint64_t words_left = words_base - words_cur;
3812
3813 if (data.gpu_blocks_all > words_left)
3814 {
3815 if (data.gpu_blocks_div == 0)
3816 {
3817 data.gpu_blocks_div = find_gpu_blocks_div (words_left, data.gpu_blocks_all);
3818 }
3819 }
3820
3821 if (data.gpu_blocks_div)
3822 {
3823 if (device_param->gpu_blocks == device_param->gpu_blocks_user)
3824 {
3825 const uint32_t gpu_blocks_new = (float) device_param->gpu_blocks * data.gpu_blocks_div;
3826 const uint32_t gpu_power_new = gpu_blocks_new;
3827
3828 if (gpu_blocks_new < device_param->gpu_blocks)
3829 {
3830 device_param->gpu_blocks = gpu_blocks_new;
3831 device_param->gpu_power = gpu_power_new;
3832 }
3833 }
3834 }
3835
3836 const uint gpu_blocks = device_param->gpu_blocks;
3837
3838 uint work = MIN (words_left, gpu_blocks);
3839
3840 work = MIN (work, max);
3841
3842 data.words_cur += work;
3843
3844 hc_thread_mutex_unlock (mux_dispatcher);
3845
3846 return work;
3847 }
3848
3849 static void *thread_calc_stdin (void *p)
3850 {
3851 hc_device_param_t *device_param = (hc_device_param_t *) p;
3852
3853 const uint attack_kern = data.attack_kern;
3854
3855 const uint gpu_blocks = device_param->gpu_blocks;
3856
3857 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3858 {
3859 hc_thread_mutex_lock (mux_dispatcher);
3860
3861 if (feof (stdin) != 0)
3862 {
3863 hc_thread_mutex_unlock (mux_dispatcher);
3864
3865 break;
3866 }
3867
3868 uint words_cur = 0;
3869
3870 while (words_cur < gpu_blocks)
3871 {
3872 char buf[BUFSIZ];
3873
3874 char *line_buf = fgets (buf, sizeof (buf), stdin);
3875
3876 if (line_buf == NULL) break;
3877
3878 uint line_len = in_superchop (line_buf);
3879
3880 line_len = convert_from_hex (line_buf, line_len);
3881
3882 // post-process rule engine
3883
3884 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3885 {
3886 char rule_buf_out[BLOCK_SIZE];
3887
3888 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3889
3890 int rule_len_out = -1;
3891
3892 if (line_len < BLOCK_SIZE)
3893 {
3894 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
3895 }
3896
3897 if (rule_len_out < 0) continue;
3898
3899 line_buf = rule_buf_out;
3900 line_len = rule_len_out;
3901 }
3902
3903 if (line_len > PW_MAX)
3904 {
3905 continue;
3906 }
3907
3908 if (attack_kern == ATTACK_KERN_STRAIGHT)
3909 {
3910 if ((line_len < data.pw_min) || (line_len > data.pw_max))
3911 {
3912 hc_thread_mutex_lock (mux_counter);
3913
3914 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3915 {
3916 data.words_progress_rejected[salt_pos] += data.gpu_rules_cnt;
3917 }
3918
3919 hc_thread_mutex_unlock (mux_counter);
3920
3921 continue;
3922 }
3923 }
3924 else if (attack_kern == ATTACK_KERN_COMBI)
3925 {
3926 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
3927 // since we still need to combine the plains
3928
3929 if (line_len > data.pw_max)
3930 {
3931 hc_thread_mutex_lock (mux_counter);
3932
3933 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3934 {
3935 data.words_progress_rejected[salt_pos] += data.combs_cnt;
3936 }
3937
3938 hc_thread_mutex_unlock (mux_counter);
3939
3940 continue;
3941 }
3942 }
3943
3944 device_param->pw_add (device_param, (uint8_t *) line_buf, line_len);
3945
3946 words_cur++;
3947
3948 if (data.devices_status == STATUS_CRACKED) break;
3949 if (data.devices_status == STATUS_ABORTED) break;
3950 if (data.devices_status == STATUS_QUIT) break;
3951 if (data.devices_status == STATUS_BYPASS) break;
3952 }
3953
3954 hc_thread_mutex_unlock (mux_dispatcher);
3955
3956 if (data.devices_status == STATUS_CRACKED) break;
3957 if (data.devices_status == STATUS_ABORTED) break;
3958 if (data.devices_status == STATUS_QUIT) break;
3959 if (data.devices_status == STATUS_BYPASS) break;
3960
3961 // we need 2 flushing because we have two independant caches and it can occur
3962 // that one buffer is already at threshold plus for that length also exists
3963 // more data in the 2nd buffer so it would overflow
3964
3965 // flush session 1
3966
3967 {
3968 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
3969 {
3970 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
3971
3972 const uint pw_cache_cnt = pw_cache->cnt;
3973
3974 if (pw_cache_cnt == 0) continue;
3975
3976 pw_cache->cnt = 0;
3977
3978 uint pws_cnt = device_param->pws_cnt;
3979
3980 pw_t *pw = device_param->pws_buf + pws_cnt;
3981
3982 device_param->pw_transpose (&pw_cache->pw_buf, pw);
3983
3984 pw->pw_len = pw_len;
3985
3986 uint pw_cnt = device_param->pw_cnt;
3987
3988 pw_cnt += pw_cache_cnt;
3989
3990 device_param->pw_cnt = pw_cnt;
3991
3992 pws_cnt++;
3993
3994 device_param->pws_cnt = pws_cnt;
3995
3996 if (pws_cnt == device_param->gpu_power_user) break;
3997 }
3998
3999 const uint pw_cnt = device_param->pw_cnt;
4000 const uint pws_cnt = device_param->pws_cnt;
4001
4002 if (pws_cnt)
4003 {
4004 run_copy (device_param, pws_cnt);
4005
4006 run_cracker (device_param, pw_cnt, pws_cnt);
4007
4008 device_param->pw_cnt = 0;
4009 device_param->pws_cnt = 0;
4010 }
4011 }
4012
4013 // flush session 2
4014
4015 {
4016 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4017 {
4018 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4019
4020 const uint pw_cache_cnt = pw_cache->cnt;
4021
4022 if (pw_cache_cnt == 0) continue;
4023
4024 pw_cache->cnt = 0;
4025
4026 uint pws_cnt = device_param->pws_cnt;
4027
4028 pw_t *pw = device_param->pws_buf + pws_cnt;
4029
4030 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4031
4032 pw->pw_len = pw_len;
4033
4034 uint pw_cnt = device_param->pw_cnt;
4035
4036 pw_cnt += pw_cache_cnt;
4037
4038 device_param->pw_cnt = pw_cnt;
4039
4040 pws_cnt++;
4041
4042 device_param->pws_cnt = pws_cnt;
4043 }
4044
4045 const uint pw_cnt = device_param->pw_cnt;
4046 const uint pws_cnt = device_param->pws_cnt;
4047
4048 if (pws_cnt)
4049 {
4050 run_copy (device_param, pws_cnt);
4051
4052 run_cracker (device_param, pw_cnt, pws_cnt);
4053
4054 device_param->pw_cnt = 0;
4055 device_param->pws_cnt = 0;
4056 }
4057 }
4058 }
4059
4060 return NULL;
4061 }
4062
4063 static void *thread_calc (void *p)
4064 {
4065 hc_device_param_t *device_param = (hc_device_param_t *) p;
4066
4067 const uint attack_mode = data.attack_mode;
4068 const uint attack_kern = data.attack_kern;
4069
4070 if (attack_mode == ATTACK_MODE_BF)
4071 {
4072 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4073 {
4074 const uint work = get_work (device_param, -1);
4075
4076 if (work == 0) break;
4077
4078 const uint64_t words_off = device_param->words_off;
4079 const uint64_t words_fin = words_off + work;
4080
4081 const uint pw_cnt = work;
4082 const uint pws_cnt = work;
4083
4084 device_param->pw_cnt = pw_cnt;
4085 device_param->pws_cnt = pws_cnt;
4086
4087 if (pws_cnt)
4088 {
4089 run_copy (device_param, pws_cnt);
4090
4091 run_cracker (device_param, pw_cnt, pws_cnt);
4092
4093 device_param->pw_cnt = 0;
4094 device_param->pws_cnt = 0;
4095 }
4096
4097 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4098
4099 if (data.devices_status == STATUS_CRACKED) break;
4100 if (data.devices_status == STATUS_ABORTED) break;
4101 if (data.devices_status == STATUS_QUIT) break;
4102 if (data.devices_status == STATUS_BYPASS) break;
4103
4104 device_param->words_done = words_fin;
4105 }
4106 }
4107 else
4108 {
4109 const uint segment_size = data.segment_size;
4110
4111 char *dictfile = data.dictfile;
4112
4113 if (attack_mode == ATTACK_MODE_COMBI)
4114 {
4115 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4116 {
4117 dictfile = data.dictfile2;
4118 }
4119 }
4120
4121 FILE *fd = fopen (dictfile, "rb");
4122
4123 if (fd == NULL)
4124 {
4125 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4126
4127 return NULL;
4128 }
4129
4130 if (attack_mode == ATTACK_MODE_COMBI)
4131 {
4132 const uint combs_mode = data.combs_mode;
4133
4134 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4135 {
4136 const char *dictfilec = data.dictfile2;
4137
4138 FILE *combs_fp = fopen (dictfilec, "rb");
4139
4140 if (combs_fp == NULL)
4141 {
4142 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4143
4144 fclose (fd);
4145
4146 return NULL;
4147 }
4148
4149 device_param->combs_fp = combs_fp;
4150 }
4151 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4152 {
4153 const char *dictfilec = data.dictfile;
4154
4155 FILE *combs_fp = fopen (dictfilec, "rb");
4156
4157 if (combs_fp == NULL)
4158 {
4159 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4160
4161 fclose (fd);
4162
4163 return NULL;
4164 }
4165
4166 device_param->combs_fp = combs_fp;
4167 }
4168 }
4169
4170 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4171
4172 wl_data->buf = (char *) mymalloc (segment_size);
4173 wl_data->avail = segment_size;
4174 wl_data->incr = segment_size;
4175 wl_data->cnt = 0;
4176 wl_data->pos = 0;
4177
4178 uint64_t words_cur = 0;
4179
4180 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4181 {
4182 uint64_t words_off = 0;
4183 uint64_t words_fin = 0;
4184
4185 uint64_t max = -1;
4186
4187 while (max)
4188 {
4189 const uint work = get_work (device_param, max);
4190
4191 if (work == 0) break;
4192
4193 words_off = device_param->words_off;
4194 words_fin = words_off + work;
4195
4196 char *line_buf;
4197 uint line_len;
4198
4199 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4200
4201 max = 0;
4202
4203 for ( ; words_cur < words_fin; words_cur++)
4204 {
4205 get_next_word (wl_data, fd, &line_buf, &line_len);
4206
4207 line_len = convert_from_hex (line_buf, line_len);
4208
4209 // post-process rule engine
4210
4211 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4212 {
4213 char rule_buf_out[BLOCK_SIZE];
4214
4215 memset (rule_buf_out, 0, sizeof (rule_buf_out));
4216
4217 int rule_len_out = -1;
4218
4219 if (line_len < BLOCK_SIZE)
4220 {
4221 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4222 }
4223
4224 if (rule_len_out < 0) continue;
4225
4226 line_buf = rule_buf_out;
4227 line_len = rule_len_out;
4228 }
4229
4230 if (attack_kern == ATTACK_KERN_STRAIGHT)
4231 {
4232 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4233 {
4234 max++;
4235
4236 hc_thread_mutex_lock (mux_counter);
4237
4238 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4239 {
4240 data.words_progress_rejected[salt_pos] += data.gpu_rules_cnt;
4241 }
4242
4243 hc_thread_mutex_unlock (mux_counter);
4244
4245 continue;
4246 }
4247 }
4248 else if (attack_kern == ATTACK_KERN_COMBI)
4249 {
4250 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4251 // since we still need to combine the plains
4252
4253 if (line_len > data.pw_max)
4254 {
4255 max++;
4256
4257 hc_thread_mutex_lock (mux_counter);
4258
4259 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4260 {
4261 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4262 }
4263
4264 hc_thread_mutex_unlock (mux_counter);
4265
4266 continue;
4267 }
4268 }
4269
4270 device_param->pw_add (device_param, (uint8_t *) line_buf, line_len);
4271
4272 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4273
4274 if (data.devices_status == STATUS_CRACKED) break;
4275 if (data.devices_status == STATUS_ABORTED) break;
4276 if (data.devices_status == STATUS_QUIT) break;
4277 if (data.devices_status == STATUS_BYPASS) break;
4278 }
4279
4280 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4281
4282 if (data.devices_status == STATUS_CRACKED) break;
4283 if (data.devices_status == STATUS_ABORTED) break;
4284 if (data.devices_status == STATUS_QUIT) break;
4285 if (data.devices_status == STATUS_BYPASS) break;
4286 }
4287
4288 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4289
4290 if (data.devices_status == STATUS_CRACKED) break;
4291 if (data.devices_status == STATUS_ABORTED) break;
4292 if (data.devices_status == STATUS_QUIT) break;
4293 if (data.devices_status == STATUS_BYPASS) break;
4294
4295 // we need 2 flushing because we have two independant caches and it can occur
4296 // that one buffer is already at threshold plus for that length also exists
4297 // more data in the 2nd buffer so it would overflow
4298
4299 //
4300 // flush session 1
4301 //
4302
4303 {
4304 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4305 {
4306 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4307
4308 const uint pw_cache_cnt = pw_cache->cnt;
4309
4310 if (pw_cache_cnt == 0) continue;
4311
4312 pw_cache->cnt = 0;
4313
4314 uint pws_cnt = device_param->pws_cnt;
4315
4316 pw_t *pw = device_param->pws_buf + pws_cnt;
4317
4318 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4319
4320 pw->pw_len = pw_len;
4321
4322 uint pw_cnt = device_param->pw_cnt;
4323
4324 pw_cnt += pw_cache_cnt;
4325
4326 device_param->pw_cnt = pw_cnt;
4327
4328 pws_cnt++;
4329
4330 device_param->pws_cnt = pws_cnt;
4331
4332 if (pws_cnt == device_param->gpu_power_user) break;
4333 }
4334
4335 const uint pw_cnt = device_param->pw_cnt;
4336 const uint pws_cnt = device_param->pws_cnt;
4337
4338 if (pws_cnt)
4339 {
4340 run_copy (device_param, pws_cnt);
4341
4342 run_cracker (device_param, pw_cnt, pws_cnt);
4343
4344 device_param->pw_cnt = 0;
4345 device_param->pws_cnt = 0;
4346 }
4347
4348 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4349
4350 if (data.devices_status == STATUS_CRACKED) break;
4351 if (data.devices_status == STATUS_ABORTED) break;
4352 if (data.devices_status == STATUS_QUIT) break;
4353 if (data.devices_status == STATUS_BYPASS) break;
4354 }
4355
4356 //
4357 // flush session 2
4358 //
4359
4360 {
4361 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4362 {
4363 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4364
4365 const uint pw_cache_cnt = pw_cache->cnt;
4366
4367 if (pw_cache_cnt == 0) continue;
4368
4369 pw_cache->cnt = 0;
4370
4371 uint pws_cnt = device_param->pws_cnt;
4372
4373 pw_t *pw = device_param->pws_buf + pws_cnt;
4374
4375 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4376
4377 pw->pw_len = pw_len;
4378
4379 uint pw_cnt = device_param->pw_cnt;
4380
4381 pw_cnt += pw_cache_cnt;
4382
4383 device_param->pw_cnt = pw_cnt;
4384
4385 pws_cnt++;
4386
4387 device_param->pws_cnt = pws_cnt;
4388 }
4389
4390 const uint pw_cnt = device_param->pw_cnt;
4391 const uint pws_cnt = device_param->pws_cnt;
4392
4393 if (pws_cnt)
4394 {
4395 run_copy (device_param, pws_cnt);
4396
4397 run_cracker (device_param, pw_cnt, pws_cnt);
4398
4399 device_param->pw_cnt = 0;
4400 device_param->pws_cnt = 0;
4401 }
4402
4403 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4404
4405 if (data.devices_status == STATUS_CRACKED) break;
4406 if (data.devices_status == STATUS_ABORTED) break;
4407 if (data.devices_status == STATUS_QUIT) break;
4408 if (data.devices_status == STATUS_BYPASS) break;
4409 }
4410
4411 if (words_fin == 0) break;
4412
4413 device_param->words_done = words_fin;
4414 }
4415
4416 if (attack_mode == ATTACK_MODE_COMBI)
4417 {
4418 fclose (device_param->combs_fp);
4419 }
4420
4421 free (wl_data->buf);
4422 free (wl_data);
4423
4424 fclose (fd);
4425 }
4426
4427 return NULL;
4428 }
4429
4430 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos, const uint gpu_loops)
4431 {
4432 salt_t *salt_buf = &data.salts_buf[salt_pos];
4433
4434 device_param->kernel_params_buf32[24] = salt_pos;
4435 device_param->kernel_params_buf32[27] = 1;
4436 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4437 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4438 device_param->kernel_params_buf32[30] = 0;
4439 device_param->kernel_params_buf32[31] = 1;
4440
4441 char *dictfile_old = data.dictfile;
4442 char *dictfile2_old = data.dictfile2;
4443 char *mask_old = data.mask;
4444
4445 const char *weak_hash_check = "weak-hash-check";
4446
4447 data.dictfile = (char *) weak_hash_check;
4448 data.dictfile2 = (char *) weak_hash_check;
4449 data.mask = (char *) weak_hash_check;
4450
4451 /**
4452 * run the kernel
4453 */
4454
4455 if (data.attack_exec == ATTACK_EXEC_ON_GPU)
4456 {
4457 run_kernel (KERN_RUN_1, device_param, 1);
4458 }
4459 else
4460 {
4461 run_kernel (KERN_RUN_1, device_param, 1);
4462
4463 const uint iter = salt_buf->salt_iter;
4464
4465 for (uint loop_pos = 0; loop_pos < iter; loop_pos += gpu_loops)
4466 {
4467 uint loop_left = iter - loop_pos;
4468
4469 loop_left = MIN (loop_left, gpu_loops);
4470
4471 device_param->kernel_params_buf32[25] = loop_pos;
4472 device_param->kernel_params_buf32[26] = loop_left;
4473
4474 run_kernel (KERN_RUN_2, device_param, 1);
4475 }
4476
4477 run_kernel (KERN_RUN_3, device_param, 1);
4478 }
4479
4480 /**
4481 * result
4482 */
4483
4484 check_cracked (device_param, salt_pos);
4485
4486 /**
4487 * cleanup
4488 */
4489
4490 device_param->kernel_params_buf32[24] = 0;
4491 device_param->kernel_params_buf32[25] = 0;
4492 device_param->kernel_params_buf32[26] = 0;
4493 device_param->kernel_params_buf32[27] = 0;
4494 device_param->kernel_params_buf32[28] = 0;
4495 device_param->kernel_params_buf32[29] = 0;
4496 device_param->kernel_params_buf32[30] = 0;
4497 device_param->kernel_params_buf32[31] = 0;
4498
4499 data.dictfile = dictfile_old;
4500 data.dictfile2 = dictfile2_old;
4501 data.mask = mask_old;
4502 }
4503
4504 // hlfmt hashcat
4505
4506 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4507 {
4508 if (data.username == 0)
4509 {
4510 *hashbuf_pos = line_buf;
4511 *hashbuf_len = line_len;
4512 }
4513 else
4514 {
4515 char *pos = line_buf;
4516 int len = line_len;
4517
4518 for (int i = 0; i < line_len; i++, pos++, len--)
4519 {
4520 if (line_buf[i] == data.separator)
4521 {
4522 pos++;
4523
4524 len--;
4525
4526 break;
4527 }
4528 }
4529
4530 *hashbuf_pos = pos;
4531 *hashbuf_len = len;
4532 }
4533 }
4534
4535 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4536 {
4537 char *pos = NULL;
4538 int len = 0;
4539
4540 int sep_cnt = 0;
4541
4542 for (int i = 0; i < line_len; i++)
4543 {
4544 if (line_buf[i] == data.separator)
4545 {
4546 sep_cnt++;
4547
4548 continue;
4549 }
4550
4551 if (sep_cnt == 0)
4552 {
4553 if (pos == NULL) pos = line_buf + i;
4554
4555 len++;
4556 }
4557 }
4558
4559 *userbuf_pos = pos;
4560 *userbuf_len = len;
4561 }
4562
4563 // hlfmt pwdump
4564
4565 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
4566 {
4567 int sep_cnt = 0;
4568
4569 int sep2_len = 0;
4570 int sep3_len = 0;
4571
4572 for (int i = 0; i < line_len; i++)
4573 {
4574 if (line_buf[i] == ':')
4575 {
4576 sep_cnt++;
4577
4578 continue;
4579 }
4580
4581 if (sep_cnt == 2) sep2_len++;
4582 if (sep_cnt == 3) sep3_len++;
4583 }
4584
4585 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4586
4587 return 0;
4588 }
4589
4590 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4591 {
4592 char *pos = NULL;
4593 int len = 0;
4594
4595 int sep_cnt = 0;
4596
4597 for (int i = 0; i < line_len; i++)
4598 {
4599 if (line_buf[i] == ':')
4600 {
4601 sep_cnt++;
4602
4603 continue;
4604 }
4605
4606 if (data.hash_mode == 1000)
4607 {
4608 if (sep_cnt == 3)
4609 {
4610 if (pos == NULL) pos = line_buf + i;
4611
4612 len++;
4613 }
4614 }
4615 else if (data.hash_mode == 3000)
4616 {
4617 if (sep_cnt == 2)
4618 {
4619 if (pos == NULL) pos = line_buf + i;
4620
4621 len++;
4622 }
4623 }
4624 }
4625
4626 *hashbuf_pos = pos;
4627 *hashbuf_len = len;
4628 }
4629
4630 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4631 {
4632 char *pos = NULL;
4633 int len = 0;
4634
4635 int sep_cnt = 0;
4636
4637 for (int i = 0; i < line_len; i++)
4638 {
4639 if (line_buf[i] == ':')
4640 {
4641 sep_cnt++;
4642
4643 continue;
4644 }
4645
4646 if (sep_cnt == 0)
4647 {
4648 if (pos == NULL) pos = line_buf + i;
4649
4650 len++;
4651 }
4652 }
4653
4654 *userbuf_pos = pos;
4655 *userbuf_len = len;
4656 }
4657
4658 // hlfmt passwd
4659
4660 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
4661 {
4662 int sep_cnt = 0;
4663
4664 char sep5_first = 0;
4665 char sep6_first = 0;
4666
4667 for (int i = 0; i < line_len; i++)
4668 {
4669 if (line_buf[i] == ':')
4670 {
4671 sep_cnt++;
4672
4673 continue;
4674 }
4675
4676 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
4677 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
4678 }
4679
4680 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
4681
4682 return 0;
4683 }
4684
4685 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4686 {
4687 char *pos = NULL;
4688 int len = 0;
4689
4690 int sep_cnt = 0;
4691
4692 for (int i = 0; i < line_len; i++)
4693 {
4694 if (line_buf[i] == ':')
4695 {
4696 sep_cnt++;
4697
4698 continue;
4699 }
4700
4701 if (sep_cnt == 1)
4702 {
4703 if (pos == NULL) pos = line_buf + i;
4704
4705 len++;
4706 }
4707 }
4708
4709 *hashbuf_pos = pos;
4710 *hashbuf_len = len;
4711 }
4712
4713 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4714 {
4715 char *pos = NULL;
4716 int len = 0;
4717
4718 int sep_cnt = 0;
4719
4720 for (int i = 0; i < line_len; i++)
4721 {
4722 if (line_buf[i] == ':')
4723 {
4724 sep_cnt++;
4725
4726 continue;
4727 }
4728
4729 if (sep_cnt == 0)
4730 {
4731 if (pos == NULL) pos = line_buf + i;
4732
4733 len++;
4734 }
4735 }
4736
4737 *userbuf_pos = pos;
4738 *userbuf_len = len;
4739 }
4740
4741 // hlfmt shadow
4742
4743 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
4744 {
4745 int sep_cnt = 0;
4746
4747 for (int i = 0; i < line_len; i++)
4748 {
4749 if (line_buf[i] == ':') sep_cnt++;
4750 }
4751
4752 if (sep_cnt == 8) return 1;
4753
4754 return 0;
4755 }
4756
4757 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4758 {
4759 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
4760 }
4761
4762 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4763 {
4764 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
4765 }
4766
4767 // hlfmt main
4768
4769 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4770 {
4771 switch (hashfile_format)
4772 {
4773 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4774 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4775 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4776 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4777 }
4778 }
4779
4780 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4781 {
4782 switch (hashfile_format)
4783 {
4784 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
4785 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
4786 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
4787 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
4788 }
4789 }
4790
4791 static uint hlfmt_detect (FILE *fp, uint max_check)
4792 {
4793 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
4794
4795 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
4796 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
4797
4798 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
4799
4800 uint num_check = 0;
4801
4802 while (!feof (fp))
4803 {
4804 char line_buf[BUFSIZ];
4805
4806 int line_len = fgetl (fp, line_buf);
4807
4808 if (line_len == 0) continue;
4809
4810 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
4811 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
4812 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
4813
4814 if (num_check == max_check) break;
4815
4816 num_check++;
4817 }
4818
4819 uint hashlist_format = HLFMT_HASHCAT;
4820
4821 for (int i = 1; i < HLFMTS_CNT; i++)
4822 {
4823 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
4824
4825 hashlist_format = i;
4826 }
4827
4828 free (formats_cnt);
4829
4830 return hashlist_format;
4831 }
4832
4833 /**
4834 * main
4835 */
4836
4837 // temp ?
4838 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
4839 {
4840 return mymalloc (iSize);
4841 }
4842
4843 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)
4844 {
4845 uint64_t collisions = 0;
4846
4847 const uint dgst_pos0 = data.dgst_pos0;
4848 const uint dgst_pos1 = data.dgst_pos1;
4849 const uint dgst_pos2 = data.dgst_pos2;
4850 const uint dgst_pos3 = data.dgst_pos3;
4851
4852 memset (bitmap_a, 0, bitmap_size);
4853 memset (bitmap_b, 0, bitmap_size);
4854 memset (bitmap_c, 0, bitmap_size);
4855 memset (bitmap_d, 0, bitmap_size);
4856
4857 for (uint i = 0; i < digests_cnt; i++)
4858 {
4859 uint *digest_ptr = (uint *) digests_buf_ptr;
4860
4861 digests_buf_ptr += dgst_size;
4862
4863 const uint val0 = 1 << (digest_ptr[dgst_pos0] & 0x1f);
4864 const uint val1 = 1 << (digest_ptr[dgst_pos1] & 0x1f);
4865 const uint val2 = 1 << (digest_ptr[dgst_pos2] & 0x1f);
4866 const uint val3 = 1 << (digest_ptr[dgst_pos3] & 0x1f);
4867
4868 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
4869 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
4870 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
4871 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
4872
4873 if (bitmap_a[idx0] & val0) collisions++;
4874 if (bitmap_b[idx1] & val1) collisions++;
4875 if (bitmap_c[idx2] & val2) collisions++;
4876 if (bitmap_d[idx3] & val3) collisions++;
4877
4878 bitmap_a[idx0] |= val0;
4879 bitmap_b[idx1] |= val1;
4880 bitmap_c[idx2] |= val2;
4881 bitmap_d[idx3] |= val3;
4882
4883 if (collisions >= collisions_max) return 0x7fffffff;
4884 }
4885
4886 return collisions;
4887 }
4888
4889 int main (int argc, char **argv)
4890 {
4891 /**
4892 * To help users a bit
4893 */
4894
4895 char *compute = getenv ("COMPUTE");
4896
4897 if (compute)
4898 {
4899 char display[100];
4900
4901 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
4902
4903 putenv (display);
4904 }
4905 else
4906 {
4907 if (getenv ("DISPLAY") == NULL)
4908 putenv ((char *) "DISPLAY=:0");
4909 }
4910
4911 /*
4912 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
4913 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
4914
4915 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
4916 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
4917 */
4918
4919 /**
4920 * Real init
4921 */
4922
4923 memset (&data, 0, sizeof (hc_global_data_t));
4924
4925 time_t proc_start;
4926
4927 time (&proc_start);
4928
4929 data.proc_start = proc_start;
4930
4931 int myargc = argc;
4932 char **myargv = argv;
4933
4934 hc_thread_mutex_init (mux_dispatcher);
4935 hc_thread_mutex_init (mux_counter);
4936 hc_thread_mutex_init (mux_display);
4937 hc_thread_mutex_init (mux_adl);
4938
4939 /**
4940 * commandline parameters
4941 */
4942
4943 uint usage = USAGE;
4944 uint version = VERSION;
4945 uint quiet = QUIET;
4946 uint benchmark = BENCHMARK;
4947 uint benchmark_mode = BENCHMARK_MODE;
4948 uint show = SHOW;
4949 uint left = LEFT;
4950 uint username = USERNAME;
4951 uint remove = REMOVE;
4952 uint remove_timer = REMOVE_TIMER;
4953 uint64_t skip = SKIP;
4954 uint64_t limit = LIMIT;
4955 uint keyspace = KEYSPACE;
4956 uint potfile_disable = POTFILE_DISABLE;
4957 uint debug_mode = DEBUG_MODE;
4958 char *debug_file = NULL;
4959 char *induction_dir = NULL;
4960 char *outfile_check_dir = NULL;
4961 uint force = FORCE;
4962 uint runtime = RUNTIME;
4963 uint hash_mode = HASH_MODE;
4964 uint attack_mode = ATTACK_MODE;
4965 uint markov_disable = MARKOV_DISABLE;
4966 uint markov_classic = MARKOV_CLASSIC;
4967 uint markov_threshold = MARKOV_THRESHOLD;
4968 char *markov_hcstat = NULL;
4969 char *outfile = NULL;
4970 uint outfile_format = OUTFILE_FORMAT;
4971 uint outfile_autohex = OUTFILE_AUTOHEX;
4972 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
4973 uint restore = RESTORE;
4974 uint restore_timer = RESTORE_TIMER;
4975 uint restore_disable = RESTORE_DISABLE;
4976 uint status = STATUS;
4977 uint status_timer = STATUS_TIMER;
4978 uint status_automat = STATUS_AUTOMAT;
4979 uint loopback = LOOPBACK;
4980 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
4981 char *session = NULL;
4982 uint hex_charset = HEX_CHARSET;
4983 uint hex_salt = HEX_SALT;
4984 uint hex_wordlist = HEX_WORDLIST;
4985 uint rp_gen = RP_GEN;
4986 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
4987 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
4988 uint rp_gen_seed = RP_GEN_SEED;
4989 char *rule_buf_l = (char *) RULE_BUF_L;
4990 char *rule_buf_r = (char *) RULE_BUF_R;
4991 uint increment = INCREMENT;
4992 uint increment_min = INCREMENT_MIN;
4993 uint increment_max = INCREMENT_MAX;
4994 char *cpu_affinity = NULL;
4995 char *gpu_devices = NULL;
4996 char *truecrypt_keyfiles = NULL;
4997 uint workload_profile = WORKLOAD_PROFILE;
4998 uint gpu_accel = GPU_ACCEL;
4999 uint gpu_loops = GPU_LOOPS;
5000 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5001 uint gpu_temp_abort = GPU_TEMP_ABORT;
5002 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5003 uint powertune_enable = POWERTUNE_ENABLE;
5004 uint logfile_disable = LOGFILE_DISABLE;
5005 uint segment_size = SEGMENT_SIZE;
5006 uint scrypt_tmto = SCRYPT_TMTO;
5007 char separator = SEPARATOR;
5008 uint bitmap_min = BITMAP_MIN;
5009 uint bitmap_max = BITMAP_MAX;
5010 char *custom_charset_1 = NULL;
5011 char *custom_charset_2 = NULL;
5012 char *custom_charset_3 = NULL;
5013 char *custom_charset_4 = NULL;
5014
5015 #define IDX_HELP 'h'
5016 #define IDX_VERSION 'V'
5017 #define IDX_VERSION_LOWER 'v'
5018 #define IDX_QUIET 0xff02
5019 #define IDX_SHOW 0xff03
5020 #define IDX_LEFT 0xff04
5021 #define IDX_REMOVE 0xff05
5022 #define IDX_REMOVE_TIMER 0xff37
5023 #define IDX_SKIP 's'
5024 #define IDX_LIMIT 'l'
5025 #define IDX_KEYSPACE 0xff35
5026 #define IDX_POTFILE_DISABLE 0xff06
5027 #define IDX_DEBUG_MODE 0xff43
5028 #define IDX_DEBUG_FILE 0xff44
5029 #define IDX_INDUCTION_DIR 0xff46
5030 #define IDX_OUTFILE_CHECK_DIR 0xff47
5031 #define IDX_USERNAME 0xff07
5032 #define IDX_FORCE 0xff08
5033 #define IDX_RUNTIME 0xff09
5034 #define IDX_BENCHMARK 'b'
5035 #define IDX_BENCHMARK_MODE 0xff32
5036 #define IDX_HASH_MODE 'm'
5037 #define IDX_ATTACK_MODE 'a'
5038 #define IDX_RP_FILE 'r'
5039 #define IDX_RP_GEN 'g'
5040 #define IDX_RP_GEN_FUNC_MIN 0xff10
5041 #define IDX_RP_GEN_FUNC_MAX 0xff11
5042 #define IDX_RP_GEN_SEED 0xff34
5043 #define IDX_RULE_BUF_L 'j'
5044 #define IDX_RULE_BUF_R 'k'
5045 #define IDX_INCREMENT 'i'
5046 #define IDX_INCREMENT_MIN 0xff12
5047 #define IDX_INCREMENT_MAX 0xff13
5048 #define IDX_OUTFILE 'o'
5049 #define IDX_OUTFILE_FORMAT 0xff14
5050 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5051 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5052 #define IDX_RESTORE 0xff15
5053 #define IDX_RESTORE_DISABLE 0xff27
5054 #define IDX_STATUS 0xff17
5055 #define IDX_STATUS_TIMER 0xff18
5056 #define IDX_STATUS_AUTOMAT 0xff50
5057 #define IDX_LOOPBACK 0xff38
5058 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5059 #define IDX_SESSION 0xff19
5060 #define IDX_HEX_CHARSET 0xff20
5061 #define IDX_HEX_SALT 0xff21
5062 #define IDX_HEX_WORDLIST 0xff40
5063 #define IDX_MARKOV_DISABLE 0xff22
5064 #define IDX_MARKOV_CLASSIC 0xff23
5065 #define IDX_MARKOV_THRESHOLD 't'
5066 #define IDX_MARKOV_HCSTAT 0xff24
5067 #define IDX_CPU_AFFINITY 0xff25
5068 #define IDX_GPU_DEVICES 'd'
5069 #define IDX_WORKLOAD_PROFILE 'w'
5070 #define IDX_GPU_ACCEL 'n'
5071 #define IDX_GPU_LOOPS 'u'
5072 #define IDX_GPU_TEMP_DISABLE 0xff29
5073 #define IDX_GPU_TEMP_ABORT 0xff30
5074 #define IDX_GPU_TEMP_RETAIN 0xff31
5075 #define IDX_POWERTUNE_ENABLE 0xff41
5076 #define IDX_LOGFILE_DISABLE 0xff51
5077 #define IDX_TRUECRYPT_KEYFILES 0xff52
5078 #define IDX_SCRYPT_TMTO 0xff61
5079 #define IDX_SEGMENT_SIZE 'c'
5080 #define IDX_SEPARATOR 'p'
5081 #define IDX_BITMAP_MIN 0xff70
5082 #define IDX_BITMAP_MAX 0xff71
5083 #define IDX_CUSTOM_CHARSET_1 '1'
5084 #define IDX_CUSTOM_CHARSET_2 '2'
5085 #define IDX_CUSTOM_CHARSET_3 '3'
5086 #define IDX_CUSTOM_CHARSET_4 '4'
5087
5088 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5089
5090 struct option long_options[] =
5091 {
5092 {"help", no_argument, 0, IDX_HELP},
5093 {"version", no_argument, 0, IDX_VERSION},
5094 {"quiet", no_argument, 0, IDX_QUIET},
5095 {"show", no_argument, 0, IDX_SHOW},
5096 {"left", no_argument, 0, IDX_LEFT},
5097 {"username", no_argument, 0, IDX_USERNAME},
5098 {"remove", no_argument, 0, IDX_REMOVE},
5099 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5100 {"skip", required_argument, 0, IDX_SKIP},
5101 {"limit", required_argument, 0, IDX_LIMIT},
5102 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5103 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5104 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5105 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5106 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5107 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5108 {"force", no_argument, 0, IDX_FORCE},
5109 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5110 {"benchmark-mode", required_argument, 0, IDX_BENCHMARK_MODE},
5111 {"restore", no_argument, 0, IDX_RESTORE},
5112 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5113 {"status", no_argument, 0, IDX_STATUS},
5114 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5115 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5116 {"loopback", no_argument, 0, IDX_LOOPBACK},
5117 {"weak-hash-threshold",
5118 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5119 {"session", required_argument, 0, IDX_SESSION},
5120 {"runtime", required_argument, 0, IDX_RUNTIME},
5121 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5122 {"generate-rules-func-min",
5123 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5124 {"generate-rules-func-max",
5125 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5126 {"generate-rules-seed",
5127 required_argument, 0, IDX_RP_GEN_SEED},
5128 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5129 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5130 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5131 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5132 {"rules-file", required_argument, 0, IDX_RP_FILE},
5133 {"outfile", required_argument, 0, IDX_OUTFILE},
5134 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5135 {"outfile-autohex-disable",
5136 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5137 {"outfile-check-timer",
5138 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5139 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5140 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5141 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5142 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5143 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5144 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5145 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5146 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5147 {"gpu-devices", required_argument, 0, IDX_GPU_DEVICES},
5148 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5149 {"gpu-accel", required_argument, 0, IDX_GPU_ACCEL},
5150 {"gpu-loops", required_argument, 0, IDX_GPU_LOOPS},
5151 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5152 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5153 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5154 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5155 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5156 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5157 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5158 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5159 // deprecated
5160 {"seperator", required_argument, 0, IDX_SEPARATOR},
5161 {"separator", required_argument, 0, IDX_SEPARATOR},
5162 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5163 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5164 {"increment", no_argument, 0, IDX_INCREMENT},
5165 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5166 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5167 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5168 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5169 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5170 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5171
5172 {0, 0, 0, 0}
5173 };
5174
5175 uint rp_files_cnt = 0;
5176
5177 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5178
5179 int option_index;
5180 int c;
5181
5182 optind = 1;
5183 optopt = 0;
5184 option_index = 0;
5185
5186 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5187 {
5188 switch (c)
5189 {
5190 case IDX_HELP: usage = 1; break;
5191 case IDX_VERSION:
5192 case IDX_VERSION_LOWER: version = 1; break;
5193 case IDX_RESTORE: restore = 1; break;
5194 case IDX_SESSION: session = optarg; break;
5195 case IDX_SHOW: show = 1; break;
5196 case IDX_LEFT: left = 1; break;
5197 case '?': return (-1);
5198 }
5199 }
5200
5201 if (optopt != 0)
5202 {
5203 log_error ("ERROR: Invalid argument specified");
5204
5205 return (-1);
5206 }
5207
5208 /**
5209 * exit functions
5210 */
5211
5212 if (version)
5213 {
5214 log_info (VERSION_TXT);
5215
5216 return (0);
5217 }
5218
5219 if (usage)
5220 {
5221 usage_big_print (PROGNAME);
5222
5223 return (0);
5224 }
5225
5226 /**
5227 * session
5228 */
5229
5230 if (session == NULL) session = (char *) PROGNAME;
5231
5232 size_t session_size = strlen (session) + 32;
5233
5234 data.session = session;
5235
5236 char *eff_restore_file = (char *) mymalloc (session_size);
5237 char *new_restore_file = (char *) mymalloc (session_size);
5238
5239 snprintf (eff_restore_file, session_size - 1, "%s.restore", session);
5240 snprintf (new_restore_file, session_size - 1, "%s.restore.new", session);
5241
5242 data.eff_restore_file = eff_restore_file;
5243 data.new_restore_file = new_restore_file;
5244
5245 if (((show == 1) || (left == 1)) && (restore == 1))
5246 {
5247 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5248 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5249
5250 return (-1);
5251 }
5252
5253 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5254 if ((show == 1) || (left == 1))
5255 {
5256 restore_disable = 1;
5257
5258 restore = 0;
5259 }
5260
5261 data.restore_disable = restore_disable;
5262
5263 restore_data_t *rd = init_restore (argc, argv);
5264
5265 data.rd = rd;
5266
5267 /**
5268 * restore file
5269 */
5270
5271 if (restore == 1)
5272 {
5273 read_restore (eff_restore_file, rd);
5274
5275 if (rd->version_bin < RESTORE_MIN)
5276 {
5277 log_error ("ERROR: Incompatible restore-file version");
5278
5279 return (-1);
5280 }
5281
5282 myargc = rd->argc;
5283 myargv = rd->argv;
5284
5285 #ifdef _POSIX
5286 rd->pid = getpid ();
5287 #elif _WIN
5288 rd->pid = GetCurrentProcessId ();
5289 #endif
5290 }
5291
5292 uint hash_mode_chgd = 0;
5293 uint runtime_chgd = 0;
5294 uint gpu_loops_chgd = 0;
5295 uint gpu_accel_chgd = 0;
5296 uint attack_mode_chgd = 0;
5297 uint outfile_format_chgd = 0;
5298 uint rp_gen_seed_chgd = 0;
5299 uint remove_timer_chgd = 0;
5300 uint increment_min_chgd = 0;
5301 uint increment_max_chgd = 0;
5302 uint gpu_temp_abort_chgd = 0;
5303 uint gpu_temp_retain_chgd = 0;
5304
5305 optind = 1;
5306 optopt = 0;
5307 option_index = 0;
5308
5309 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5310 {
5311 switch (c)
5312 {
5313 //case IDX_HELP: usage = 1; break;
5314 //case IDX_VERSION: version = 1; break;
5315 //case IDX_RESTORE: restore = 1; break;
5316 case IDX_QUIET: quiet = 1; break;
5317 //case IDX_SHOW: show = 1; break;
5318 case IDX_SHOW: break;
5319 //case IDX_LEFT: left = 1; break;
5320 case IDX_LEFT: break;
5321 case IDX_USERNAME: username = 1; break;
5322 case IDX_REMOVE: remove = 1; break;
5323 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5324 remove_timer_chgd = 1; break;
5325 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5326 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5327 case IDX_DEBUG_FILE: debug_file = optarg; break;
5328 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5329 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5330 case IDX_FORCE: force = 1; break;
5331 case IDX_SKIP: skip = atoll (optarg); break;
5332 case IDX_LIMIT: limit = atoll (optarg); break;
5333 case IDX_KEYSPACE: keyspace = 1; break;
5334 case IDX_BENCHMARK: benchmark = 1; break;
5335 case IDX_BENCHMARK_MODE: benchmark_mode = atoi (optarg); break;
5336 case IDX_RESTORE: break;
5337 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5338 case IDX_STATUS: status = 1; break;
5339 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5340 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5341 case IDX_LOOPBACK: loopback = 1; break;
5342 case IDX_WEAK_HASH_THRESHOLD:
5343 weak_hash_threshold = atoi (optarg); break;
5344 //case IDX_SESSION: session = optarg; break;
5345 case IDX_SESSION: break;
5346 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5347 hash_mode_chgd = 1; break;
5348 case IDX_RUNTIME: runtime = atoi (optarg);
5349 runtime_chgd = 1; break;
5350 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5351 attack_mode_chgd = 1; break;
5352 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5353 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5354 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5355 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5356 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5357 rp_gen_seed_chgd = 1; break;
5358 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5359 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5360 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5361 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5362 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5363 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5364 case IDX_OUTFILE: outfile = optarg; break;
5365 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5366 outfile_format_chgd = 1; break;
5367 case IDX_OUTFILE_AUTOHEX_DISABLE:
5368 outfile_autohex = 0; break;
5369 case IDX_OUTFILE_CHECK_TIMER:
5370 outfile_check_timer = atoi (optarg); break;
5371 case IDX_HEX_CHARSET: hex_charset = 1; break;
5372 case IDX_HEX_SALT: hex_salt = 1; break;
5373 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5374 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5375 case IDX_GPU_DEVICES: gpu_devices = optarg; break;
5376 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg); break;
5377 case IDX_GPU_ACCEL: gpu_accel = atoi (optarg);
5378 gpu_accel_chgd = 1; break;
5379 case IDX_GPU_LOOPS: gpu_loops = atoi (optarg);
5380 gpu_loops_chgd = 1; break;
5381 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5382 case IDX_GPU_TEMP_ABORT: gpu_temp_abort_chgd = 1;
5383 gpu_temp_abort = atoi (optarg); break;
5384 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain_chgd = 1;
5385 gpu_temp_retain = atoi (optarg); break;
5386 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5387 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5388 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5389 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5390 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5391 case IDX_SEPARATOR: separator = optarg[0]; break;
5392 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5393 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5394 case IDX_INCREMENT: increment = 1; break;
5395 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5396 increment_min_chgd = 1; break;
5397 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5398 increment_max_chgd = 1; break;
5399 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5400 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5401 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5402 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5403
5404 default:
5405 log_error ("ERROR: Invalid argument specified");
5406 return (-1);
5407 }
5408 }
5409
5410 if (optopt != 0)
5411 {
5412 log_error ("ERROR: Invalid argument specified");
5413
5414 return (-1);
5415 }
5416
5417 /**
5418 * Inform user things getting started,
5419 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5420 * - we do not need to check algorithm_pos
5421 */
5422
5423 if (quiet == 0)
5424 {
5425 if (benchmark == 1)
5426 {
5427 log_info ("%s v%.2f starting in benchmark-mode...", PROGNAME, (float) VERSION_BIN / 100);
5428
5429 log_info ("");
5430 }
5431 else if (restore == 1)
5432 {
5433 log_info ("%s v%.2f starting in restore-mode...", PROGNAME, (float) VERSION_BIN / 100);
5434
5435 log_info ("");
5436 }
5437 else
5438 {
5439 log_info ("%s v%.2f starting...", PROGNAME, (float) VERSION_BIN / 100);
5440
5441 log_info ("");
5442 }
5443 }
5444
5445 /**
5446 * sanity check
5447 */
5448
5449 if (attack_mode > 7)
5450 {
5451 log_error ("ERROR: Invalid attack-mode specified");
5452
5453 return (-1);
5454 }
5455
5456 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5457 {
5458 log_error ("ERROR: Invalid runtime specified");
5459
5460 return (-1);
5461 }
5462
5463 if (hash_mode_chgd && hash_mode > 12800) // just added to remove compiler warnings for hash_mode_chgd
5464 {
5465 log_error ("ERROR: Invalid hash-type specified");
5466
5467 return (-1);
5468 }
5469
5470 // renamed hash modes
5471
5472 if (hash_mode_chgd)
5473 {
5474 int n = -1;
5475
5476 switch (hash_mode)
5477 {
5478 case 123: n = 124;
5479 break;
5480 }
5481
5482 if (n >= 0)
5483 {
5484 log_error ("Old -m specified, use -m %d instead", n);
5485
5486 return (-1);
5487 }
5488 }
5489
5490 if (username == 1)
5491 {
5492 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5493 {
5494 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5495
5496 return (-1);
5497 }
5498 }
5499
5500 if (outfile_format > 16)
5501 {
5502 log_error ("ERROR: Invalid outfile-format specified");
5503
5504 return (-1);
5505 }
5506
5507 if (left == 1)
5508 {
5509 if (outfile_format_chgd == 1)
5510 {
5511 if (outfile_format > 1)
5512 {
5513 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5514
5515 return (-1);
5516 }
5517 }
5518 else
5519 {
5520 outfile_format = OUTFILE_FMT_HASH;
5521 }
5522 }
5523
5524 if (show == 1)
5525 {
5526 if (outfile_format_chgd == 1)
5527 {
5528 if ((outfile_format > 7) && (outfile_format < 16))
5529 {
5530 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
5531
5532 return (-1);
5533 }
5534 }
5535 }
5536
5537 if (increment_min < INCREMENT_MIN)
5538 {
5539 log_error ("ERROR: Invalid increment-min specified");
5540
5541 return (-1);
5542 }
5543
5544 if (increment_max > INCREMENT_MAX)
5545 {
5546 log_error ("ERROR: Invalid increment-max specified");
5547
5548 return (-1);
5549 }
5550
5551 if (increment_min > increment_max)
5552 {
5553 log_error ("ERROR: Invalid increment-min specified");
5554
5555 return (-1);
5556 }
5557
5558 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
5559 {
5560 log_error ("ERROR: increment is not allowed in attack-mode 0");
5561
5562 return (-1);
5563 }
5564
5565 if ((increment == 0) && (increment_min_chgd == 1))
5566 {
5567 log_error ("ERROR: increment-min is only supported together with increment switch");
5568
5569 return (-1);
5570 }
5571
5572 if ((increment == 0) && (increment_max_chgd == 1))
5573 {
5574 log_error ("ERROR: increment-max is only supported together with increment switch");
5575
5576 return (-1);
5577 }
5578
5579 if (rp_files_cnt && rp_gen)
5580 {
5581 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
5582
5583 return (-1);
5584 }
5585
5586 if (rp_files_cnt || rp_gen)
5587 {
5588 if (attack_mode != ATTACK_MODE_STRAIGHT)
5589 {
5590 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
5591
5592 return (-1);
5593 }
5594 }
5595
5596 if (rp_gen_func_min > rp_gen_func_max)
5597 {
5598 log_error ("ERROR: Invalid rp-gen-func-min specified");
5599
5600 return (-1);
5601 }
5602
5603 if (gpu_accel_chgd == 1)
5604 {
5605 if (workload_profile != WORKLOAD_PROFILE)
5606 {
5607 log_error ("ERROR: gpu-accel parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5608
5609 return (-1);
5610 }
5611
5612 if (gpu_accel < 1)
5613 {
5614 log_error ("ERROR: Invalid gpu-accel specified");
5615
5616 return (-1);
5617 }
5618
5619 if (gpu_accel > 800)
5620 {
5621 log_error ("ERROR: Invalid gpu-accel specified");
5622
5623 return (-1);
5624 }
5625 }
5626
5627 if (gpu_loops_chgd == 1)
5628 {
5629 if (workload_profile != WORKLOAD_PROFILE)
5630 {
5631 log_error ("ERROR: gpu-loops parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5632
5633 return (-1);
5634 }
5635
5636 if (gpu_loops < 1)
5637 {
5638 log_error ("ERROR: Invalid gpu-loops specified");
5639
5640 return (-1);
5641 }
5642
5643 if (gpu_loops > 1024)
5644 {
5645 log_error ("ERROR: Invalid gpu-loops specified");
5646
5647 return (-1);
5648 }
5649 }
5650
5651 if (benchmark == 1)
5652 {
5653 if (workload_profile != WORKLOAD_PROFILE)
5654 {
5655 log_error ("ERROR: Using the workload-profile in benchmark mode is not allowed");
5656
5657 return (-1);
5658 }
5659 }
5660
5661 if ((workload_profile < 1) || (workload_profile > 3))
5662 {
5663 log_error ("ERROR: workload-profile %i not available", workload_profile);
5664
5665 return (-1);
5666 }
5667
5668 if (show == 1 || left == 1)
5669 {
5670 attack_mode = ATTACK_MODE_NONE;
5671
5672 if (remove == 1)
5673 {
5674 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
5675
5676 return (-1);
5677 }
5678
5679 if (potfile_disable == 1)
5680 {
5681 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
5682
5683 return (-1);
5684 }
5685 }
5686
5687 uint attack_kern = ATTACK_KERN_NONE;
5688
5689 switch (attack_mode)
5690 {
5691 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
5692 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
5693 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
5694 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
5695 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
5696 }
5697
5698 if (benchmark == 0)
5699 {
5700 if (keyspace == 1)
5701 {
5702 int num_additional_params = 1;
5703
5704 if (attack_kern == ATTACK_KERN_COMBI)
5705 {
5706 num_additional_params = 2;
5707 }
5708
5709 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
5710
5711 if (keyspace_wordlist_specified == 0) optind--;
5712 }
5713
5714 if (attack_kern == ATTACK_KERN_NONE)
5715 {
5716 if ((optind + 1) != myargc)
5717 {
5718 usage_mini_print (myargv[0]);
5719
5720 return (-1);
5721 }
5722 }
5723 else if (attack_kern == ATTACK_KERN_STRAIGHT)
5724 {
5725 if ((optind + 1) > myargc)
5726 {
5727 usage_mini_print (myargv[0]);
5728
5729 return (-1);
5730 }
5731 }
5732 else if (attack_kern == ATTACK_KERN_COMBI)
5733 {
5734 if ((optind + 3) != myargc)
5735 {
5736 usage_mini_print (myargv[0]);
5737
5738 return (-1);
5739 }
5740 }
5741 else if (attack_kern == ATTACK_KERN_BF)
5742 {
5743 if ((optind + 1) > myargc)
5744 {
5745 usage_mini_print (myargv[0]);
5746
5747 return (-1);
5748 }
5749 }
5750 else
5751 {
5752 usage_mini_print (myargv[0]);
5753
5754 return (-1);
5755 }
5756 }
5757 else
5758 {
5759 if (myargv[optind] != 0)
5760 {
5761 log_error ("ERROR: Invalid argument for benchmark mode specified");
5762
5763 return (-1);
5764 }
5765
5766 if (attack_mode_chgd == 1)
5767 {
5768 if (attack_mode != ATTACK_MODE_BF)
5769 {
5770 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
5771
5772 return (-1);
5773 }
5774 }
5775
5776 if (benchmark_mode == 0)
5777 {
5778 // nothing to do
5779 }
5780 else if (benchmark_mode == 1)
5781 {
5782 if (gpu_accel_chgd == 1 || gpu_loops_chgd == 1)
5783 {
5784 log_error ("ERROR: Benchmark-mode 1 does not allow gpu-accel or gpu-loops changed");
5785
5786 return (-1);
5787 }
5788 }
5789 else
5790 {
5791 log_error ("ERROR: Benchmark-mode must be 0 or 1");
5792
5793 return (-1);
5794 }
5795 }
5796
5797 if (skip != 0 && limit != 0)
5798 {
5799 limit += skip;
5800 }
5801
5802 if (keyspace == 1)
5803 {
5804 if (show == 1)
5805 {
5806 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
5807
5808 return (-1);
5809 }
5810 else if (left == 1)
5811 {
5812 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
5813
5814 return (-1);
5815 }
5816
5817 potfile_disable = 1;
5818
5819 restore_disable = 1;
5820
5821 restore = 0;
5822
5823 weak_hash_threshold = 0;
5824
5825 quiet = 1;
5826 }
5827
5828 if (remove_timer_chgd == 1)
5829 {
5830 if (remove == 0)
5831 {
5832 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
5833
5834 return (-1);
5835 }
5836
5837 if (remove_timer < 1)
5838 {
5839 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
5840
5841 return (-1);
5842 }
5843 }
5844
5845 if (loopback == 1)
5846 {
5847 if (attack_mode == ATTACK_MODE_BF)
5848 {
5849 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
5850
5851 return (-1);
5852 }
5853 else if (attack_mode == ATTACK_MODE_STRAIGHT)
5854 {
5855 if ((rp_files_cnt == 0) && (rp_gen == 0))
5856 {
5857 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
5858
5859 return (-1);
5860 }
5861 }
5862 }
5863
5864 if (debug_mode > 0)
5865 {
5866 if (attack_mode != ATTACK_MODE_STRAIGHT)
5867 {
5868 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
5869
5870 return (-1);
5871 }
5872
5873 if ((rp_files_cnt == 0) && (rp_gen == 0))
5874 {
5875 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
5876
5877 return (-1);
5878 }
5879 }
5880
5881 if (debug_mode > 4)
5882 {
5883 log_error ("ERROR: Invalid debug-mode specified");
5884
5885 return (-1);
5886 }
5887
5888 if (debug_file != NULL)
5889 {
5890 if (debug_mode < 1)
5891 {
5892 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
5893
5894 return (-1);
5895 }
5896 }
5897
5898 if (induction_dir != NULL)
5899 {
5900 if (attack_mode == ATTACK_MODE_BF)
5901 {
5902 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
5903
5904 return (-1);
5905 }
5906 }
5907
5908 /**
5909 * induction directory
5910 */
5911
5912 char *induction_directory = NULL;
5913
5914 if (attack_mode != ATTACK_MODE_BF)
5915 {
5916 if (induction_dir == NULL)
5917 {
5918 induction_directory = (char *) mymalloc (session_size);
5919
5920 snprintf (induction_directory, session_size - 1, "%s.%s", session, INDUCT_DIR);
5921
5922 // create induction folder if it does not already exist
5923
5924 if (keyspace == 0)
5925 {
5926 if (rmdir (induction_directory) == -1)
5927 {
5928 if (errno == ENOENT)
5929 {
5930 // good, we can ignore
5931 }
5932 else if (errno == ENOTEMPTY)
5933 {
5934 char *induction_directory_mv = (char *) mymalloc (session_size);
5935
5936 snprintf (induction_directory_mv, session_size - 1, "%s.induct.%d", session, (int) proc_start);
5937
5938 if (rename (induction_directory, induction_directory_mv) != 0)
5939 {
5940 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
5941
5942 return (-1);
5943 }
5944 }
5945 else
5946 {
5947 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
5948
5949 return (-1);
5950 }
5951 }
5952
5953 #ifdef _WIN
5954 #define mkdir(name,mode) mkdir (name)
5955 #endif
5956
5957 if (mkdir (induction_directory, 0700) == -1)
5958 {
5959 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
5960
5961 return (-1);
5962 }
5963 }
5964 }
5965 else
5966 {
5967 induction_directory = induction_dir;
5968 }
5969 }
5970
5971 data.induction_directory = induction_directory;
5972
5973 /**
5974 * loopback
5975 */
5976
5977 size_t loopback_size = session_size + strlen (LOOPBACK_FILE) + 12;
5978
5979 char *loopback_file = (char *) mymalloc (loopback_size);
5980
5981 /**
5982 * outfile-check directory
5983 */
5984
5985 char *outfile_check_directory = NULL;
5986
5987 if (outfile_check_dir == NULL)
5988 {
5989 outfile_check_directory = (char *) mymalloc (session_size);
5990
5991 snprintf (outfile_check_directory, session_size - 1, "%s.%s", session, OUTFILES_DIR);
5992 }
5993 else
5994 {
5995 outfile_check_directory = outfile_check_dir;
5996 }
5997
5998 data.outfile_check_directory = outfile_check_directory;
5999
6000 if (keyspace == 0)
6001 {
6002 struct stat outfile_check_stat;
6003
6004 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6005 {
6006 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6007
6008 if (is_dir == 0)
6009 {
6010 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6011
6012 return (-1);
6013 }
6014 }
6015 else if (outfile_check_dir == NULL)
6016 {
6017 #ifdef _WIN
6018 #define mkdir(name,mode) mkdir (name)
6019 #endif
6020
6021 if (mkdir (outfile_check_directory, 0700) == -1)
6022 {
6023 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6024
6025 return (-1);
6026 }
6027 }
6028 }
6029
6030 /**
6031 * special other stuff
6032 */
6033
6034 if (hash_mode == 9710)
6035 {
6036 outfile_format = 5;
6037 outfile_format_chgd = 1;
6038 }
6039
6040 if (hash_mode == 9810)
6041 {
6042 outfile_format = 5;
6043 outfile_format_chgd = 1;
6044 }
6045
6046 if (hash_mode == 10410)
6047 {
6048 outfile_format = 5;
6049 outfile_format_chgd = 1;
6050 }
6051
6052 /**
6053 * store stuff
6054 */
6055
6056 data.hash_mode = hash_mode;
6057 data.restore = restore;
6058 data.restore_timer = restore_timer;
6059 data.restore_disable = restore_disable;
6060 data.status = status;
6061 data.status_timer = status_timer;
6062 data.status_automat = status_automat;
6063 data.loopback = loopback;
6064 data.runtime = runtime;
6065 data.remove = remove;
6066 data.remove_timer = remove_timer;
6067 data.debug_mode = debug_mode;
6068 data.debug_file = debug_file;
6069 data.username = username;
6070 data.quiet = quiet;
6071 data.outfile = outfile;
6072 data.outfile_format = outfile_format;
6073 data.outfile_autohex = outfile_autohex;
6074 data.hex_charset = hex_charset;
6075 data.hex_salt = hex_salt;
6076 data.hex_wordlist = hex_wordlist;
6077 data.separator = separator;
6078 data.rp_files = rp_files;
6079 data.rp_files_cnt = rp_files_cnt;
6080 data.rp_gen = rp_gen;
6081 data.rp_gen_seed = rp_gen_seed;
6082 data.force = force;
6083 data.benchmark = benchmark;
6084 data.skip = skip;
6085 data.limit = limit;
6086 data.powertune_enable = powertune_enable;
6087 data.logfile_disable = logfile_disable;
6088 data.truecrypt_keyfiles = truecrypt_keyfiles;
6089 data.scrypt_tmto = scrypt_tmto;
6090
6091 /**
6092 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
6093 */
6094
6095 #ifdef LINUX
6096
6097 char *resolved_path = realpath (myargv[0], NULL);
6098
6099 char *install_dir = get_install_dir (resolved_path);
6100 char *profile_dir = NULL;
6101 char *session_dir = NULL;
6102
6103 if (strcmp (install_dir, INSTALL_FOLDER) == 0)
6104 {
6105 struct passwd *pw = getpwuid (getuid ());
6106
6107 const char *homedir = pw->pw_dir;
6108
6109 profile_dir = get_profile_dir (homedir);
6110 session_dir = get_session_dir (profile_dir, session);
6111 }
6112 else
6113 {
6114 profile_dir = install_dir;
6115 session_dir = install_dir;
6116 }
6117
6118 myfree (resolved_path);
6119
6120 #else
6121
6122 char *install_dir = get_install_dir (myargv[0]);
6123 char *profile_dir = install_dir;
6124 char *session_dir = install_dir;
6125
6126 #endif
6127
6128 data.install_dir = install_dir;
6129 data.profile_dir = profile_dir;
6130 data.session_dir = session_dir;
6131
6132 /**
6133 * cpu affinity
6134 */
6135
6136 if (cpu_affinity)
6137 {
6138 set_cpu_affinity (cpu_affinity);
6139 }
6140
6141 if (rp_gen_seed_chgd == 0)
6142 {
6143 srand (proc_start);
6144 }
6145 else
6146 {
6147 srand (rp_gen_seed);
6148 }
6149
6150 /**
6151 * logfile init
6152 */
6153
6154 if (logfile_disable == 0)
6155 {
6156 size_t logfile_size = strlen (session) + 32;
6157
6158 char *logfile = (char *) mymalloc (logfile_size);
6159
6160 snprintf (logfile, logfile_size - 1, "%s.log", session);
6161
6162 data.logfile = logfile;
6163
6164 char *topid = logfile_generate_topid ();
6165
6166 data.topid = topid;
6167 }
6168
6169 // logfile_append() checks for logfile_disable internally to make it easier from here
6170
6171 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6172 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6173 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6174 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6175 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6176 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6177 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6178 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6179 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6180 #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));
6181
6182 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6183 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6184 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6185 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6186 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6187 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6188 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6189 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6190
6191 logfile_top_msg ("START");
6192
6193 logfile_top_uint (attack_mode);
6194 logfile_top_uint (attack_kern);
6195 logfile_top_uint (benchmark);
6196 logfile_top_uint (benchmark_mode);
6197 logfile_top_uint (bitmap_min);
6198 logfile_top_uint (bitmap_max);
6199 logfile_top_uint (debug_mode);
6200 logfile_top_uint (force);
6201 logfile_top_uint (gpu_accel);
6202 logfile_top_uint (gpu_loops);
6203 logfile_top_uint (gpu_temp_abort);
6204 logfile_top_uint (gpu_temp_disable);
6205 logfile_top_uint (gpu_temp_retain);
6206 logfile_top_uint (hash_mode);
6207 logfile_top_uint (hex_charset);
6208 logfile_top_uint (hex_salt);
6209 logfile_top_uint (hex_wordlist);
6210 logfile_top_uint (increment);
6211 logfile_top_uint (increment_max);
6212 logfile_top_uint (increment_min);
6213 logfile_top_uint (keyspace);
6214 logfile_top_uint (left);
6215 logfile_top_uint (logfile_disable);
6216 logfile_top_uint (loopback);
6217 logfile_top_uint (markov_classic);
6218 logfile_top_uint (markov_disable);
6219 logfile_top_uint (markov_threshold);
6220 logfile_top_uint (outfile_autohex);
6221 logfile_top_uint (outfile_check_timer);
6222 logfile_top_uint (outfile_format);
6223 logfile_top_uint (potfile_disable);
6224 logfile_top_uint (powertune_enable);
6225 logfile_top_uint (scrypt_tmto);
6226 logfile_top_uint (quiet);
6227 logfile_top_uint (remove);
6228 logfile_top_uint (remove_timer);
6229 logfile_top_uint (restore);
6230 logfile_top_uint (restore_disable);
6231 logfile_top_uint (restore_timer);
6232 logfile_top_uint (rp_gen);
6233 logfile_top_uint (rp_gen_func_max);
6234 logfile_top_uint (rp_gen_func_min);
6235 logfile_top_uint (rp_gen_seed);
6236 logfile_top_uint (runtime);
6237 logfile_top_uint (segment_size);
6238 logfile_top_uint (show);
6239 logfile_top_uint (status);
6240 logfile_top_uint (status_automat);
6241 logfile_top_uint (status_timer);
6242 logfile_top_uint (usage);
6243 logfile_top_uint (username);
6244 logfile_top_uint (version);
6245 logfile_top_uint (weak_hash_threshold);
6246 logfile_top_uint (workload_profile);
6247 logfile_top_uint64 (limit);
6248 logfile_top_uint64 (skip);
6249 logfile_top_char (separator);
6250 logfile_top_string (cpu_affinity);
6251 logfile_top_string (custom_charset_1);
6252 logfile_top_string (custom_charset_2);
6253 logfile_top_string (custom_charset_3);
6254 logfile_top_string (custom_charset_4);
6255 logfile_top_string (debug_file);
6256 logfile_top_string (gpu_devices);
6257 logfile_top_string (induction_dir);
6258 logfile_top_string (markov_hcstat);
6259 logfile_top_string (outfile);
6260 logfile_top_string (outfile_check_dir);
6261 logfile_top_string (rule_buf_l);
6262 logfile_top_string (rule_buf_r);
6263 logfile_top_string (session);
6264 logfile_top_string (truecrypt_keyfiles);
6265
6266 /**
6267 * devices
6268 */
6269
6270 uint gpu_devicemask = devices_to_devicemask (gpu_devices);
6271
6272 /**
6273 * benchmark
6274 */
6275
6276 if (benchmark == 1)
6277 {
6278 /**
6279 * disable useless stuff for benchmark
6280 */
6281
6282 restore_timer = 0;
6283 status_timer = 0;
6284 restore_disable = 1;
6285 potfile_disable = 1;
6286 weak_hash_threshold = 0;
6287
6288 data.restore_timer = restore_timer;
6289 data.status_timer = status_timer;
6290 data.restore_disable = restore_disable;
6291
6292 if (benchmark_mode == 1)
6293 {
6294 markov_disable = 1;
6295 }
6296
6297 /**
6298 * force attack mode to be bruteforce
6299 */
6300
6301 attack_mode = ATTACK_MODE_BF;
6302 attack_kern = ATTACK_KERN_BF;
6303
6304 if (runtime_chgd == 0)
6305 {
6306 runtime = 4;
6307
6308 if (benchmark_mode == 1) runtime = 17;
6309
6310 data.runtime = runtime;
6311 }
6312 }
6313
6314 /**
6315 * config
6316 */
6317
6318 uint hash_type = 0;
6319 uint salt_type = 0;
6320 uint attack_exec = 0;
6321 uint opts_type = 0;
6322 uint kern_type = 0;
6323 uint dgst_size = 0;
6324 uint esalt_size = 0;
6325 uint opti_type = 0;
6326 uint dgst_pos0 = -1;
6327 uint dgst_pos1 = -1;
6328 uint dgst_pos2 = -1;
6329 uint dgst_pos3 = -1;
6330
6331 int (*parse_func) (char *, uint, hash_t *);
6332 int (*sort_by_digest) (const void *, const void *);
6333
6334 uint algorithm_pos = 0;
6335 uint algorithm_max = 1;
6336
6337 uint *algorithms = default_benchmark_algorithms;
6338
6339 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6340
6341 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6342 {
6343 /*
6344 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6345 * the following algos are skipped entirely
6346 */
6347
6348 if (algorithm_pos > 0)
6349 {
6350 local_free (rd);
6351
6352 rd = init_restore (argc, argv);
6353
6354 data.rd = rd;
6355 }
6356
6357 /**
6358 * update hash_mode in case of multihash benchmark
6359 */
6360
6361 if (benchmark == 1)
6362 {
6363 if (hash_mode_chgd == 0)
6364 {
6365 hash_mode = algorithms[algorithm_pos];
6366
6367 data.hash_mode = hash_mode;
6368 }
6369
6370 quiet = 1;
6371
6372 data.quiet = quiet;
6373 }
6374
6375 switch (hash_mode)
6376 {
6377 case 0: hash_type = HASH_TYPE_MD5;
6378 salt_type = SALT_TYPE_NONE;
6379 attack_exec = ATTACK_EXEC_ON_GPU;
6380 opts_type = OPTS_TYPE_PT_GENERATE_LE
6381 | OPTS_TYPE_PT_ADD80
6382 | OPTS_TYPE_PT_ADDBITS14;
6383 kern_type = KERN_TYPE_MD5;
6384 dgst_size = DGST_SIZE_4_4;
6385 parse_func = md5_parse_hash;
6386 sort_by_digest = sort_by_digest_4_4;
6387 opti_type = OPTI_TYPE_ZERO_BYTE
6388 | OPTI_TYPE_PRECOMPUTE_INIT
6389 | OPTI_TYPE_PRECOMPUTE_MERKLE
6390 | OPTI_TYPE_MEET_IN_MIDDLE
6391 | OPTI_TYPE_EARLY_SKIP
6392 | OPTI_TYPE_NOT_ITERATED
6393 | OPTI_TYPE_NOT_SALTED
6394 | OPTI_TYPE_RAW_HASH;
6395 dgst_pos0 = 0;
6396 dgst_pos1 = 3;
6397 dgst_pos2 = 2;
6398 dgst_pos3 = 1;
6399 break;
6400
6401 case 10: hash_type = HASH_TYPE_MD5;
6402 salt_type = SALT_TYPE_INTERN;
6403 attack_exec = ATTACK_EXEC_ON_GPU;
6404 opts_type = OPTS_TYPE_PT_GENERATE_LE
6405 | OPTS_TYPE_ST_ADD80
6406 | OPTS_TYPE_ST_ADDBITS14;
6407 kern_type = KERN_TYPE_MD5_PWSLT;
6408 dgst_size = DGST_SIZE_4_4;
6409 parse_func = md5s_parse_hash;
6410 sort_by_digest = sort_by_digest_4_4;
6411 opti_type = OPTI_TYPE_ZERO_BYTE
6412 | OPTI_TYPE_PRECOMPUTE_INIT
6413 | OPTI_TYPE_PRECOMPUTE_MERKLE
6414 | OPTI_TYPE_MEET_IN_MIDDLE
6415 | OPTI_TYPE_EARLY_SKIP
6416 | OPTI_TYPE_NOT_ITERATED
6417 | OPTI_TYPE_APPENDED_SALT
6418 | OPTI_TYPE_RAW_HASH;
6419 dgst_pos0 = 0;
6420 dgst_pos1 = 3;
6421 dgst_pos2 = 2;
6422 dgst_pos3 = 1;
6423 break;
6424
6425 case 11: hash_type = HASH_TYPE_MD5;
6426 salt_type = SALT_TYPE_INTERN;
6427 attack_exec = ATTACK_EXEC_ON_GPU;
6428 opts_type = OPTS_TYPE_PT_GENERATE_LE
6429 | OPTS_TYPE_ST_ADD80
6430 | OPTS_TYPE_ST_ADDBITS14;
6431 kern_type = KERN_TYPE_MD5_PWSLT;
6432 dgst_size = DGST_SIZE_4_4;
6433 parse_func = joomla_parse_hash;
6434 sort_by_digest = sort_by_digest_4_4;
6435 opti_type = OPTI_TYPE_ZERO_BYTE
6436 | OPTI_TYPE_PRECOMPUTE_INIT
6437 | OPTI_TYPE_PRECOMPUTE_MERKLE
6438 | OPTI_TYPE_MEET_IN_MIDDLE
6439 | OPTI_TYPE_EARLY_SKIP
6440 | OPTI_TYPE_NOT_ITERATED
6441 | OPTI_TYPE_APPENDED_SALT
6442 | OPTI_TYPE_RAW_HASH;
6443 dgst_pos0 = 0;
6444 dgst_pos1 = 3;
6445 dgst_pos2 = 2;
6446 dgst_pos3 = 1;
6447 break;
6448
6449 case 12: hash_type = HASH_TYPE_MD5;
6450 salt_type = SALT_TYPE_INTERN;
6451 attack_exec = ATTACK_EXEC_ON_GPU;
6452 opts_type = OPTS_TYPE_PT_GENERATE_LE
6453 | OPTS_TYPE_ST_ADD80
6454 | OPTS_TYPE_ST_ADDBITS14;
6455 kern_type = KERN_TYPE_MD5_PWSLT;
6456 dgst_size = DGST_SIZE_4_4;
6457 parse_func = postgresql_parse_hash;
6458 sort_by_digest = sort_by_digest_4_4;
6459 opti_type = OPTI_TYPE_ZERO_BYTE
6460 | OPTI_TYPE_PRECOMPUTE_INIT
6461 | OPTI_TYPE_PRECOMPUTE_MERKLE
6462 | OPTI_TYPE_MEET_IN_MIDDLE
6463 | OPTI_TYPE_EARLY_SKIP
6464 | OPTI_TYPE_NOT_ITERATED
6465 | OPTI_TYPE_APPENDED_SALT
6466 | OPTI_TYPE_RAW_HASH;
6467 dgst_pos0 = 0;
6468 dgst_pos1 = 3;
6469 dgst_pos2 = 2;
6470 dgst_pos3 = 1;
6471 break;
6472
6473 case 20: hash_type = HASH_TYPE_MD5;
6474 salt_type = SALT_TYPE_INTERN;
6475 attack_exec = ATTACK_EXEC_ON_GPU;
6476 opts_type = OPTS_TYPE_PT_GENERATE_LE
6477 | OPTS_TYPE_PT_ADD80
6478 | OPTS_TYPE_PT_ADDBITS14;
6479 kern_type = KERN_TYPE_MD5_SLTPW;
6480 dgst_size = DGST_SIZE_4_4;
6481 parse_func = md5s_parse_hash;
6482 sort_by_digest = sort_by_digest_4_4;
6483 opti_type = OPTI_TYPE_ZERO_BYTE
6484 | OPTI_TYPE_PRECOMPUTE_INIT
6485 | OPTI_TYPE_PRECOMPUTE_MERKLE
6486 | OPTI_TYPE_EARLY_SKIP
6487 | OPTI_TYPE_NOT_ITERATED
6488 | OPTI_TYPE_PREPENDED_SALT
6489 | OPTI_TYPE_RAW_HASH;
6490 dgst_pos0 = 0;
6491 dgst_pos1 = 3;
6492 dgst_pos2 = 2;
6493 dgst_pos3 = 1;
6494 break;
6495
6496 case 21: hash_type = HASH_TYPE_MD5;
6497 salt_type = SALT_TYPE_INTERN;
6498 attack_exec = ATTACK_EXEC_ON_GPU;
6499 opts_type = OPTS_TYPE_PT_GENERATE_LE
6500 | OPTS_TYPE_PT_ADD80
6501 | OPTS_TYPE_PT_ADDBITS14;
6502 kern_type = KERN_TYPE_MD5_SLTPW;
6503 dgst_size = DGST_SIZE_4_4;
6504 parse_func = osc_parse_hash;
6505 sort_by_digest = sort_by_digest_4_4;
6506 opti_type = OPTI_TYPE_ZERO_BYTE
6507 | OPTI_TYPE_PRECOMPUTE_INIT
6508 | OPTI_TYPE_PRECOMPUTE_MERKLE
6509 | OPTI_TYPE_EARLY_SKIP
6510 | OPTI_TYPE_NOT_ITERATED
6511 | OPTI_TYPE_PREPENDED_SALT
6512 | OPTI_TYPE_RAW_HASH;
6513 dgst_pos0 = 0;
6514 dgst_pos1 = 3;
6515 dgst_pos2 = 2;
6516 dgst_pos3 = 1;
6517 break;
6518
6519 case 22: hash_type = HASH_TYPE_MD5;
6520 salt_type = SALT_TYPE_EMBEDDED;
6521 attack_exec = ATTACK_EXEC_ON_GPU;
6522 opts_type = OPTS_TYPE_PT_GENERATE_LE
6523 | OPTS_TYPE_PT_ADD80
6524 | OPTS_TYPE_PT_ADDBITS14;
6525 kern_type = KERN_TYPE_MD5_SLTPW;
6526 dgst_size = DGST_SIZE_4_4;
6527 parse_func = netscreen_parse_hash;
6528 sort_by_digest = sort_by_digest_4_4;
6529 opti_type = OPTI_TYPE_ZERO_BYTE
6530 | OPTI_TYPE_PRECOMPUTE_INIT
6531 | OPTI_TYPE_PRECOMPUTE_MERKLE
6532 | OPTI_TYPE_EARLY_SKIP
6533 | OPTI_TYPE_NOT_ITERATED
6534 | OPTI_TYPE_PREPENDED_SALT
6535 | OPTI_TYPE_RAW_HASH;
6536 dgst_pos0 = 0;
6537 dgst_pos1 = 3;
6538 dgst_pos2 = 2;
6539 dgst_pos3 = 1;
6540 break;
6541
6542 case 23: hash_type = HASH_TYPE_MD5;
6543 salt_type = SALT_TYPE_EMBEDDED;
6544 attack_exec = ATTACK_EXEC_ON_GPU;
6545 opts_type = OPTS_TYPE_PT_GENERATE_LE
6546 | OPTS_TYPE_PT_ADD80
6547 | OPTS_TYPE_PT_ADDBITS14;
6548 kern_type = KERN_TYPE_MD5_SLTPW;
6549 dgst_size = DGST_SIZE_4_4;
6550 parse_func = skype_parse_hash;
6551 sort_by_digest = sort_by_digest_4_4;
6552 opti_type = OPTI_TYPE_ZERO_BYTE
6553 | OPTI_TYPE_PRECOMPUTE_INIT
6554 | OPTI_TYPE_PRECOMPUTE_MERKLE
6555 | OPTI_TYPE_EARLY_SKIP
6556 | OPTI_TYPE_NOT_ITERATED
6557 | OPTI_TYPE_PREPENDED_SALT
6558 | OPTI_TYPE_RAW_HASH;
6559 dgst_pos0 = 0;
6560 dgst_pos1 = 3;
6561 dgst_pos2 = 2;
6562 dgst_pos3 = 1;
6563 break;
6564
6565 case 30: hash_type = HASH_TYPE_MD5;
6566 salt_type = SALT_TYPE_INTERN;
6567 attack_exec = ATTACK_EXEC_ON_GPU;
6568 opts_type = OPTS_TYPE_PT_GENERATE_LE
6569 | OPTS_TYPE_PT_UNICODE
6570 | OPTS_TYPE_ST_ADD80
6571 | OPTS_TYPE_ST_ADDBITS14;
6572 kern_type = KERN_TYPE_MD5_PWUSLT;
6573 dgst_size = DGST_SIZE_4_4;
6574 parse_func = md5s_parse_hash;
6575 sort_by_digest = sort_by_digest_4_4;
6576 opti_type = OPTI_TYPE_ZERO_BYTE
6577 | OPTI_TYPE_PRECOMPUTE_INIT
6578 | OPTI_TYPE_PRECOMPUTE_MERKLE
6579 | OPTI_TYPE_MEET_IN_MIDDLE
6580 | OPTI_TYPE_EARLY_SKIP
6581 | OPTI_TYPE_NOT_ITERATED
6582 | OPTI_TYPE_APPENDED_SALT
6583 | OPTI_TYPE_RAW_HASH;
6584 dgst_pos0 = 0;
6585 dgst_pos1 = 3;
6586 dgst_pos2 = 2;
6587 dgst_pos3 = 1;
6588 break;
6589
6590 case 40: hash_type = HASH_TYPE_MD5;
6591 salt_type = SALT_TYPE_INTERN;
6592 attack_exec = ATTACK_EXEC_ON_GPU;
6593 opts_type = OPTS_TYPE_PT_GENERATE_LE
6594 | OPTS_TYPE_PT_ADD80
6595 | OPTS_TYPE_PT_ADDBITS14
6596 | OPTS_TYPE_PT_UNICODE;
6597 kern_type = KERN_TYPE_MD5_SLTPWU;
6598 dgst_size = DGST_SIZE_4_4;
6599 parse_func = md5s_parse_hash;
6600 sort_by_digest = sort_by_digest_4_4;
6601 opti_type = OPTI_TYPE_ZERO_BYTE
6602 | OPTI_TYPE_PRECOMPUTE_INIT
6603 | OPTI_TYPE_PRECOMPUTE_MERKLE
6604 | OPTI_TYPE_EARLY_SKIP
6605 | OPTI_TYPE_NOT_ITERATED
6606 | OPTI_TYPE_PREPENDED_SALT
6607 | OPTI_TYPE_RAW_HASH;
6608 dgst_pos0 = 0;
6609 dgst_pos1 = 3;
6610 dgst_pos2 = 2;
6611 dgst_pos3 = 1;
6612 break;
6613
6614 case 50: hash_type = HASH_TYPE_MD5;
6615 salt_type = SALT_TYPE_INTERN;
6616 attack_exec = ATTACK_EXEC_ON_GPU;
6617 opts_type = OPTS_TYPE_PT_GENERATE_LE
6618 | OPTS_TYPE_ST_ADD80
6619 | OPTS_TYPE_ST_ADDBITS14;
6620 kern_type = KERN_TYPE_HMACMD5_PW;
6621 dgst_size = DGST_SIZE_4_4;
6622 parse_func = hmacmd5_parse_hash;
6623 sort_by_digest = sort_by_digest_4_4;
6624 opti_type = OPTI_TYPE_ZERO_BYTE
6625 | OPTI_TYPE_NOT_ITERATED;
6626 dgst_pos0 = 0;
6627 dgst_pos1 = 3;
6628 dgst_pos2 = 2;
6629 dgst_pos3 = 1;
6630 break;
6631
6632 case 60: hash_type = HASH_TYPE_MD5;
6633 salt_type = SALT_TYPE_INTERN;
6634 attack_exec = ATTACK_EXEC_ON_GPU;
6635 opts_type = OPTS_TYPE_PT_GENERATE_LE
6636 | OPTS_TYPE_PT_ADD80
6637 | OPTS_TYPE_PT_ADDBITS14;
6638 kern_type = KERN_TYPE_HMACMD5_SLT;
6639 dgst_size = DGST_SIZE_4_4;
6640 parse_func = hmacmd5_parse_hash;
6641 sort_by_digest = sort_by_digest_4_4;
6642 opti_type = OPTI_TYPE_ZERO_BYTE
6643 | OPTI_TYPE_NOT_ITERATED;
6644 dgst_pos0 = 0;
6645 dgst_pos1 = 3;
6646 dgst_pos2 = 2;
6647 dgst_pos3 = 1;
6648 break;
6649
6650 case 100: hash_type = HASH_TYPE_SHA1;
6651 salt_type = SALT_TYPE_NONE;
6652 attack_exec = ATTACK_EXEC_ON_GPU;
6653 opts_type = OPTS_TYPE_PT_GENERATE_BE
6654 | OPTS_TYPE_PT_ADD80
6655 | OPTS_TYPE_PT_ADDBITS15;
6656 kern_type = KERN_TYPE_SHA1;
6657 dgst_size = DGST_SIZE_4_5;
6658 parse_func = sha1_parse_hash;
6659 sort_by_digest = sort_by_digest_4_5;
6660 opti_type = OPTI_TYPE_ZERO_BYTE
6661 | OPTI_TYPE_PRECOMPUTE_INIT
6662 | OPTI_TYPE_PRECOMPUTE_MERKLE
6663 | OPTI_TYPE_EARLY_SKIP
6664 | OPTI_TYPE_NOT_ITERATED
6665 | OPTI_TYPE_NOT_SALTED
6666 | OPTI_TYPE_RAW_HASH;
6667 dgst_pos0 = 3;
6668 dgst_pos1 = 4;
6669 dgst_pos2 = 2;
6670 dgst_pos3 = 1;
6671 break;
6672
6673 case 101: hash_type = HASH_TYPE_SHA1;
6674 salt_type = SALT_TYPE_NONE;
6675 attack_exec = ATTACK_EXEC_ON_GPU;
6676 opts_type = OPTS_TYPE_PT_GENERATE_BE
6677 | OPTS_TYPE_PT_ADD80
6678 | OPTS_TYPE_PT_ADDBITS15;
6679 kern_type = KERN_TYPE_SHA1;
6680 dgst_size = DGST_SIZE_4_5;
6681 parse_func = sha1b64_parse_hash;
6682 sort_by_digest = sort_by_digest_4_5;
6683 opti_type = OPTI_TYPE_ZERO_BYTE
6684 | OPTI_TYPE_PRECOMPUTE_INIT
6685 | OPTI_TYPE_PRECOMPUTE_MERKLE
6686 | OPTI_TYPE_EARLY_SKIP
6687 | OPTI_TYPE_NOT_ITERATED
6688 | OPTI_TYPE_NOT_SALTED
6689 | OPTI_TYPE_RAW_HASH;
6690 dgst_pos0 = 3;
6691 dgst_pos1 = 4;
6692 dgst_pos2 = 2;
6693 dgst_pos3 = 1;
6694 break;
6695
6696 case 110: hash_type = HASH_TYPE_SHA1;
6697 salt_type = SALT_TYPE_INTERN;
6698 attack_exec = ATTACK_EXEC_ON_GPU;
6699 opts_type = OPTS_TYPE_PT_GENERATE_BE
6700 | OPTS_TYPE_ST_ADD80
6701 | OPTS_TYPE_ST_ADDBITS15;
6702 kern_type = KERN_TYPE_SHA1_PWSLT;
6703 dgst_size = DGST_SIZE_4_5;
6704 parse_func = sha1s_parse_hash;
6705 sort_by_digest = sort_by_digest_4_5;
6706 opti_type = OPTI_TYPE_ZERO_BYTE
6707 | OPTI_TYPE_PRECOMPUTE_INIT
6708 | OPTI_TYPE_PRECOMPUTE_MERKLE
6709 | OPTI_TYPE_EARLY_SKIP
6710 | OPTI_TYPE_NOT_ITERATED
6711 | OPTI_TYPE_APPENDED_SALT
6712 | OPTI_TYPE_RAW_HASH;
6713 dgst_pos0 = 3;
6714 dgst_pos1 = 4;
6715 dgst_pos2 = 2;
6716 dgst_pos3 = 1;
6717 break;
6718
6719 case 111: hash_type = HASH_TYPE_SHA1;
6720 salt_type = SALT_TYPE_EMBEDDED;
6721 attack_exec = ATTACK_EXEC_ON_GPU;
6722 opts_type = OPTS_TYPE_PT_GENERATE_BE
6723 | OPTS_TYPE_ST_ADD80
6724 | OPTS_TYPE_ST_ADDBITS15;
6725 kern_type = KERN_TYPE_SHA1_PWSLT;
6726 dgst_size = DGST_SIZE_4_5;
6727 parse_func = sha1b64s_parse_hash;
6728 sort_by_digest = sort_by_digest_4_5;
6729 opti_type = OPTI_TYPE_ZERO_BYTE
6730 | OPTI_TYPE_PRECOMPUTE_INIT
6731 | OPTI_TYPE_PRECOMPUTE_MERKLE
6732 | OPTI_TYPE_EARLY_SKIP
6733 | OPTI_TYPE_NOT_ITERATED
6734 | OPTI_TYPE_APPENDED_SALT
6735 | OPTI_TYPE_RAW_HASH;
6736 dgst_pos0 = 3;
6737 dgst_pos1 = 4;
6738 dgst_pos2 = 2;
6739 dgst_pos3 = 1;
6740 break;
6741
6742 case 112: hash_type = HASH_TYPE_SHA1;
6743 salt_type = SALT_TYPE_INTERN;
6744 attack_exec = ATTACK_EXEC_ON_GPU;
6745 opts_type = OPTS_TYPE_PT_GENERATE_BE
6746 | OPTS_TYPE_ST_ADD80
6747 | OPTS_TYPE_ST_ADDBITS15
6748 | OPTS_TYPE_ST_HEX;
6749 kern_type = KERN_TYPE_SHA1_PWSLT;
6750 dgst_size = DGST_SIZE_4_5;
6751 parse_func = oracles_parse_hash;
6752 sort_by_digest = sort_by_digest_4_5;
6753 opti_type = OPTI_TYPE_ZERO_BYTE
6754 | OPTI_TYPE_PRECOMPUTE_INIT
6755 | OPTI_TYPE_PRECOMPUTE_MERKLE
6756 | OPTI_TYPE_EARLY_SKIP
6757 | OPTI_TYPE_NOT_ITERATED
6758 | OPTI_TYPE_APPENDED_SALT
6759 | OPTI_TYPE_RAW_HASH;
6760 dgst_pos0 = 3;
6761 dgst_pos1 = 4;
6762 dgst_pos2 = 2;
6763 dgst_pos3 = 1;
6764 break;
6765
6766 case 120: hash_type = HASH_TYPE_SHA1;
6767 salt_type = SALT_TYPE_INTERN;
6768 attack_exec = ATTACK_EXEC_ON_GPU;
6769 opts_type = OPTS_TYPE_PT_GENERATE_BE
6770 | OPTS_TYPE_PT_ADD80
6771 | OPTS_TYPE_PT_ADDBITS15;
6772 kern_type = KERN_TYPE_SHA1_SLTPW;
6773 dgst_size = DGST_SIZE_4_5;
6774 parse_func = sha1s_parse_hash;
6775 sort_by_digest = sort_by_digest_4_5;
6776 opti_type = OPTI_TYPE_ZERO_BYTE
6777 | OPTI_TYPE_PRECOMPUTE_INIT
6778 | OPTI_TYPE_PRECOMPUTE_MERKLE
6779 | OPTI_TYPE_EARLY_SKIP
6780 | OPTI_TYPE_NOT_ITERATED
6781 | OPTI_TYPE_PREPENDED_SALT
6782 | OPTI_TYPE_RAW_HASH;
6783 dgst_pos0 = 3;
6784 dgst_pos1 = 4;
6785 dgst_pos2 = 2;
6786 dgst_pos3 = 1;
6787 break;
6788
6789 case 121: hash_type = HASH_TYPE_SHA1;
6790 salt_type = SALT_TYPE_INTERN;
6791 attack_exec = ATTACK_EXEC_ON_GPU;
6792 opts_type = OPTS_TYPE_PT_GENERATE_BE
6793 | OPTS_TYPE_PT_ADD80
6794 | OPTS_TYPE_PT_ADDBITS15
6795 | OPTS_TYPE_ST_LOWER;
6796 kern_type = KERN_TYPE_SHA1_SLTPW;
6797 dgst_size = DGST_SIZE_4_5;
6798 parse_func = smf_parse_hash;
6799 sort_by_digest = sort_by_digest_4_5;
6800 opti_type = OPTI_TYPE_ZERO_BYTE
6801 | OPTI_TYPE_PRECOMPUTE_INIT
6802 | OPTI_TYPE_PRECOMPUTE_MERKLE
6803 | OPTI_TYPE_EARLY_SKIP
6804 | OPTI_TYPE_NOT_ITERATED
6805 | OPTI_TYPE_PREPENDED_SALT
6806 | OPTI_TYPE_RAW_HASH;
6807 dgst_pos0 = 3;
6808 dgst_pos1 = 4;
6809 dgst_pos2 = 2;
6810 dgst_pos3 = 1;
6811 break;
6812
6813 case 122: hash_type = HASH_TYPE_SHA1;
6814 salt_type = SALT_TYPE_EMBEDDED;
6815 attack_exec = ATTACK_EXEC_ON_GPU;
6816 opts_type = OPTS_TYPE_PT_GENERATE_BE
6817 | OPTS_TYPE_PT_ADD80
6818 | OPTS_TYPE_PT_ADDBITS15
6819 | OPTS_TYPE_ST_HEX;
6820 kern_type = KERN_TYPE_SHA1_SLTPW;
6821 dgst_size = DGST_SIZE_4_5;
6822 parse_func = osx1_parse_hash;
6823 sort_by_digest = sort_by_digest_4_5;
6824 opti_type = OPTI_TYPE_ZERO_BYTE
6825 | OPTI_TYPE_PRECOMPUTE_INIT
6826 | OPTI_TYPE_PRECOMPUTE_MERKLE
6827 | OPTI_TYPE_EARLY_SKIP
6828 | OPTI_TYPE_NOT_ITERATED
6829 | OPTI_TYPE_PREPENDED_SALT
6830 | OPTI_TYPE_RAW_HASH;
6831 dgst_pos0 = 3;
6832 dgst_pos1 = 4;
6833 dgst_pos2 = 2;
6834 dgst_pos3 = 1;
6835 break;
6836
6837 case 124: hash_type = HASH_TYPE_SHA1;
6838 salt_type = SALT_TYPE_EMBEDDED;
6839 attack_exec = ATTACK_EXEC_ON_GPU;
6840 opts_type = OPTS_TYPE_PT_GENERATE_BE
6841 | OPTS_TYPE_PT_ADD80
6842 | OPTS_TYPE_PT_ADDBITS15;
6843 kern_type = KERN_TYPE_SHA1_SLTPW;
6844 dgst_size = DGST_SIZE_4_5;
6845 parse_func = djangosha1_parse_hash;
6846 sort_by_digest = sort_by_digest_4_5;
6847 opti_type = OPTI_TYPE_ZERO_BYTE
6848 | OPTI_TYPE_PRECOMPUTE_INIT
6849 | OPTI_TYPE_PRECOMPUTE_MERKLE
6850 | OPTI_TYPE_EARLY_SKIP
6851 | OPTI_TYPE_NOT_ITERATED
6852 | OPTI_TYPE_PREPENDED_SALT
6853 | OPTI_TYPE_RAW_HASH;
6854 dgst_pos0 = 3;
6855 dgst_pos1 = 4;
6856 dgst_pos2 = 2;
6857 dgst_pos3 = 1;
6858 break;
6859
6860 case 130: hash_type = HASH_TYPE_SHA1;
6861 salt_type = SALT_TYPE_INTERN;
6862 attack_exec = ATTACK_EXEC_ON_GPU;
6863 opts_type = OPTS_TYPE_PT_GENERATE_BE
6864 | OPTS_TYPE_PT_UNICODE
6865 | OPTS_TYPE_ST_ADD80
6866 | OPTS_TYPE_ST_ADDBITS15;
6867 kern_type = KERN_TYPE_SHA1_PWUSLT;
6868 dgst_size = DGST_SIZE_4_5;
6869 parse_func = sha1s_parse_hash;
6870 sort_by_digest = sort_by_digest_4_5;
6871 opti_type = OPTI_TYPE_ZERO_BYTE
6872 | OPTI_TYPE_PRECOMPUTE_INIT
6873 | OPTI_TYPE_PRECOMPUTE_MERKLE
6874 | OPTI_TYPE_EARLY_SKIP
6875 | OPTI_TYPE_NOT_ITERATED
6876 | OPTI_TYPE_APPENDED_SALT
6877 | OPTI_TYPE_RAW_HASH;
6878 dgst_pos0 = 3;
6879 dgst_pos1 = 4;
6880 dgst_pos2 = 2;
6881 dgst_pos3 = 1;
6882 break;
6883
6884 case 131: hash_type = HASH_TYPE_SHA1;
6885 salt_type = SALT_TYPE_EMBEDDED;
6886 attack_exec = ATTACK_EXEC_ON_GPU;
6887 opts_type = OPTS_TYPE_PT_GENERATE_BE
6888 | OPTS_TYPE_PT_UNICODE
6889 | OPTS_TYPE_PT_UPPER
6890 | OPTS_TYPE_ST_ADD80
6891 | OPTS_TYPE_ST_ADDBITS15
6892 | OPTS_TYPE_ST_HEX;
6893 kern_type = KERN_TYPE_SHA1_PWUSLT;
6894 dgst_size = DGST_SIZE_4_5;
6895 parse_func = mssql2000_parse_hash;
6896 sort_by_digest = sort_by_digest_4_5;
6897 opti_type = OPTI_TYPE_ZERO_BYTE
6898 | OPTI_TYPE_PRECOMPUTE_INIT
6899 | OPTI_TYPE_PRECOMPUTE_MERKLE
6900 | OPTI_TYPE_EARLY_SKIP
6901 | OPTI_TYPE_NOT_ITERATED
6902 | OPTI_TYPE_APPENDED_SALT
6903 | OPTI_TYPE_RAW_HASH;
6904 dgst_pos0 = 3;
6905 dgst_pos1 = 4;
6906 dgst_pos2 = 2;
6907 dgst_pos3 = 1;
6908 break;
6909
6910 case 132: hash_type = HASH_TYPE_SHA1;
6911 salt_type = SALT_TYPE_EMBEDDED;
6912 attack_exec = ATTACK_EXEC_ON_GPU;
6913 opts_type = OPTS_TYPE_PT_GENERATE_BE
6914 | OPTS_TYPE_PT_UNICODE
6915 | OPTS_TYPE_ST_ADD80
6916 | OPTS_TYPE_ST_ADDBITS15
6917 | OPTS_TYPE_ST_HEX;
6918 kern_type = KERN_TYPE_SHA1_PWUSLT;
6919 dgst_size = DGST_SIZE_4_5;
6920 parse_func = mssql2005_parse_hash;
6921 sort_by_digest = sort_by_digest_4_5;
6922 opti_type = OPTI_TYPE_ZERO_BYTE
6923 | OPTI_TYPE_PRECOMPUTE_INIT
6924 | OPTI_TYPE_PRECOMPUTE_MERKLE
6925 | OPTI_TYPE_EARLY_SKIP
6926 | OPTI_TYPE_NOT_ITERATED
6927 | OPTI_TYPE_APPENDED_SALT
6928 | OPTI_TYPE_RAW_HASH;
6929 dgst_pos0 = 3;
6930 dgst_pos1 = 4;
6931 dgst_pos2 = 2;
6932 dgst_pos3 = 1;
6933 break;
6934
6935 case 133: hash_type = HASH_TYPE_SHA1;
6936 salt_type = SALT_TYPE_EMBEDDED;
6937 attack_exec = ATTACK_EXEC_ON_GPU;
6938 opts_type = OPTS_TYPE_PT_GENERATE_BE
6939 | OPTS_TYPE_PT_UNICODE
6940 | OPTS_TYPE_ST_ADD80
6941 | OPTS_TYPE_ST_ADDBITS15;
6942 kern_type = KERN_TYPE_SHA1_PWUSLT;
6943 dgst_size = DGST_SIZE_4_5;
6944 parse_func = peoplesoft_parse_hash;
6945 sort_by_digest = sort_by_digest_4_5;
6946 opti_type = OPTI_TYPE_ZERO_BYTE
6947 | OPTI_TYPE_PRECOMPUTE_INIT
6948 | OPTI_TYPE_PRECOMPUTE_MERKLE
6949 | OPTI_TYPE_EARLY_SKIP
6950 | OPTI_TYPE_NOT_ITERATED
6951 | OPTI_TYPE_APPENDED_SALT
6952 | OPTI_TYPE_RAW_HASH;
6953 dgst_pos0 = 3;
6954 dgst_pos1 = 4;
6955 dgst_pos2 = 2;
6956 dgst_pos3 = 1;
6957 break;
6958
6959 case 140: hash_type = HASH_TYPE_SHA1;
6960 salt_type = SALT_TYPE_INTERN;
6961 attack_exec = ATTACK_EXEC_ON_GPU;
6962 opts_type = OPTS_TYPE_PT_GENERATE_BE
6963 | OPTS_TYPE_PT_ADD80
6964 | OPTS_TYPE_PT_ADDBITS15
6965 | OPTS_TYPE_PT_UNICODE;
6966 kern_type = KERN_TYPE_SHA1_SLTPWU;
6967 dgst_size = DGST_SIZE_4_5;
6968 parse_func = sha1s_parse_hash;
6969 sort_by_digest = sort_by_digest_4_5;
6970 opti_type = OPTI_TYPE_ZERO_BYTE
6971 | OPTI_TYPE_PRECOMPUTE_INIT
6972 | OPTI_TYPE_PRECOMPUTE_MERKLE
6973 | OPTI_TYPE_EARLY_SKIP
6974 | OPTI_TYPE_NOT_ITERATED
6975 | OPTI_TYPE_PREPENDED_SALT
6976 | OPTI_TYPE_RAW_HASH;
6977 dgst_pos0 = 3;
6978 dgst_pos1 = 4;
6979 dgst_pos2 = 2;
6980 dgst_pos3 = 1;
6981 break;
6982
6983 case 141: hash_type = HASH_TYPE_SHA1;
6984 salt_type = SALT_TYPE_EMBEDDED;
6985 attack_exec = ATTACK_EXEC_ON_GPU;
6986 opts_type = OPTS_TYPE_PT_GENERATE_BE
6987 | OPTS_TYPE_PT_ADD80
6988 | OPTS_TYPE_PT_ADDBITS15
6989 | OPTS_TYPE_PT_UNICODE
6990 | OPTS_TYPE_ST_BASE64;
6991 kern_type = KERN_TYPE_SHA1_SLTPWU;
6992 dgst_size = DGST_SIZE_4_5;
6993 parse_func = episerver_parse_hash;
6994 sort_by_digest = sort_by_digest_4_5;
6995 opti_type = OPTI_TYPE_ZERO_BYTE
6996 | OPTI_TYPE_PRECOMPUTE_INIT
6997 | OPTI_TYPE_PRECOMPUTE_MERKLE
6998 | OPTI_TYPE_EARLY_SKIP
6999 | OPTI_TYPE_NOT_ITERATED
7000 | OPTI_TYPE_PREPENDED_SALT
7001 | OPTI_TYPE_RAW_HASH;
7002 dgst_pos0 = 3;
7003 dgst_pos1 = 4;
7004 dgst_pos2 = 2;
7005 dgst_pos3 = 1;
7006 break;
7007
7008 case 150: hash_type = HASH_TYPE_SHA1;
7009 salt_type = SALT_TYPE_INTERN;
7010 attack_exec = ATTACK_EXEC_ON_GPU;
7011 opts_type = OPTS_TYPE_PT_GENERATE_BE
7012 | OPTS_TYPE_ST_ADD80
7013 | OPTS_TYPE_ST_ADDBITS15;
7014 kern_type = KERN_TYPE_HMACSHA1_PW;
7015 dgst_size = DGST_SIZE_4_5;
7016 parse_func = hmacsha1_parse_hash;
7017 sort_by_digest = sort_by_digest_4_5;
7018 opti_type = OPTI_TYPE_ZERO_BYTE
7019 | OPTI_TYPE_NOT_ITERATED;
7020 dgst_pos0 = 3;
7021 dgst_pos1 = 4;
7022 dgst_pos2 = 2;
7023 dgst_pos3 = 1;
7024 break;
7025
7026 case 160: hash_type = HASH_TYPE_SHA1;
7027 salt_type = SALT_TYPE_INTERN;
7028 attack_exec = ATTACK_EXEC_ON_GPU;
7029 opts_type = OPTS_TYPE_PT_GENERATE_BE
7030 | OPTS_TYPE_PT_ADD80
7031 | OPTS_TYPE_PT_ADDBITS15;
7032 kern_type = KERN_TYPE_HMACSHA1_SLT;
7033 dgst_size = DGST_SIZE_4_5;
7034 parse_func = hmacsha1_parse_hash;
7035 sort_by_digest = sort_by_digest_4_5;
7036 opti_type = OPTI_TYPE_ZERO_BYTE
7037 | OPTI_TYPE_NOT_ITERATED;
7038 dgst_pos0 = 3;
7039 dgst_pos1 = 4;
7040 dgst_pos2 = 2;
7041 dgst_pos3 = 1;
7042 break;
7043
7044 case 190: hash_type = HASH_TYPE_SHA1;
7045 salt_type = SALT_TYPE_NONE;
7046 attack_exec = ATTACK_EXEC_ON_GPU;
7047 opts_type = OPTS_TYPE_PT_GENERATE_BE
7048 | OPTS_TYPE_PT_ADD80
7049 | OPTS_TYPE_PT_ADDBITS15;
7050 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7051 dgst_size = DGST_SIZE_4_5;
7052 parse_func = sha1linkedin_parse_hash;
7053 sort_by_digest = sort_by_digest_4_5;
7054 opti_type = OPTI_TYPE_ZERO_BYTE
7055 | OPTI_TYPE_PRECOMPUTE_INIT
7056 | OPTI_TYPE_EARLY_SKIP
7057 | OPTI_TYPE_NOT_ITERATED
7058 | OPTI_TYPE_NOT_SALTED;
7059 dgst_pos0 = 0;
7060 dgst_pos1 = 4;
7061 dgst_pos2 = 3;
7062 dgst_pos3 = 2;
7063 break;
7064
7065 case 200: hash_type = HASH_TYPE_MYSQL;
7066 salt_type = SALT_TYPE_NONE;
7067 attack_exec = ATTACK_EXEC_ON_GPU;
7068 opts_type = 0;
7069 kern_type = KERN_TYPE_MYSQL;
7070 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7071 parse_func = mysql323_parse_hash;
7072 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7073 opti_type = OPTI_TYPE_ZERO_BYTE;
7074 dgst_pos0 = 0;
7075 dgst_pos1 = 1;
7076 dgst_pos2 = 2;
7077 dgst_pos3 = 3;
7078 break;
7079
7080 case 300: hash_type = HASH_TYPE_SHA1;
7081 salt_type = SALT_TYPE_NONE;
7082 attack_exec = ATTACK_EXEC_ON_GPU;
7083 opts_type = OPTS_TYPE_PT_GENERATE_BE
7084 | OPTS_TYPE_PT_ADD80
7085 | OPTS_TYPE_PT_ADDBITS15;
7086 kern_type = KERN_TYPE_MYSQL41;
7087 dgst_size = DGST_SIZE_4_5;
7088 parse_func = sha1_parse_hash;
7089 sort_by_digest = sort_by_digest_4_5;
7090 opti_type = OPTI_TYPE_ZERO_BYTE
7091 | OPTI_TYPE_PRECOMPUTE_INIT
7092 | OPTI_TYPE_PRECOMPUTE_MERKLE
7093 | OPTI_TYPE_EARLY_SKIP
7094 | OPTI_TYPE_NOT_ITERATED
7095 | OPTI_TYPE_NOT_SALTED;
7096 dgst_pos0 = 3;
7097 dgst_pos1 = 4;
7098 dgst_pos2 = 2;
7099 dgst_pos3 = 1;
7100 break;
7101
7102 case 400: hash_type = HASH_TYPE_MD5;
7103 salt_type = SALT_TYPE_EMBEDDED;
7104 attack_exec = ATTACK_EXEC_ON_CPU;
7105 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7106 kern_type = KERN_TYPE_PHPASS;
7107 dgst_size = DGST_SIZE_4_4;
7108 parse_func = phpass_parse_hash;
7109 sort_by_digest = sort_by_digest_4_4;
7110 opti_type = OPTI_TYPE_ZERO_BYTE;
7111 dgst_pos0 = 0;
7112 dgst_pos1 = 1;
7113 dgst_pos2 = 2;
7114 dgst_pos3 = 3;
7115 break;
7116
7117 case 500: hash_type = HASH_TYPE_MD5;
7118 salt_type = SALT_TYPE_EMBEDDED;
7119 attack_exec = ATTACK_EXEC_ON_CPU;
7120 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7121 kern_type = KERN_TYPE_MD5CRYPT;
7122 dgst_size = DGST_SIZE_4_4;
7123 parse_func = md5crypt_parse_hash;
7124 sort_by_digest = sort_by_digest_4_4;
7125 opti_type = OPTI_TYPE_ZERO_BYTE;
7126 dgst_pos0 = 0;
7127 dgst_pos1 = 1;
7128 dgst_pos2 = 2;
7129 dgst_pos3 = 3;
7130 break;
7131
7132 case 501: hash_type = HASH_TYPE_MD5;
7133 salt_type = SALT_TYPE_EMBEDDED;
7134 attack_exec = ATTACK_EXEC_ON_CPU;
7135 opts_type = OPTS_TYPE_PT_GENERATE_LE
7136 | OPTS_TYPE_HASH_COPY;
7137 kern_type = KERN_TYPE_MD5CRYPT;
7138 dgst_size = DGST_SIZE_4_4;
7139 parse_func = juniper_parse_hash;
7140 sort_by_digest = sort_by_digest_4_4;
7141 opti_type = OPTI_TYPE_ZERO_BYTE;
7142 dgst_pos0 = 0;
7143 dgst_pos1 = 1;
7144 dgst_pos2 = 2;
7145 dgst_pos3 = 3;
7146 break;
7147
7148 case 900: hash_type = HASH_TYPE_MD4;
7149 salt_type = SALT_TYPE_NONE;
7150 attack_exec = ATTACK_EXEC_ON_GPU;
7151 opts_type = OPTS_TYPE_PT_GENERATE_LE
7152 | OPTS_TYPE_PT_ADD80
7153 | OPTS_TYPE_PT_ADDBITS14;
7154 kern_type = KERN_TYPE_MD4;
7155 dgst_size = DGST_SIZE_4_4;
7156 parse_func = md4_parse_hash;
7157 sort_by_digest = sort_by_digest_4_4;
7158 opti_type = OPTI_TYPE_ZERO_BYTE
7159 | OPTI_TYPE_PRECOMPUTE_INIT
7160 | OPTI_TYPE_PRECOMPUTE_MERKLE
7161 | OPTI_TYPE_MEET_IN_MIDDLE
7162 | OPTI_TYPE_EARLY_SKIP
7163 | OPTI_TYPE_NOT_ITERATED
7164 | OPTI_TYPE_NOT_SALTED
7165 | OPTI_TYPE_RAW_HASH;
7166 dgst_pos0 = 0;
7167 dgst_pos1 = 3;
7168 dgst_pos2 = 2;
7169 dgst_pos3 = 1;
7170 break;
7171
7172 case 1000: hash_type = HASH_TYPE_MD4;
7173 salt_type = SALT_TYPE_NONE;
7174 attack_exec = ATTACK_EXEC_ON_GPU;
7175 opts_type = OPTS_TYPE_PT_GENERATE_LE
7176 | OPTS_TYPE_PT_ADD80
7177 | OPTS_TYPE_PT_ADDBITS14
7178 | OPTS_TYPE_PT_UNICODE;
7179 kern_type = KERN_TYPE_MD4_PWU;
7180 dgst_size = DGST_SIZE_4_4;
7181 parse_func = md4_parse_hash;
7182 sort_by_digest = sort_by_digest_4_4;
7183 opti_type = OPTI_TYPE_ZERO_BYTE
7184 | OPTI_TYPE_PRECOMPUTE_INIT
7185 | OPTI_TYPE_PRECOMPUTE_MERKLE
7186 | OPTI_TYPE_MEET_IN_MIDDLE
7187 | OPTI_TYPE_EARLY_SKIP
7188 | OPTI_TYPE_NOT_ITERATED
7189 | OPTI_TYPE_NOT_SALTED
7190 | OPTI_TYPE_RAW_HASH;
7191 dgst_pos0 = 0;
7192 dgst_pos1 = 3;
7193 dgst_pos2 = 2;
7194 dgst_pos3 = 1;
7195 break;
7196
7197 case 1100: hash_type = HASH_TYPE_MD4;
7198 salt_type = SALT_TYPE_INTERN;
7199 attack_exec = ATTACK_EXEC_ON_GPU;
7200 opts_type = OPTS_TYPE_PT_GENERATE_LE
7201 | OPTS_TYPE_PT_ADD80
7202 | OPTS_TYPE_PT_ADDBITS14
7203 | OPTS_TYPE_PT_UNICODE
7204 | OPTS_TYPE_ST_ADD80
7205 | OPTS_TYPE_ST_UNICODE
7206 | OPTS_TYPE_ST_LOWER;
7207 kern_type = KERN_TYPE_MD44_PWUSLT;
7208 dgst_size = DGST_SIZE_4_4;
7209 parse_func = dcc_parse_hash;
7210 sort_by_digest = sort_by_digest_4_4;
7211 opti_type = OPTI_TYPE_ZERO_BYTE
7212 | OPTI_TYPE_PRECOMPUTE_INIT
7213 | OPTI_TYPE_PRECOMPUTE_MERKLE
7214 | OPTI_TYPE_EARLY_SKIP
7215 | OPTI_TYPE_NOT_ITERATED;
7216 dgst_pos0 = 0;
7217 dgst_pos1 = 3;
7218 dgst_pos2 = 2;
7219 dgst_pos3 = 1;
7220 break;
7221
7222 case 1400: hash_type = HASH_TYPE_SHA256;
7223 salt_type = SALT_TYPE_NONE;
7224 attack_exec = ATTACK_EXEC_ON_GPU;
7225 opts_type = OPTS_TYPE_PT_GENERATE_BE
7226 | OPTS_TYPE_PT_ADD80
7227 | OPTS_TYPE_PT_ADDBITS15;
7228 kern_type = KERN_TYPE_SHA256;
7229 dgst_size = DGST_SIZE_4_8;
7230 parse_func = sha256_parse_hash;
7231 sort_by_digest = sort_by_digest_4_8;
7232 opti_type = OPTI_TYPE_ZERO_BYTE
7233 | OPTI_TYPE_PRECOMPUTE_INIT
7234 | OPTI_TYPE_PRECOMPUTE_MERKLE
7235 | OPTI_TYPE_EARLY_SKIP
7236 | OPTI_TYPE_NOT_ITERATED
7237 | OPTI_TYPE_NOT_SALTED
7238 | OPTI_TYPE_RAW_HASH;
7239 dgst_pos0 = 3;
7240 dgst_pos1 = 7;
7241 dgst_pos2 = 2;
7242 dgst_pos3 = 6;
7243 break;
7244
7245 case 1410: hash_type = HASH_TYPE_SHA256;
7246 salt_type = SALT_TYPE_INTERN;
7247 attack_exec = ATTACK_EXEC_ON_GPU;
7248 opts_type = OPTS_TYPE_PT_GENERATE_BE
7249 | OPTS_TYPE_ST_ADD80
7250 | OPTS_TYPE_ST_ADDBITS15;
7251 kern_type = KERN_TYPE_SHA256_PWSLT;
7252 dgst_size = DGST_SIZE_4_8;
7253 parse_func = sha256s_parse_hash;
7254 sort_by_digest = sort_by_digest_4_8;
7255 opti_type = OPTI_TYPE_ZERO_BYTE
7256 | OPTI_TYPE_PRECOMPUTE_INIT
7257 | OPTI_TYPE_PRECOMPUTE_MERKLE
7258 | OPTI_TYPE_EARLY_SKIP
7259 | OPTI_TYPE_NOT_ITERATED
7260 | OPTI_TYPE_APPENDED_SALT
7261 | OPTI_TYPE_RAW_HASH;
7262 dgst_pos0 = 3;
7263 dgst_pos1 = 7;
7264 dgst_pos2 = 2;
7265 dgst_pos3 = 6;
7266 break;
7267
7268 case 1420: hash_type = HASH_TYPE_SHA256;
7269 salt_type = SALT_TYPE_INTERN;
7270 attack_exec = ATTACK_EXEC_ON_GPU;
7271 opts_type = OPTS_TYPE_PT_GENERATE_BE
7272 | OPTS_TYPE_PT_ADD80
7273 | OPTS_TYPE_PT_ADDBITS15;
7274 kern_type = KERN_TYPE_SHA256_SLTPW;
7275 dgst_size = DGST_SIZE_4_8;
7276 parse_func = sha256s_parse_hash;
7277 sort_by_digest = sort_by_digest_4_8;
7278 opti_type = OPTI_TYPE_ZERO_BYTE
7279 | OPTI_TYPE_PRECOMPUTE_INIT
7280 | OPTI_TYPE_PRECOMPUTE_MERKLE
7281 | OPTI_TYPE_EARLY_SKIP
7282 | OPTI_TYPE_NOT_ITERATED
7283 | OPTI_TYPE_PREPENDED_SALT
7284 | OPTI_TYPE_RAW_HASH;
7285 dgst_pos0 = 3;
7286 dgst_pos1 = 7;
7287 dgst_pos2 = 2;
7288 dgst_pos3 = 6;
7289 break;
7290
7291 case 1421: hash_type = HASH_TYPE_SHA256;
7292 salt_type = SALT_TYPE_EMBEDDED;
7293 attack_exec = ATTACK_EXEC_ON_GPU;
7294 opts_type = OPTS_TYPE_PT_GENERATE_BE
7295 | OPTS_TYPE_PT_ADD80
7296 | OPTS_TYPE_PT_ADDBITS15;
7297 kern_type = KERN_TYPE_SHA256_SLTPW;
7298 dgst_size = DGST_SIZE_4_8;
7299 parse_func = hmailserver_parse_hash;
7300 sort_by_digest = sort_by_digest_4_8;
7301 opti_type = OPTI_TYPE_ZERO_BYTE
7302 | OPTI_TYPE_PRECOMPUTE_INIT
7303 | OPTI_TYPE_PRECOMPUTE_MERKLE
7304 | OPTI_TYPE_EARLY_SKIP
7305 | OPTI_TYPE_NOT_ITERATED
7306 | OPTI_TYPE_PREPENDED_SALT
7307 | OPTI_TYPE_RAW_HASH;
7308 dgst_pos0 = 3;
7309 dgst_pos1 = 7;
7310 dgst_pos2 = 2;
7311 dgst_pos3 = 6;
7312 break;
7313
7314 case 1430: hash_type = HASH_TYPE_SHA256;
7315 salt_type = SALT_TYPE_INTERN;
7316 attack_exec = ATTACK_EXEC_ON_GPU;
7317 opts_type = OPTS_TYPE_PT_GENERATE_BE
7318 | OPTS_TYPE_PT_UNICODE
7319 | OPTS_TYPE_ST_ADD80
7320 | OPTS_TYPE_ST_ADDBITS15;
7321 kern_type = KERN_TYPE_SHA256_PWUSLT;
7322 dgst_size = DGST_SIZE_4_8;
7323 parse_func = sha256s_parse_hash;
7324 sort_by_digest = sort_by_digest_4_8;
7325 opti_type = OPTI_TYPE_ZERO_BYTE
7326 | OPTI_TYPE_PRECOMPUTE_INIT
7327 | OPTI_TYPE_PRECOMPUTE_MERKLE
7328 | OPTI_TYPE_EARLY_SKIP
7329 | OPTI_TYPE_NOT_ITERATED
7330 | OPTI_TYPE_APPENDED_SALT
7331 | OPTI_TYPE_RAW_HASH;
7332 dgst_pos0 = 3;
7333 dgst_pos1 = 7;
7334 dgst_pos2 = 2;
7335 dgst_pos3 = 6;
7336 break;
7337
7338 case 1440: hash_type = HASH_TYPE_SHA256;
7339 salt_type = SALT_TYPE_INTERN;
7340 attack_exec = ATTACK_EXEC_ON_GPU;
7341 opts_type = OPTS_TYPE_PT_GENERATE_BE
7342 | OPTS_TYPE_PT_ADD80
7343 | OPTS_TYPE_PT_ADDBITS15
7344 | OPTS_TYPE_PT_UNICODE;
7345 kern_type = KERN_TYPE_SHA256_SLTPWU;
7346 dgst_size = DGST_SIZE_4_8;
7347 parse_func = sha256s_parse_hash;
7348 sort_by_digest = sort_by_digest_4_8;
7349 opti_type = OPTI_TYPE_ZERO_BYTE
7350 | OPTI_TYPE_PRECOMPUTE_INIT
7351 | OPTI_TYPE_PRECOMPUTE_MERKLE
7352 | OPTI_TYPE_EARLY_SKIP
7353 | OPTI_TYPE_NOT_ITERATED
7354 | OPTI_TYPE_PREPENDED_SALT
7355 | OPTI_TYPE_RAW_HASH;
7356 dgst_pos0 = 3;
7357 dgst_pos1 = 7;
7358 dgst_pos2 = 2;
7359 dgst_pos3 = 6;
7360 break;
7361
7362 case 1441: hash_type = HASH_TYPE_SHA256;
7363 salt_type = SALT_TYPE_EMBEDDED;
7364 attack_exec = ATTACK_EXEC_ON_GPU;
7365 opts_type = OPTS_TYPE_PT_GENERATE_BE
7366 | OPTS_TYPE_PT_ADD80
7367 | OPTS_TYPE_PT_ADDBITS15
7368 | OPTS_TYPE_PT_UNICODE
7369 | OPTS_TYPE_ST_BASE64;
7370 kern_type = KERN_TYPE_SHA256_SLTPWU;
7371 dgst_size = DGST_SIZE_4_8;
7372 parse_func = episerver4_parse_hash;
7373 sort_by_digest = sort_by_digest_4_8;
7374 opti_type = OPTI_TYPE_ZERO_BYTE
7375 | OPTI_TYPE_PRECOMPUTE_INIT
7376 | OPTI_TYPE_PRECOMPUTE_MERKLE
7377 | OPTI_TYPE_EARLY_SKIP
7378 | OPTI_TYPE_NOT_ITERATED
7379 | OPTI_TYPE_PREPENDED_SALT
7380 | OPTI_TYPE_RAW_HASH;
7381 dgst_pos0 = 3;
7382 dgst_pos1 = 7;
7383 dgst_pos2 = 2;
7384 dgst_pos3 = 6;
7385 break;
7386
7387 case 1450: hash_type = HASH_TYPE_SHA256;
7388 salt_type = SALT_TYPE_INTERN;
7389 attack_exec = ATTACK_EXEC_ON_GPU;
7390 opts_type = OPTS_TYPE_PT_GENERATE_BE
7391 | OPTS_TYPE_ST_ADD80;
7392 kern_type = KERN_TYPE_HMACSHA256_PW;
7393 dgst_size = DGST_SIZE_4_8;
7394 parse_func = hmacsha256_parse_hash;
7395 sort_by_digest = sort_by_digest_4_8;
7396 opti_type = OPTI_TYPE_ZERO_BYTE
7397 | OPTI_TYPE_NOT_ITERATED;
7398 dgst_pos0 = 3;
7399 dgst_pos1 = 7;
7400 dgst_pos2 = 2;
7401 dgst_pos3 = 6;
7402 break;
7403
7404 case 1460: hash_type = HASH_TYPE_SHA256;
7405 salt_type = SALT_TYPE_INTERN;
7406 attack_exec = ATTACK_EXEC_ON_GPU;
7407 opts_type = OPTS_TYPE_PT_GENERATE_BE
7408 | OPTS_TYPE_PT_ADD80
7409 | OPTS_TYPE_PT_ADDBITS15;
7410 kern_type = KERN_TYPE_HMACSHA256_SLT;
7411 dgst_size = DGST_SIZE_4_8;
7412 parse_func = hmacsha256_parse_hash;
7413 sort_by_digest = sort_by_digest_4_8;
7414 opti_type = OPTI_TYPE_ZERO_BYTE
7415 | OPTI_TYPE_NOT_ITERATED;
7416 dgst_pos0 = 3;
7417 dgst_pos1 = 7;
7418 dgst_pos2 = 2;
7419 dgst_pos3 = 6;
7420 break;
7421
7422 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7423 salt_type = SALT_TYPE_EMBEDDED;
7424 attack_exec = ATTACK_EXEC_ON_GPU;
7425 opts_type = OPTS_TYPE_PT_GENERATE_LE
7426 | OPTS_TYPE_PT_BITSLICE;
7427 kern_type = KERN_TYPE_DESCRYPT;
7428 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7429 parse_func = descrypt_parse_hash;
7430 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7431 opti_type = OPTI_TYPE_ZERO_BYTE
7432 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7433 dgst_pos0 = 0;
7434 dgst_pos1 = 1;
7435 dgst_pos2 = 2;
7436 dgst_pos3 = 3;
7437 break;
7438
7439 case 1600: hash_type = HASH_TYPE_MD5;
7440 salt_type = SALT_TYPE_EMBEDDED;
7441 attack_exec = ATTACK_EXEC_ON_CPU;
7442 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7443 kern_type = KERN_TYPE_APR1CRYPT;
7444 dgst_size = DGST_SIZE_4_4;
7445 parse_func = md5apr1_parse_hash;
7446 sort_by_digest = sort_by_digest_4_4;
7447 opti_type = OPTI_TYPE_ZERO_BYTE;
7448 dgst_pos0 = 0;
7449 dgst_pos1 = 1;
7450 dgst_pos2 = 2;
7451 dgst_pos3 = 3;
7452 break;
7453
7454 case 1700: hash_type = HASH_TYPE_SHA512;
7455 salt_type = SALT_TYPE_NONE;
7456 attack_exec = ATTACK_EXEC_ON_GPU;
7457 opts_type = OPTS_TYPE_PT_GENERATE_BE
7458 | OPTS_TYPE_PT_ADD80
7459 | OPTS_TYPE_PT_ADDBITS15;
7460 kern_type = KERN_TYPE_SHA512;
7461 dgst_size = DGST_SIZE_8_8;
7462 parse_func = sha512_parse_hash;
7463 sort_by_digest = sort_by_digest_8_8;
7464 opti_type = OPTI_TYPE_ZERO_BYTE
7465 | OPTI_TYPE_PRECOMPUTE_INIT
7466 | OPTI_TYPE_PRECOMPUTE_MERKLE
7467 | OPTI_TYPE_EARLY_SKIP
7468 | OPTI_TYPE_NOT_ITERATED
7469 | OPTI_TYPE_NOT_SALTED
7470 | OPTI_TYPE_RAW_HASH;
7471 dgst_pos0 = 14;
7472 dgst_pos1 = 15;
7473 dgst_pos2 = 6;
7474 dgst_pos3 = 7;
7475 break;
7476
7477 case 1710: hash_type = HASH_TYPE_SHA512;
7478 salt_type = SALT_TYPE_INTERN;
7479 attack_exec = ATTACK_EXEC_ON_GPU;
7480 opts_type = OPTS_TYPE_PT_GENERATE_BE
7481 | OPTS_TYPE_ST_ADD80
7482 | OPTS_TYPE_ST_ADDBITS15;
7483 kern_type = KERN_TYPE_SHA512_PWSLT;
7484 dgst_size = DGST_SIZE_8_8;
7485 parse_func = sha512s_parse_hash;
7486 sort_by_digest = sort_by_digest_8_8;
7487 opti_type = OPTI_TYPE_ZERO_BYTE
7488 | OPTI_TYPE_PRECOMPUTE_INIT
7489 | OPTI_TYPE_PRECOMPUTE_MERKLE
7490 | OPTI_TYPE_EARLY_SKIP
7491 | OPTI_TYPE_NOT_ITERATED
7492 | OPTI_TYPE_APPENDED_SALT
7493 | OPTI_TYPE_RAW_HASH;
7494 dgst_pos0 = 14;
7495 dgst_pos1 = 15;
7496 dgst_pos2 = 6;
7497 dgst_pos3 = 7;
7498 break;
7499
7500 case 1711: hash_type = HASH_TYPE_SHA512;
7501 salt_type = SALT_TYPE_EMBEDDED;
7502 attack_exec = ATTACK_EXEC_ON_GPU;
7503 opts_type = OPTS_TYPE_PT_GENERATE_BE
7504 | OPTS_TYPE_ST_ADD80
7505 | OPTS_TYPE_ST_ADDBITS15;
7506 kern_type = KERN_TYPE_SHA512_PWSLT;
7507 dgst_size = DGST_SIZE_8_8;
7508 parse_func = sha512b64s_parse_hash;
7509 sort_by_digest = sort_by_digest_8_8;
7510 opti_type = OPTI_TYPE_ZERO_BYTE
7511 | OPTI_TYPE_PRECOMPUTE_INIT
7512 | OPTI_TYPE_PRECOMPUTE_MERKLE
7513 | OPTI_TYPE_EARLY_SKIP
7514 | OPTI_TYPE_NOT_ITERATED
7515 | OPTI_TYPE_APPENDED_SALT
7516 | OPTI_TYPE_RAW_HASH;
7517 dgst_pos0 = 14;
7518 dgst_pos1 = 15;
7519 dgst_pos2 = 6;
7520 dgst_pos3 = 7;
7521 break;
7522
7523 case 1720: hash_type = HASH_TYPE_SHA512;
7524 salt_type = SALT_TYPE_INTERN;
7525 attack_exec = ATTACK_EXEC_ON_GPU;
7526 opts_type = OPTS_TYPE_PT_GENERATE_BE
7527 | OPTS_TYPE_PT_ADD80
7528 | OPTS_TYPE_PT_ADDBITS15;
7529 kern_type = KERN_TYPE_SHA512_SLTPW;
7530 dgst_size = DGST_SIZE_8_8;
7531 parse_func = sha512s_parse_hash;
7532 sort_by_digest = sort_by_digest_8_8;
7533 opti_type = OPTI_TYPE_ZERO_BYTE
7534 | OPTI_TYPE_PRECOMPUTE_INIT
7535 | OPTI_TYPE_PRECOMPUTE_MERKLE
7536 | OPTI_TYPE_EARLY_SKIP
7537 | OPTI_TYPE_NOT_ITERATED
7538 | OPTI_TYPE_PREPENDED_SALT
7539 | OPTI_TYPE_RAW_HASH;
7540 dgst_pos0 = 14;
7541 dgst_pos1 = 15;
7542 dgst_pos2 = 6;
7543 dgst_pos3 = 7;
7544 break;
7545
7546 case 1722: hash_type = HASH_TYPE_SHA512;
7547 salt_type = SALT_TYPE_EMBEDDED;
7548 attack_exec = ATTACK_EXEC_ON_GPU;
7549 opts_type = OPTS_TYPE_PT_GENERATE_BE
7550 | OPTS_TYPE_PT_ADD80
7551 | OPTS_TYPE_PT_ADDBITS15
7552 | OPTS_TYPE_ST_HEX;
7553 kern_type = KERN_TYPE_SHA512_SLTPW;
7554 dgst_size = DGST_SIZE_8_8;
7555 parse_func = osx512_parse_hash;
7556 sort_by_digest = sort_by_digest_8_8;
7557 opti_type = OPTI_TYPE_ZERO_BYTE
7558 | OPTI_TYPE_PRECOMPUTE_INIT
7559 | OPTI_TYPE_PRECOMPUTE_MERKLE
7560 | OPTI_TYPE_EARLY_SKIP
7561 | OPTI_TYPE_NOT_ITERATED
7562 | OPTI_TYPE_PREPENDED_SALT
7563 | OPTI_TYPE_RAW_HASH;
7564 dgst_pos0 = 14;
7565 dgst_pos1 = 15;
7566 dgst_pos2 = 6;
7567 dgst_pos3 = 7;
7568 break;
7569
7570 case 1730: hash_type = HASH_TYPE_SHA512;
7571 salt_type = SALT_TYPE_INTERN;
7572 attack_exec = ATTACK_EXEC_ON_GPU;
7573 opts_type = OPTS_TYPE_PT_GENERATE_BE
7574 | OPTS_TYPE_PT_UNICODE
7575 | OPTS_TYPE_ST_ADD80
7576 | OPTS_TYPE_ST_ADDBITS15;
7577 kern_type = KERN_TYPE_SHA512_PWSLTU;
7578 dgst_size = DGST_SIZE_8_8;
7579 parse_func = sha512s_parse_hash;
7580 sort_by_digest = sort_by_digest_8_8;
7581 opti_type = OPTI_TYPE_ZERO_BYTE
7582 | OPTI_TYPE_PRECOMPUTE_INIT
7583 | OPTI_TYPE_PRECOMPUTE_MERKLE
7584 | OPTI_TYPE_EARLY_SKIP
7585 | OPTI_TYPE_NOT_ITERATED
7586 | OPTI_TYPE_APPENDED_SALT
7587 | OPTI_TYPE_RAW_HASH;
7588 dgst_pos0 = 14;
7589 dgst_pos1 = 15;
7590 dgst_pos2 = 6;
7591 dgst_pos3 = 7;
7592 break;
7593
7594 case 1731: hash_type = HASH_TYPE_SHA512;
7595 salt_type = SALT_TYPE_EMBEDDED;
7596 attack_exec = ATTACK_EXEC_ON_GPU;
7597 opts_type = OPTS_TYPE_PT_GENERATE_BE
7598 | OPTS_TYPE_PT_UNICODE
7599 | OPTS_TYPE_ST_ADD80
7600 | OPTS_TYPE_ST_ADDBITS15
7601 | OPTS_TYPE_ST_HEX;
7602 kern_type = KERN_TYPE_SHA512_PWSLTU;
7603 dgst_size = DGST_SIZE_8_8;
7604 parse_func = mssql2012_parse_hash;
7605 sort_by_digest = sort_by_digest_8_8;
7606 opti_type = OPTI_TYPE_ZERO_BYTE
7607 | OPTI_TYPE_PRECOMPUTE_INIT
7608 | OPTI_TYPE_PRECOMPUTE_MERKLE
7609 | OPTI_TYPE_EARLY_SKIP
7610 | OPTI_TYPE_NOT_ITERATED
7611 | OPTI_TYPE_APPENDED_SALT
7612 | OPTI_TYPE_RAW_HASH;
7613 dgst_pos0 = 14;
7614 dgst_pos1 = 15;
7615 dgst_pos2 = 6;
7616 dgst_pos3 = 7;
7617 break;
7618
7619 case 1740: hash_type = HASH_TYPE_SHA512;
7620 salt_type = SALT_TYPE_INTERN;
7621 attack_exec = ATTACK_EXEC_ON_GPU;
7622 opts_type = OPTS_TYPE_PT_GENERATE_BE
7623 | OPTS_TYPE_PT_ADD80
7624 | OPTS_TYPE_PT_ADDBITS15
7625 | OPTS_TYPE_PT_UNICODE;
7626 kern_type = KERN_TYPE_SHA512_SLTPWU;
7627 dgst_size = DGST_SIZE_8_8;
7628 parse_func = sha512s_parse_hash;
7629 sort_by_digest = sort_by_digest_8_8;
7630 opti_type = OPTI_TYPE_ZERO_BYTE
7631 | OPTI_TYPE_PRECOMPUTE_INIT
7632 | OPTI_TYPE_PRECOMPUTE_MERKLE
7633 | OPTI_TYPE_EARLY_SKIP
7634 | OPTI_TYPE_NOT_ITERATED
7635 | OPTI_TYPE_PREPENDED_SALT
7636 | OPTI_TYPE_RAW_HASH;
7637 dgst_pos0 = 14;
7638 dgst_pos1 = 15;
7639 dgst_pos2 = 6;
7640 dgst_pos3 = 7;
7641 break;
7642
7643 case 1750: hash_type = HASH_TYPE_SHA512;
7644 salt_type = SALT_TYPE_INTERN;
7645 attack_exec = ATTACK_EXEC_ON_GPU;
7646 opts_type = OPTS_TYPE_PT_GENERATE_BE
7647 | OPTS_TYPE_ST_ADD80;
7648 kern_type = KERN_TYPE_HMACSHA512_PW;
7649 dgst_size = DGST_SIZE_8_8;
7650 parse_func = hmacsha512_parse_hash;
7651 sort_by_digest = sort_by_digest_8_8;
7652 opti_type = OPTI_TYPE_ZERO_BYTE
7653 | OPTI_TYPE_NOT_ITERATED;
7654 dgst_pos0 = 14;
7655 dgst_pos1 = 15;
7656 dgst_pos2 = 6;
7657 dgst_pos3 = 7;
7658 break;
7659
7660 case 1760: hash_type = HASH_TYPE_SHA512;
7661 salt_type = SALT_TYPE_INTERN;
7662 attack_exec = ATTACK_EXEC_ON_GPU;
7663 opts_type = OPTS_TYPE_PT_GENERATE_BE
7664 | OPTS_TYPE_PT_ADD80
7665 | OPTS_TYPE_PT_ADDBITS15;
7666 kern_type = KERN_TYPE_HMACSHA512_SLT;
7667 dgst_size = DGST_SIZE_8_8;
7668 parse_func = hmacsha512_parse_hash;
7669 sort_by_digest = sort_by_digest_8_8;
7670 opti_type = OPTI_TYPE_ZERO_BYTE
7671 | OPTI_TYPE_NOT_ITERATED;
7672 dgst_pos0 = 14;
7673 dgst_pos1 = 15;
7674 dgst_pos2 = 6;
7675 dgst_pos3 = 7;
7676 break;
7677
7678 case 1800: hash_type = HASH_TYPE_SHA512;
7679 salt_type = SALT_TYPE_EMBEDDED;
7680 attack_exec = ATTACK_EXEC_ON_CPU;
7681 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7682 kern_type = KERN_TYPE_SHA512CRYPT;
7683 dgst_size = DGST_SIZE_8_8;
7684 parse_func = sha512crypt_parse_hash;
7685 sort_by_digest = sort_by_digest_8_8;
7686 opti_type = OPTI_TYPE_ZERO_BYTE;
7687 dgst_pos0 = 0;
7688 dgst_pos1 = 1;
7689 dgst_pos2 = 2;
7690 dgst_pos3 = 3;
7691 break;
7692
7693 case 2100: hash_type = HASH_TYPE_DCC2;
7694 salt_type = SALT_TYPE_EMBEDDED;
7695 attack_exec = ATTACK_EXEC_ON_CPU;
7696 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
7697 | OPTS_TYPE_ST_LOWER
7698 | OPTS_TYPE_ST_UNICODE;
7699 kern_type = KERN_TYPE_DCC2;
7700 dgst_size = DGST_SIZE_4_4;
7701 parse_func = dcc2_parse_hash;
7702 sort_by_digest = sort_by_digest_4_4;
7703 opti_type = OPTI_TYPE_ZERO_BYTE;
7704 dgst_pos0 = 0;
7705 dgst_pos1 = 1;
7706 dgst_pos2 = 2;
7707 dgst_pos3 = 3;
7708 break;
7709
7710 case 2400: hash_type = HASH_TYPE_MD5;
7711 salt_type = SALT_TYPE_NONE;
7712 attack_exec = ATTACK_EXEC_ON_GPU;
7713 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7714 kern_type = KERN_TYPE_MD5PIX;
7715 dgst_size = DGST_SIZE_4_4;
7716 parse_func = md5pix_parse_hash;
7717 sort_by_digest = sort_by_digest_4_4;
7718 opti_type = OPTI_TYPE_ZERO_BYTE
7719 | OPTI_TYPE_PRECOMPUTE_INIT
7720 | OPTI_TYPE_PRECOMPUTE_MERKLE
7721 | OPTI_TYPE_EARLY_SKIP
7722 | OPTI_TYPE_NOT_ITERATED
7723 | OPTI_TYPE_NOT_SALTED;
7724 dgst_pos0 = 0;
7725 dgst_pos1 = 3;
7726 dgst_pos2 = 2;
7727 dgst_pos3 = 1;
7728 break;
7729
7730 case 2410: hash_type = HASH_TYPE_MD5;
7731 salt_type = SALT_TYPE_INTERN;
7732 attack_exec = ATTACK_EXEC_ON_GPU;
7733 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7734 kern_type = KERN_TYPE_MD5ASA;
7735 dgst_size = DGST_SIZE_4_4;
7736 parse_func = md5asa_parse_hash;
7737 sort_by_digest = sort_by_digest_4_4;
7738 opti_type = OPTI_TYPE_ZERO_BYTE
7739 | OPTI_TYPE_PRECOMPUTE_INIT
7740 | OPTI_TYPE_PRECOMPUTE_MERKLE
7741 | OPTI_TYPE_EARLY_SKIP
7742 | OPTI_TYPE_NOT_ITERATED;
7743 dgst_pos0 = 0;
7744 dgst_pos1 = 3;
7745 dgst_pos2 = 2;
7746 dgst_pos3 = 1;
7747 break;
7748
7749 case 2500: hash_type = HASH_TYPE_WPA;
7750 salt_type = SALT_TYPE_EMBEDDED;
7751 attack_exec = ATTACK_EXEC_ON_CPU;
7752 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7753 kern_type = KERN_TYPE_WPA;
7754 dgst_size = DGST_SIZE_4_4;
7755 parse_func = wpa_parse_hash;
7756 sort_by_digest = sort_by_digest_4_4;
7757 opti_type = OPTI_TYPE_ZERO_BYTE;
7758 dgst_pos0 = 0;
7759 dgst_pos1 = 1;
7760 dgst_pos2 = 2;
7761 dgst_pos3 = 3;
7762 break;
7763
7764 case 2600: hash_type = HASH_TYPE_MD5;
7765 salt_type = SALT_TYPE_VIRTUAL;
7766 attack_exec = ATTACK_EXEC_ON_GPU;
7767 opts_type = OPTS_TYPE_PT_GENERATE_LE
7768 | OPTS_TYPE_PT_ADD80
7769 | OPTS_TYPE_PT_ADDBITS14
7770 | OPTS_TYPE_ST_ADD80;
7771 kern_type = KERN_TYPE_MD55_PWSLT1;
7772 dgst_size = DGST_SIZE_4_4;
7773 parse_func = md5md5_parse_hash;
7774 sort_by_digest = sort_by_digest_4_4;
7775 opti_type = OPTI_TYPE_ZERO_BYTE
7776 | OPTI_TYPE_PRECOMPUTE_INIT
7777 | OPTI_TYPE_PRECOMPUTE_MERKLE
7778 | OPTI_TYPE_EARLY_SKIP;
7779 dgst_pos0 = 0;
7780 dgst_pos1 = 3;
7781 dgst_pos2 = 2;
7782 dgst_pos3 = 1;
7783 break;
7784
7785 case 2611: hash_type = HASH_TYPE_MD5;
7786 salt_type = SALT_TYPE_INTERN;
7787 attack_exec = ATTACK_EXEC_ON_GPU;
7788 opts_type = OPTS_TYPE_PT_GENERATE_LE
7789 | OPTS_TYPE_PT_ADD80
7790 | OPTS_TYPE_PT_ADDBITS14
7791 | OPTS_TYPE_ST_ADD80;
7792 kern_type = KERN_TYPE_MD55_PWSLT1;
7793 dgst_size = DGST_SIZE_4_4;
7794 parse_func = vb3_parse_hash;
7795 sort_by_digest = sort_by_digest_4_4;
7796 opti_type = OPTI_TYPE_ZERO_BYTE
7797 | OPTI_TYPE_PRECOMPUTE_INIT
7798 | OPTI_TYPE_PRECOMPUTE_MERKLE
7799 | OPTI_TYPE_EARLY_SKIP;
7800 dgst_pos0 = 0;
7801 dgst_pos1 = 3;
7802 dgst_pos2 = 2;
7803 dgst_pos3 = 1;
7804 break;
7805
7806 case 2612: hash_type = HASH_TYPE_MD5;
7807 salt_type = SALT_TYPE_EMBEDDED;
7808 attack_exec = ATTACK_EXEC_ON_GPU;
7809 opts_type = OPTS_TYPE_PT_GENERATE_LE
7810 | OPTS_TYPE_PT_ADD80
7811 | OPTS_TYPE_PT_ADDBITS14
7812 | OPTS_TYPE_ST_ADD80
7813 | OPTS_TYPE_ST_HEX;
7814 kern_type = KERN_TYPE_MD55_PWSLT1;
7815 dgst_size = DGST_SIZE_4_4;
7816 parse_func = phps_parse_hash;
7817 sort_by_digest = sort_by_digest_4_4;
7818 opti_type = OPTI_TYPE_ZERO_BYTE
7819 | OPTI_TYPE_PRECOMPUTE_INIT
7820 | OPTI_TYPE_PRECOMPUTE_MERKLE
7821 | OPTI_TYPE_EARLY_SKIP;
7822 dgst_pos0 = 0;
7823 dgst_pos1 = 3;
7824 dgst_pos2 = 2;
7825 dgst_pos3 = 1;
7826 break;
7827
7828 case 2711: hash_type = HASH_TYPE_MD5;
7829 salt_type = SALT_TYPE_INTERN;
7830 attack_exec = ATTACK_EXEC_ON_GPU;
7831 opts_type = OPTS_TYPE_PT_GENERATE_LE
7832 | OPTS_TYPE_PT_ADD80
7833 | OPTS_TYPE_PT_ADDBITS14
7834 | OPTS_TYPE_ST_ADD80;
7835 kern_type = KERN_TYPE_MD55_PWSLT2;
7836 dgst_size = DGST_SIZE_4_4;
7837 parse_func = vb30_parse_hash;
7838 sort_by_digest = sort_by_digest_4_4;
7839 opti_type = OPTI_TYPE_ZERO_BYTE
7840 | OPTI_TYPE_PRECOMPUTE_INIT
7841 | OPTI_TYPE_EARLY_SKIP;
7842 dgst_pos0 = 0;
7843 dgst_pos1 = 3;
7844 dgst_pos2 = 2;
7845 dgst_pos3 = 1;
7846 break;
7847
7848 case 2811: hash_type = HASH_TYPE_MD5;
7849 salt_type = SALT_TYPE_INTERN;
7850 attack_exec = ATTACK_EXEC_ON_GPU;
7851 opts_type = OPTS_TYPE_PT_GENERATE_LE
7852 | OPTS_TYPE_PT_ADD80
7853 | OPTS_TYPE_PT_ADDBITS14;
7854 kern_type = KERN_TYPE_MD55_SLTPW;
7855 dgst_size = DGST_SIZE_4_4;
7856 parse_func = ipb2_parse_hash;
7857 sort_by_digest = sort_by_digest_4_4;
7858 opti_type = OPTI_TYPE_ZERO_BYTE
7859 | OPTI_TYPE_PRECOMPUTE_INIT
7860 | OPTI_TYPE_EARLY_SKIP;
7861 dgst_pos0 = 0;
7862 dgst_pos1 = 3;
7863 dgst_pos2 = 2;
7864 dgst_pos3 = 1;
7865 break;
7866
7867 case 3000: hash_type = HASH_TYPE_LM;
7868 salt_type = SALT_TYPE_NONE;
7869 attack_exec = ATTACK_EXEC_ON_GPU;
7870 opts_type = OPTS_TYPE_PT_GENERATE_LE
7871 | OPTS_TYPE_PT_UPPER
7872 | OPTS_TYPE_PT_BITSLICE;
7873 kern_type = KERN_TYPE_LM;
7874 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7875 parse_func = lm_parse_hash;
7876 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7877 opti_type = OPTI_TYPE_ZERO_BYTE
7878 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7879 dgst_pos0 = 0;
7880 dgst_pos1 = 1;
7881 dgst_pos2 = 2;
7882 dgst_pos3 = 3;
7883 break;
7884
7885 case 3100: hash_type = HASH_TYPE_ORACLEH;
7886 salt_type = SALT_TYPE_INTERN;
7887 attack_exec = ATTACK_EXEC_ON_GPU;
7888 opts_type = OPTS_TYPE_PT_GENERATE_LE
7889 | OPTS_TYPE_PT_UPPER
7890 | OPTS_TYPE_ST_UPPER;
7891 kern_type = KERN_TYPE_ORACLEH;
7892 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7893 parse_func = oracleh_parse_hash;
7894 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7895 opti_type = OPTI_TYPE_ZERO_BYTE;
7896 dgst_pos0 = 0;
7897 dgst_pos1 = 1;
7898 dgst_pos2 = 2;
7899 dgst_pos3 = 3;
7900 break;
7901
7902 case 3200: hash_type = HASH_TYPE_BCRYPT;
7903 salt_type = SALT_TYPE_EMBEDDED;
7904 attack_exec = ATTACK_EXEC_ON_CPU;
7905 opts_type = OPTS_TYPE_PT_GENERATE_LE
7906 | OPTS_TYPE_ST_GENERATE_LE;
7907 kern_type = KERN_TYPE_BCRYPT;
7908 dgst_size = DGST_SIZE_4_6;
7909 parse_func = bcrypt_parse_hash;
7910 sort_by_digest = sort_by_digest_4_6;
7911 opti_type = OPTI_TYPE_ZERO_BYTE;
7912 dgst_pos0 = 0;
7913 dgst_pos1 = 1;
7914 dgst_pos2 = 2;
7915 dgst_pos3 = 3;
7916 break;
7917
7918 case 3710: hash_type = HASH_TYPE_MD5;
7919 salt_type = SALT_TYPE_INTERN;
7920 attack_exec = ATTACK_EXEC_ON_GPU;
7921 opts_type = OPTS_TYPE_PT_GENERATE_LE
7922 | OPTS_TYPE_PT_ADD80
7923 | OPTS_TYPE_PT_ADDBITS14;
7924 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
7925 dgst_size = DGST_SIZE_4_4;
7926 parse_func = md5s_parse_hash;
7927 sort_by_digest = sort_by_digest_4_4;
7928 opti_type = OPTI_TYPE_ZERO_BYTE
7929 | OPTI_TYPE_PRECOMPUTE_INIT
7930 | OPTI_TYPE_PRECOMPUTE_MERKLE
7931 | OPTI_TYPE_EARLY_SKIP;
7932 dgst_pos0 = 0;
7933 dgst_pos1 = 3;
7934 dgst_pos2 = 2;
7935 dgst_pos3 = 1;
7936 break;
7937
7938 case 3711: hash_type = HASH_TYPE_MD5;
7939 salt_type = SALT_TYPE_EMBEDDED;
7940 attack_exec = ATTACK_EXEC_ON_GPU;
7941 opts_type = OPTS_TYPE_PT_GENERATE_LE
7942 | OPTS_TYPE_PT_ADD80
7943 | OPTS_TYPE_PT_ADDBITS14;
7944 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
7945 dgst_size = DGST_SIZE_4_4;
7946 parse_func = mediawiki_b_parse_hash;
7947 sort_by_digest = sort_by_digest_4_4;
7948 opti_type = OPTI_TYPE_ZERO_BYTE
7949 | OPTI_TYPE_PRECOMPUTE_INIT
7950 | OPTI_TYPE_PRECOMPUTE_MERKLE
7951 | OPTI_TYPE_EARLY_SKIP;
7952 dgst_pos0 = 0;
7953 dgst_pos1 = 3;
7954 dgst_pos2 = 2;
7955 dgst_pos3 = 1;
7956 break;
7957
7958 case 3800: hash_type = HASH_TYPE_MD5;
7959 salt_type = SALT_TYPE_INTERN;
7960 attack_exec = ATTACK_EXEC_ON_GPU;
7961 opts_type = OPTS_TYPE_PT_GENERATE_LE
7962 | OPTS_TYPE_ST_ADDBITS14;
7963 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
7964 dgst_size = DGST_SIZE_4_4;
7965 parse_func = md5s_parse_hash;
7966 sort_by_digest = sort_by_digest_4_4;
7967 opti_type = OPTI_TYPE_ZERO_BYTE
7968 | OPTI_TYPE_PRECOMPUTE_INIT
7969 | OPTI_TYPE_PRECOMPUTE_MERKLE
7970 | OPTI_TYPE_EARLY_SKIP
7971 | OPTI_TYPE_NOT_ITERATED
7972 | OPTI_TYPE_RAW_HASH;
7973 dgst_pos0 = 0;
7974 dgst_pos1 = 3;
7975 dgst_pos2 = 2;
7976 dgst_pos3 = 1;
7977 break;
7978
7979 case 4300: hash_type = HASH_TYPE_MD5;
7980 salt_type = SALT_TYPE_VIRTUAL;
7981 attack_exec = ATTACK_EXEC_ON_GPU;
7982 opts_type = OPTS_TYPE_PT_GENERATE_LE
7983 | OPTS_TYPE_PT_ADD80
7984 | OPTS_TYPE_PT_ADDBITS14
7985 | OPTS_TYPE_ST_ADD80;
7986 kern_type = KERN_TYPE_MD5U5_PWSLT1;
7987 dgst_size = DGST_SIZE_4_4;
7988 parse_func = md5md5_parse_hash;
7989 sort_by_digest = sort_by_digest_4_4;
7990 opti_type = OPTI_TYPE_ZERO_BYTE
7991 | OPTI_TYPE_PRECOMPUTE_INIT
7992 | OPTI_TYPE_PRECOMPUTE_MERKLE
7993 | OPTI_TYPE_EARLY_SKIP;
7994 dgst_pos0 = 0;
7995 dgst_pos1 = 3;
7996 dgst_pos2 = 2;
7997 dgst_pos3 = 1;
7998 break;
7999
8000
8001 case 4400: hash_type = HASH_TYPE_MD5;
8002 salt_type = SALT_TYPE_NONE;
8003 attack_exec = ATTACK_EXEC_ON_GPU;
8004 opts_type = OPTS_TYPE_PT_GENERATE_BE
8005 | OPTS_TYPE_PT_ADD80
8006 | OPTS_TYPE_PT_ADDBITS15;
8007 kern_type = KERN_TYPE_MD5_SHA1;
8008 dgst_size = DGST_SIZE_4_4;
8009 parse_func = md5_parse_hash;
8010 sort_by_digest = sort_by_digest_4_4;
8011 opti_type = OPTI_TYPE_ZERO_BYTE
8012 | OPTI_TYPE_PRECOMPUTE_INIT
8013 | OPTI_TYPE_PRECOMPUTE_MERKLE
8014 | OPTI_TYPE_EARLY_SKIP
8015 | OPTI_TYPE_NOT_ITERATED
8016 | OPTI_TYPE_NOT_SALTED
8017 | OPTI_TYPE_RAW_HASH;
8018 dgst_pos0 = 0;
8019 dgst_pos1 = 3;
8020 dgst_pos2 = 2;
8021 dgst_pos3 = 1;
8022 break;
8023
8024 case 4500: hash_type = HASH_TYPE_SHA1;
8025 salt_type = SALT_TYPE_NONE;
8026 attack_exec = ATTACK_EXEC_ON_GPU;
8027 opts_type = OPTS_TYPE_PT_GENERATE_BE
8028 | OPTS_TYPE_PT_ADD80
8029 | OPTS_TYPE_PT_ADDBITS15;
8030 kern_type = KERN_TYPE_SHA11;
8031 dgst_size = DGST_SIZE_4_5;
8032 parse_func = sha1_parse_hash;
8033 sort_by_digest = sort_by_digest_4_5;
8034 opti_type = OPTI_TYPE_ZERO_BYTE
8035 | OPTI_TYPE_PRECOMPUTE_INIT
8036 | OPTI_TYPE_PRECOMPUTE_MERKLE
8037 | OPTI_TYPE_EARLY_SKIP
8038 | OPTI_TYPE_NOT_SALTED;
8039 dgst_pos0 = 3;
8040 dgst_pos1 = 4;
8041 dgst_pos2 = 2;
8042 dgst_pos3 = 1;
8043 break;
8044
8045 case 4700: hash_type = HASH_TYPE_SHA1;
8046 salt_type = SALT_TYPE_NONE;
8047 attack_exec = ATTACK_EXEC_ON_GPU;
8048 opts_type = OPTS_TYPE_PT_GENERATE_LE
8049 | OPTS_TYPE_PT_ADD80
8050 | OPTS_TYPE_PT_ADDBITS14;
8051 kern_type = KERN_TYPE_SHA1_MD5;
8052 dgst_size = DGST_SIZE_4_5;
8053 parse_func = sha1_parse_hash;
8054 sort_by_digest = sort_by_digest_4_5;
8055 opti_type = OPTI_TYPE_ZERO_BYTE
8056 | OPTI_TYPE_PRECOMPUTE_INIT
8057 | OPTI_TYPE_PRECOMPUTE_MERKLE
8058 | OPTI_TYPE_EARLY_SKIP
8059 | OPTI_TYPE_NOT_ITERATED
8060 | OPTI_TYPE_NOT_SALTED
8061 | OPTI_TYPE_RAW_HASH;
8062 dgst_pos0 = 3;
8063 dgst_pos1 = 4;
8064 dgst_pos2 = 2;
8065 dgst_pos3 = 1;
8066 break;
8067
8068 case 4800: hash_type = HASH_TYPE_MD5;
8069 salt_type = SALT_TYPE_EMBEDDED;
8070 attack_exec = ATTACK_EXEC_ON_GPU;
8071 opts_type = OPTS_TYPE_PT_GENERATE_LE
8072 | OPTS_TYPE_PT_ADDBITS14;
8073 kern_type = KERN_TYPE_MD5_CHAP;
8074 dgst_size = DGST_SIZE_4_4;
8075 parse_func = chap_parse_hash;
8076 sort_by_digest = sort_by_digest_4_4;
8077 opti_type = OPTI_TYPE_ZERO_BYTE
8078 | OPTI_TYPE_PRECOMPUTE_INIT
8079 | OPTI_TYPE_PRECOMPUTE_MERKLE
8080 | OPTI_TYPE_MEET_IN_MIDDLE
8081 | OPTI_TYPE_EARLY_SKIP
8082 | OPTI_TYPE_NOT_ITERATED
8083 | OPTI_TYPE_RAW_HASH;
8084 dgst_pos0 = 0;
8085 dgst_pos1 = 3;
8086 dgst_pos2 = 2;
8087 dgst_pos3 = 1;
8088 break;
8089
8090 case 4900: hash_type = HASH_TYPE_SHA1;
8091 salt_type = SALT_TYPE_INTERN;
8092 attack_exec = ATTACK_EXEC_ON_GPU;
8093 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8094 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8095 dgst_size = DGST_SIZE_4_5;
8096 parse_func = sha1s_parse_hash;
8097 sort_by_digest = sort_by_digest_4_5;
8098 opti_type = OPTI_TYPE_ZERO_BYTE
8099 | OPTI_TYPE_PRECOMPUTE_INIT
8100 | OPTI_TYPE_PRECOMPUTE_MERKLE
8101 | OPTI_TYPE_EARLY_SKIP;
8102 dgst_pos0 = 3;
8103 dgst_pos1 = 4;
8104 dgst_pos2 = 2;
8105 dgst_pos3 = 1;
8106 break;
8107
8108 case 5000: hash_type = HASH_TYPE_KECCAK;
8109 salt_type = SALT_TYPE_EMBEDDED;
8110 attack_exec = ATTACK_EXEC_ON_GPU;
8111 opts_type = OPTS_TYPE_PT_GENERATE_LE
8112 | OPTS_TYPE_PT_ADD01;
8113 kern_type = KERN_TYPE_KECCAK;
8114 dgst_size = DGST_SIZE_8_25;
8115 parse_func = keccak_parse_hash;
8116 sort_by_digest = sort_by_digest_8_25;
8117 opti_type = OPTI_TYPE_ZERO_BYTE
8118 | OPTI_TYPE_RAW_HASH;
8119 dgst_pos0 = 2;
8120 dgst_pos1 = 3;
8121 dgst_pos2 = 4;
8122 dgst_pos3 = 5;
8123 break;
8124
8125 case 5100: hash_type = HASH_TYPE_MD5H;
8126 salt_type = SALT_TYPE_NONE;
8127 attack_exec = ATTACK_EXEC_ON_GPU;
8128 opts_type = OPTS_TYPE_PT_GENERATE_LE
8129 | OPTS_TYPE_PT_ADD80
8130 | OPTS_TYPE_PT_ADDBITS14;
8131 kern_type = KERN_TYPE_MD5H;
8132 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8133 parse_func = md5half_parse_hash;
8134 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8135 opti_type = OPTI_TYPE_ZERO_BYTE
8136 | OPTI_TYPE_RAW_HASH;
8137 dgst_pos0 = 0;
8138 dgst_pos1 = 1;
8139 dgst_pos2 = 2;
8140 dgst_pos3 = 3;
8141 break;
8142
8143 case 5200: hash_type = HASH_TYPE_SHA256;
8144 salt_type = SALT_TYPE_EMBEDDED;
8145 attack_exec = ATTACK_EXEC_ON_CPU;
8146 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8147 kern_type = KERN_TYPE_PSAFE3;
8148 dgst_size = DGST_SIZE_4_8;
8149 parse_func = psafe3_parse_hash;
8150 sort_by_digest = sort_by_digest_4_8;
8151 opti_type = OPTI_TYPE_ZERO_BYTE;
8152 dgst_pos0 = 0;
8153 dgst_pos1 = 1;
8154 dgst_pos2 = 2;
8155 dgst_pos3 = 3;
8156 break;
8157
8158 case 5300: hash_type = HASH_TYPE_MD5;
8159 salt_type = SALT_TYPE_EMBEDDED;
8160 attack_exec = ATTACK_EXEC_ON_GPU;
8161 opts_type = OPTS_TYPE_PT_GENERATE_LE
8162 | OPTS_TYPE_ST_ADD80;
8163 kern_type = KERN_TYPE_IKEPSK_MD5;
8164 dgst_size = DGST_SIZE_4_4;
8165 parse_func = ikepsk_md5_parse_hash;
8166 sort_by_digest = sort_by_digest_4_4;
8167 opti_type = OPTI_TYPE_ZERO_BYTE;
8168 dgst_pos0 = 0;
8169 dgst_pos1 = 3;
8170 dgst_pos2 = 2;
8171 dgst_pos3 = 1;
8172 break;
8173
8174 case 5400: hash_type = HASH_TYPE_SHA1;
8175 salt_type = SALT_TYPE_EMBEDDED;
8176 attack_exec = ATTACK_EXEC_ON_GPU;
8177 opts_type = OPTS_TYPE_PT_GENERATE_BE
8178 | OPTS_TYPE_ST_ADD80;
8179 kern_type = KERN_TYPE_IKEPSK_SHA1;
8180 dgst_size = DGST_SIZE_4_5;
8181 parse_func = ikepsk_sha1_parse_hash;
8182 sort_by_digest = sort_by_digest_4_5;
8183 opti_type = OPTI_TYPE_ZERO_BYTE;
8184 dgst_pos0 = 3;
8185 dgst_pos1 = 4;
8186 dgst_pos2 = 2;
8187 dgst_pos3 = 1;
8188 break;
8189
8190 case 5500: hash_type = HASH_TYPE_NETNTLM;
8191 salt_type = SALT_TYPE_EMBEDDED;
8192 attack_exec = ATTACK_EXEC_ON_GPU;
8193 opts_type = OPTS_TYPE_PT_GENERATE_LE
8194 | OPTS_TYPE_PT_ADD80
8195 | OPTS_TYPE_PT_ADDBITS14
8196 | OPTS_TYPE_PT_UNICODE
8197 | OPTS_TYPE_ST_HEX;
8198 kern_type = KERN_TYPE_NETNTLMv1;
8199 dgst_size = DGST_SIZE_4_4;
8200 parse_func = netntlmv1_parse_hash;
8201 sort_by_digest = sort_by_digest_4_4;
8202 opti_type = OPTI_TYPE_ZERO_BYTE
8203 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8204 dgst_pos0 = 0;
8205 dgst_pos1 = 1;
8206 dgst_pos2 = 2;
8207 dgst_pos3 = 3;
8208 break;
8209
8210 case 5600: hash_type = HASH_TYPE_MD5;
8211 salt_type = SALT_TYPE_EMBEDDED;
8212 attack_exec = ATTACK_EXEC_ON_GPU;
8213 opts_type = OPTS_TYPE_PT_GENERATE_LE
8214 | OPTS_TYPE_PT_ADD80
8215 | OPTS_TYPE_PT_ADDBITS14
8216 | OPTS_TYPE_PT_UNICODE;
8217 kern_type = KERN_TYPE_NETNTLMv2;
8218 dgst_size = DGST_SIZE_4_4;
8219 parse_func = netntlmv2_parse_hash;
8220 sort_by_digest = sort_by_digest_4_4;
8221 opti_type = OPTI_TYPE_ZERO_BYTE;
8222 dgst_pos0 = 0;
8223 dgst_pos1 = 3;
8224 dgst_pos2 = 2;
8225 dgst_pos3 = 1;
8226 break;
8227
8228 case 5700: hash_type = HASH_TYPE_SHA256;
8229 salt_type = SALT_TYPE_NONE;
8230 attack_exec = ATTACK_EXEC_ON_GPU;
8231 opts_type = OPTS_TYPE_PT_GENERATE_BE
8232 | OPTS_TYPE_PT_ADD80
8233 | OPTS_TYPE_PT_ADDBITS15;
8234 kern_type = KERN_TYPE_SHA256;
8235 dgst_size = DGST_SIZE_4_8;
8236 parse_func = cisco4_parse_hash;
8237 sort_by_digest = sort_by_digest_4_8;
8238 opti_type = OPTI_TYPE_ZERO_BYTE
8239 | OPTI_TYPE_PRECOMPUTE_INIT
8240 | OPTI_TYPE_PRECOMPUTE_MERKLE
8241 | OPTI_TYPE_EARLY_SKIP
8242 | OPTI_TYPE_NOT_ITERATED
8243 | OPTI_TYPE_NOT_SALTED
8244 | OPTI_TYPE_RAW_HASH;
8245 dgst_pos0 = 3;
8246 dgst_pos1 = 7;
8247 dgst_pos2 = 2;
8248 dgst_pos3 = 6;
8249 break;
8250
8251 case 5800: hash_type = HASH_TYPE_SHA1;
8252 salt_type = SALT_TYPE_INTERN;
8253 attack_exec = ATTACK_EXEC_ON_CPU;
8254 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8255 | OPTS_TYPE_ST_ADD80;
8256 kern_type = KERN_TYPE_ANDROIDPIN;
8257 dgst_size = DGST_SIZE_4_5;
8258 parse_func = androidpin_parse_hash;
8259 sort_by_digest = sort_by_digest_4_5;
8260 opti_type = OPTI_TYPE_ZERO_BYTE;
8261 dgst_pos0 = 0;
8262 dgst_pos1 = 1;
8263 dgst_pos2 = 2;
8264 dgst_pos3 = 3;
8265 break;
8266
8267 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8268 salt_type = SALT_TYPE_NONE;
8269 attack_exec = ATTACK_EXEC_ON_GPU;
8270 opts_type = OPTS_TYPE_PT_GENERATE_LE
8271 | OPTS_TYPE_PT_ADD80;
8272 kern_type = KERN_TYPE_RIPEMD160;
8273 dgst_size = DGST_SIZE_4_5;
8274 parse_func = ripemd160_parse_hash;
8275 sort_by_digest = sort_by_digest_4_5;
8276 opti_type = OPTI_TYPE_ZERO_BYTE;
8277 dgst_pos0 = 0;
8278 dgst_pos1 = 1;
8279 dgst_pos2 = 2;
8280 dgst_pos3 = 3;
8281 break;
8282
8283 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8284 salt_type = SALT_TYPE_NONE;
8285 attack_exec = ATTACK_EXEC_ON_GPU;
8286 opts_type = OPTS_TYPE_PT_GENERATE_BE
8287 | OPTS_TYPE_PT_ADD80;
8288 kern_type = KERN_TYPE_WHIRLPOOL;
8289 dgst_size = DGST_SIZE_4_16;
8290 parse_func = whirlpool_parse_hash;
8291 sort_by_digest = sort_by_digest_4_16;
8292 opti_type = OPTI_TYPE_ZERO_BYTE;
8293 dgst_pos0 = 0;
8294 dgst_pos1 = 1;
8295 dgst_pos2 = 2;
8296 dgst_pos3 = 3;
8297 break;
8298
8299 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8300 salt_type = SALT_TYPE_EMBEDDED;
8301 attack_exec = ATTACK_EXEC_ON_CPU;
8302 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8303 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8304 dgst_size = DGST_SIZE_4_5;
8305 parse_func = truecrypt_parse_hash_2k;
8306 sort_by_digest = sort_by_digest_4_5;
8307 opti_type = OPTI_TYPE_ZERO_BYTE;
8308 dgst_pos0 = 0;
8309 dgst_pos1 = 1;
8310 dgst_pos2 = 2;
8311 dgst_pos3 = 3;
8312 break;
8313
8314 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8315 salt_type = SALT_TYPE_EMBEDDED;
8316 attack_exec = ATTACK_EXEC_ON_CPU;
8317 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8318 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8319 dgst_size = DGST_SIZE_4_5;
8320 parse_func = truecrypt_parse_hash_2k;
8321 sort_by_digest = sort_by_digest_4_5;
8322 opti_type = OPTI_TYPE_ZERO_BYTE;
8323 dgst_pos0 = 0;
8324 dgst_pos1 = 1;
8325 dgst_pos2 = 2;
8326 dgst_pos3 = 3;
8327 break;
8328
8329 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8330 salt_type = SALT_TYPE_EMBEDDED;
8331 attack_exec = ATTACK_EXEC_ON_CPU;
8332 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8333 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8334 dgst_size = DGST_SIZE_4_5;
8335 parse_func = truecrypt_parse_hash_2k;
8336 sort_by_digest = sort_by_digest_4_5;
8337 opti_type = OPTI_TYPE_ZERO_BYTE;
8338 dgst_pos0 = 0;
8339 dgst_pos1 = 1;
8340 dgst_pos2 = 2;
8341 dgst_pos3 = 3;
8342 break;
8343
8344 case 6221: hash_type = HASH_TYPE_SHA512;
8345 salt_type = SALT_TYPE_EMBEDDED;
8346 attack_exec = ATTACK_EXEC_ON_CPU;
8347 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8348 kern_type = KERN_TYPE_TCSHA512_XTS512;
8349 dgst_size = DGST_SIZE_8_8;
8350 parse_func = truecrypt_parse_hash_1k;
8351 sort_by_digest = sort_by_digest_8_8;
8352 opti_type = OPTI_TYPE_ZERO_BYTE;
8353 dgst_pos0 = 0;
8354 dgst_pos1 = 1;
8355 dgst_pos2 = 2;
8356 dgst_pos3 = 3;
8357 break;
8358
8359 case 6222: hash_type = HASH_TYPE_SHA512;
8360 salt_type = SALT_TYPE_EMBEDDED;
8361 attack_exec = ATTACK_EXEC_ON_CPU;
8362 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8363 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8364 dgst_size = DGST_SIZE_8_8;
8365 parse_func = truecrypt_parse_hash_1k;
8366 sort_by_digest = sort_by_digest_8_8;
8367 opti_type = OPTI_TYPE_ZERO_BYTE;
8368 dgst_pos0 = 0;
8369 dgst_pos1 = 1;
8370 dgst_pos2 = 2;
8371 dgst_pos3 = 3;
8372 break;
8373
8374 case 6223: hash_type = HASH_TYPE_SHA512;
8375 salt_type = SALT_TYPE_EMBEDDED;
8376 attack_exec = ATTACK_EXEC_ON_CPU;
8377 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8378 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8379 dgst_size = DGST_SIZE_8_8;
8380 parse_func = truecrypt_parse_hash_1k;
8381 sort_by_digest = sort_by_digest_8_8;
8382 opti_type = OPTI_TYPE_ZERO_BYTE;
8383 dgst_pos0 = 0;
8384 dgst_pos1 = 1;
8385 dgst_pos2 = 2;
8386 dgst_pos3 = 3;
8387 break;
8388
8389 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8390 salt_type = SALT_TYPE_EMBEDDED;
8391 attack_exec = ATTACK_EXEC_ON_CPU;
8392 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8393 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8394 dgst_size = DGST_SIZE_4_8;
8395 parse_func = truecrypt_parse_hash_1k;
8396 sort_by_digest = sort_by_digest_4_8;
8397 opti_type = OPTI_TYPE_ZERO_BYTE;
8398 dgst_pos0 = 0;
8399 dgst_pos1 = 1;
8400 dgst_pos2 = 2;
8401 dgst_pos3 = 3;
8402 break;
8403
8404 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8405 salt_type = SALT_TYPE_EMBEDDED;
8406 attack_exec = ATTACK_EXEC_ON_CPU;
8407 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8408 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8409 dgst_size = DGST_SIZE_4_8;
8410 parse_func = truecrypt_parse_hash_1k;
8411 sort_by_digest = sort_by_digest_4_8;
8412 opti_type = OPTI_TYPE_ZERO_BYTE;
8413 dgst_pos0 = 0;
8414 dgst_pos1 = 1;
8415 dgst_pos2 = 2;
8416 dgst_pos3 = 3;
8417 break;
8418
8419 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8420 salt_type = SALT_TYPE_EMBEDDED;
8421 attack_exec = ATTACK_EXEC_ON_CPU;
8422 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8423 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8424 dgst_size = DGST_SIZE_4_8;
8425 parse_func = truecrypt_parse_hash_1k;
8426 sort_by_digest = sort_by_digest_4_8;
8427 opti_type = OPTI_TYPE_ZERO_BYTE;
8428 dgst_pos0 = 0;
8429 dgst_pos1 = 1;
8430 dgst_pos2 = 2;
8431 dgst_pos3 = 3;
8432 break;
8433
8434 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8435 salt_type = SALT_TYPE_EMBEDDED;
8436 attack_exec = ATTACK_EXEC_ON_CPU;
8437 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8438 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8439 dgst_size = DGST_SIZE_4_5;
8440 parse_func = truecrypt_parse_hash_1k;
8441 sort_by_digest = sort_by_digest_4_5;
8442 opti_type = OPTI_TYPE_ZERO_BYTE;
8443 dgst_pos0 = 0;
8444 dgst_pos1 = 1;
8445 dgst_pos2 = 2;
8446 dgst_pos3 = 3;
8447 break;
8448
8449 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8450 salt_type = SALT_TYPE_EMBEDDED;
8451 attack_exec = ATTACK_EXEC_ON_CPU;
8452 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8453 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8454 dgst_size = DGST_SIZE_4_5;
8455 parse_func = truecrypt_parse_hash_1k;
8456 sort_by_digest = sort_by_digest_4_5;
8457 opti_type = OPTI_TYPE_ZERO_BYTE;
8458 dgst_pos0 = 0;
8459 dgst_pos1 = 1;
8460 dgst_pos2 = 2;
8461 dgst_pos3 = 3;
8462 break;
8463
8464 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8465 salt_type = SALT_TYPE_EMBEDDED;
8466 attack_exec = ATTACK_EXEC_ON_CPU;
8467 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8468 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8469 dgst_size = DGST_SIZE_4_5;
8470 parse_func = truecrypt_parse_hash_1k;
8471 sort_by_digest = sort_by_digest_4_5;
8472 opti_type = OPTI_TYPE_ZERO_BYTE;
8473 dgst_pos0 = 0;
8474 dgst_pos1 = 1;
8475 dgst_pos2 = 2;
8476 dgst_pos3 = 3;
8477 break;
8478
8479 case 6300: hash_type = HASH_TYPE_MD5;
8480 salt_type = SALT_TYPE_EMBEDDED;
8481 attack_exec = ATTACK_EXEC_ON_CPU;
8482 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8483 kern_type = KERN_TYPE_MD5AIX;
8484 dgst_size = DGST_SIZE_4_4;
8485 parse_func = md5aix_parse_hash;
8486 sort_by_digest = sort_by_digest_4_4;
8487 opti_type = OPTI_TYPE_ZERO_BYTE;
8488 dgst_pos0 = 0;
8489 dgst_pos1 = 1;
8490 dgst_pos2 = 2;
8491 dgst_pos3 = 3;
8492 break;
8493
8494 case 6400: hash_type = HASH_TYPE_SHA256;
8495 salt_type = SALT_TYPE_EMBEDDED;
8496 attack_exec = ATTACK_EXEC_ON_CPU;
8497 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8498 kern_type = KERN_TYPE_SHA256AIX;
8499 dgst_size = DGST_SIZE_4_8;
8500 parse_func = sha256aix_parse_hash;
8501 sort_by_digest = sort_by_digest_4_8;
8502 opti_type = OPTI_TYPE_ZERO_BYTE;
8503 dgst_pos0 = 0;
8504 dgst_pos1 = 1;
8505 dgst_pos2 = 2;
8506 dgst_pos3 = 3;
8507 break;
8508
8509 case 6500: hash_type = HASH_TYPE_SHA512;
8510 salt_type = SALT_TYPE_EMBEDDED;
8511 attack_exec = ATTACK_EXEC_ON_CPU;
8512 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8513 kern_type = KERN_TYPE_SHA512AIX;
8514 dgst_size = DGST_SIZE_8_8;
8515 parse_func = sha512aix_parse_hash;
8516 sort_by_digest = sort_by_digest_8_8;
8517 opti_type = OPTI_TYPE_ZERO_BYTE;
8518 dgst_pos0 = 0;
8519 dgst_pos1 = 1;
8520 dgst_pos2 = 2;
8521 dgst_pos3 = 3;
8522 break;
8523
8524 case 6600: hash_type = HASH_TYPE_AES;
8525 salt_type = SALT_TYPE_EMBEDDED;
8526 attack_exec = ATTACK_EXEC_ON_CPU;
8527 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8528 kern_type = KERN_TYPE_AGILEKEY;
8529 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8530 parse_func = agilekey_parse_hash;
8531 sort_by_digest = sort_by_digest_4_5;
8532 opti_type = OPTI_TYPE_ZERO_BYTE;
8533 dgst_pos0 = 0;
8534 dgst_pos1 = 1;
8535 dgst_pos2 = 2;
8536 dgst_pos3 = 3;
8537 break;
8538
8539 case 6700: hash_type = HASH_TYPE_SHA1;
8540 salt_type = SALT_TYPE_EMBEDDED;
8541 attack_exec = ATTACK_EXEC_ON_CPU;
8542 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8543 kern_type = KERN_TYPE_SHA1AIX;
8544 dgst_size = DGST_SIZE_4_5;
8545 parse_func = sha1aix_parse_hash;
8546 sort_by_digest = sort_by_digest_4_5;
8547 opti_type = OPTI_TYPE_ZERO_BYTE;
8548 dgst_pos0 = 0;
8549 dgst_pos1 = 1;
8550 dgst_pos2 = 2;
8551 dgst_pos3 = 3;
8552 break;
8553
8554 case 6800: hash_type = HASH_TYPE_AES;
8555 salt_type = SALT_TYPE_EMBEDDED;
8556 attack_exec = ATTACK_EXEC_ON_CPU;
8557 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8558 kern_type = KERN_TYPE_LASTPASS;
8559 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
8560 parse_func = lastpass_parse_hash;
8561 sort_by_digest = sort_by_digest_4_8;
8562 opti_type = OPTI_TYPE_ZERO_BYTE;
8563 dgst_pos0 = 0;
8564 dgst_pos1 = 1;
8565 dgst_pos2 = 2;
8566 dgst_pos3 = 3;
8567 break;
8568
8569 case 6900: hash_type = HASH_TYPE_GOST;
8570 salt_type = SALT_TYPE_NONE;
8571 attack_exec = ATTACK_EXEC_ON_GPU;
8572 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8573 kern_type = KERN_TYPE_GOST;
8574 dgst_size = DGST_SIZE_4_8;
8575 parse_func = gost_parse_hash;
8576 sort_by_digest = sort_by_digest_4_8;
8577 opti_type = OPTI_TYPE_ZERO_BYTE;
8578 dgst_pos0 = 0;
8579 dgst_pos1 = 1;
8580 dgst_pos2 = 2;
8581 dgst_pos3 = 3;
8582 break;
8583
8584 case 7100: hash_type = HASH_TYPE_SHA512;
8585 salt_type = SALT_TYPE_EMBEDDED;
8586 attack_exec = ATTACK_EXEC_ON_CPU;
8587 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8588 kern_type = KERN_TYPE_PBKDF2_SHA512;
8589 dgst_size = DGST_SIZE_8_16;
8590 parse_func = sha512osx_parse_hash;
8591 sort_by_digest = sort_by_digest_8_16;
8592 opti_type = OPTI_TYPE_ZERO_BYTE;
8593 dgst_pos0 = 0;
8594 dgst_pos1 = 1;
8595 dgst_pos2 = 2;
8596 dgst_pos3 = 3;
8597 break;
8598
8599 case 7200: hash_type = HASH_TYPE_SHA512;
8600 salt_type = SALT_TYPE_EMBEDDED;
8601 attack_exec = ATTACK_EXEC_ON_CPU;
8602 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8603 kern_type = KERN_TYPE_PBKDF2_SHA512;
8604 dgst_size = DGST_SIZE_8_16;
8605 parse_func = sha512grub_parse_hash;
8606 sort_by_digest = sort_by_digest_8_16;
8607 opti_type = OPTI_TYPE_ZERO_BYTE;
8608 dgst_pos0 = 0;
8609 dgst_pos1 = 1;
8610 dgst_pos2 = 2;
8611 dgst_pos3 = 3;
8612 break;
8613
8614 case 7300: hash_type = HASH_TYPE_SHA1;
8615 salt_type = SALT_TYPE_EMBEDDED;
8616 attack_exec = ATTACK_EXEC_ON_GPU;
8617 opts_type = OPTS_TYPE_PT_GENERATE_BE
8618 | OPTS_TYPE_ST_ADD80
8619 | OPTS_TYPE_ST_ADDBITS15;
8620 kern_type = KERN_TYPE_RAKP;
8621 dgst_size = DGST_SIZE_4_5;
8622 parse_func = rakp_parse_hash;
8623 sort_by_digest = sort_by_digest_4_5;
8624 opti_type = OPTI_TYPE_ZERO_BYTE
8625 | OPTI_TYPE_NOT_ITERATED;
8626 dgst_pos0 = 3;
8627 dgst_pos1 = 4;
8628 dgst_pos2 = 2;
8629 dgst_pos3 = 1;
8630 break;
8631
8632 case 7400: hash_type = HASH_TYPE_SHA256;
8633 salt_type = SALT_TYPE_EMBEDDED;
8634 attack_exec = ATTACK_EXEC_ON_CPU;
8635 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8636 kern_type = KERN_TYPE_SHA256CRYPT;
8637 dgst_size = DGST_SIZE_4_8;
8638 parse_func = sha256crypt_parse_hash;
8639 sort_by_digest = sort_by_digest_4_8;
8640 opti_type = OPTI_TYPE_ZERO_BYTE;
8641 dgst_pos0 = 0;
8642 dgst_pos1 = 1;
8643 dgst_pos2 = 2;
8644 dgst_pos3 = 3;
8645 break;
8646
8647 case 7500: hash_type = HASH_TYPE_KRB5PA;
8648 salt_type = SALT_TYPE_EMBEDDED;
8649 attack_exec = ATTACK_EXEC_ON_GPU;
8650 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8651 kern_type = KERN_TYPE_KRB5PA;
8652 dgst_size = DGST_SIZE_4_4;
8653 parse_func = krb5pa_parse_hash;
8654 sort_by_digest = sort_by_digest_4_4;
8655 opti_type = OPTI_TYPE_ZERO_BYTE
8656 | OPTI_TYPE_NOT_ITERATED;
8657 dgst_pos0 = 3;
8658 dgst_pos1 = 7;
8659 dgst_pos2 = 2;
8660 dgst_pos3 = 6;
8661 break;
8662
8663 case 7600: hash_type = HASH_TYPE_SHA1;
8664 salt_type = SALT_TYPE_INTERN;
8665 attack_exec = ATTACK_EXEC_ON_GPU;
8666 opts_type = OPTS_TYPE_PT_GENERATE_BE
8667 | OPTS_TYPE_PT_ADD80
8668 | OPTS_TYPE_PT_ADDBITS15;
8669 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
8670 dgst_size = DGST_SIZE_4_5;
8671 parse_func = redmine_parse_hash;
8672 sort_by_digest = sort_by_digest_4_5;
8673 opti_type = OPTI_TYPE_ZERO_BYTE
8674 | OPTI_TYPE_PRECOMPUTE_INIT
8675 | OPTI_TYPE_EARLY_SKIP
8676 | OPTI_TYPE_NOT_ITERATED
8677 | OPTI_TYPE_PREPENDED_SALT;
8678 dgst_pos0 = 3;
8679 dgst_pos1 = 4;
8680 dgst_pos2 = 2;
8681 dgst_pos3 = 1;
8682 break;
8683
8684 case 7700: hash_type = HASH_TYPE_SAPB;
8685 salt_type = SALT_TYPE_EMBEDDED;
8686 attack_exec = ATTACK_EXEC_ON_GPU;
8687 opts_type = OPTS_TYPE_PT_GENERATE_LE
8688 | OPTS_TYPE_PT_UPPER
8689 | OPTS_TYPE_ST_UPPER;
8690 kern_type = KERN_TYPE_SAPB;
8691 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8692 parse_func = sapb_parse_hash;
8693 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8694 opti_type = OPTI_TYPE_ZERO_BYTE
8695 | OPTI_TYPE_PRECOMPUTE_INIT
8696 | OPTI_TYPE_NOT_ITERATED;
8697 dgst_pos0 = 0;
8698 dgst_pos1 = 1;
8699 dgst_pos2 = 2;
8700 dgst_pos3 = 3;
8701 break;
8702
8703 case 7800: hash_type = HASH_TYPE_SAPG;
8704 salt_type = SALT_TYPE_EMBEDDED;
8705 attack_exec = ATTACK_EXEC_ON_GPU;
8706 opts_type = OPTS_TYPE_PT_GENERATE_BE
8707 | OPTS_TYPE_ST_ADD80
8708 | OPTS_TYPE_ST_UPPER;
8709 kern_type = KERN_TYPE_SAPG;
8710 dgst_size = DGST_SIZE_4_5;
8711 parse_func = sapg_parse_hash;
8712 sort_by_digest = sort_by_digest_4_5;
8713 opti_type = OPTI_TYPE_ZERO_BYTE
8714 | OPTI_TYPE_PRECOMPUTE_INIT
8715 | OPTI_TYPE_NOT_ITERATED;
8716 dgst_pos0 = 3;
8717 dgst_pos1 = 4;
8718 dgst_pos2 = 2;
8719 dgst_pos3 = 1;
8720 break;
8721
8722 case 7900: hash_type = HASH_TYPE_SHA512;
8723 salt_type = SALT_TYPE_EMBEDDED;
8724 attack_exec = ATTACK_EXEC_ON_CPU;
8725 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8726 kern_type = KERN_TYPE_DRUPAL7;
8727 dgst_size = DGST_SIZE_8_8;
8728 parse_func = drupal7_parse_hash;
8729 sort_by_digest = sort_by_digest_8_8;
8730 opti_type = OPTI_TYPE_ZERO_BYTE;
8731 dgst_pos0 = 0;
8732 dgst_pos1 = 1;
8733 dgst_pos2 = 2;
8734 dgst_pos3 = 3;
8735 break;
8736
8737 case 8000: hash_type = HASH_TYPE_SHA256;
8738 salt_type = SALT_TYPE_EMBEDDED;
8739 attack_exec = ATTACK_EXEC_ON_GPU;
8740 opts_type = OPTS_TYPE_PT_GENERATE_BE
8741 | OPTS_TYPE_PT_UNICODE
8742 | OPTS_TYPE_ST_ADD80
8743 | OPTS_TYPE_ST_HEX;
8744 kern_type = KERN_TYPE_SYBASEASE;
8745 dgst_size = DGST_SIZE_4_8;
8746 parse_func = sybasease_parse_hash;
8747 sort_by_digest = sort_by_digest_4_8;
8748 opti_type = OPTI_TYPE_ZERO_BYTE
8749 | OPTI_TYPE_PRECOMPUTE_INIT
8750 | OPTI_TYPE_EARLY_SKIP
8751 | OPTI_TYPE_NOT_ITERATED
8752 | OPTI_TYPE_RAW_HASH;
8753 dgst_pos0 = 3;
8754 dgst_pos1 = 7;
8755 dgst_pos2 = 2;
8756 dgst_pos3 = 6;
8757 break;
8758
8759 case 8100: hash_type = HASH_TYPE_SHA1;
8760 salt_type = SALT_TYPE_EMBEDDED;
8761 attack_exec = ATTACK_EXEC_ON_GPU;
8762 opts_type = OPTS_TYPE_PT_GENERATE_BE;
8763 kern_type = KERN_TYPE_NETSCALER;
8764 dgst_size = DGST_SIZE_4_5;
8765 parse_func = netscaler_parse_hash;
8766 sort_by_digest = sort_by_digest_4_5;
8767 opti_type = OPTI_TYPE_ZERO_BYTE
8768 | OPTI_TYPE_PRECOMPUTE_INIT
8769 | OPTI_TYPE_PRECOMPUTE_MERKLE
8770 | OPTI_TYPE_EARLY_SKIP
8771 | OPTI_TYPE_NOT_ITERATED
8772 | OPTI_TYPE_PREPENDED_SALT
8773 | OPTI_TYPE_RAW_HASH;
8774 dgst_pos0 = 3;
8775 dgst_pos1 = 4;
8776 dgst_pos2 = 2;
8777 dgst_pos3 = 1;
8778 break;
8779
8780 case 8200: hash_type = HASH_TYPE_SHA256;
8781 salt_type = SALT_TYPE_EMBEDDED;
8782 attack_exec = ATTACK_EXEC_ON_CPU;
8783 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8784 kern_type = KERN_TYPE_CLOUDKEY;
8785 dgst_size = DGST_SIZE_4_8;
8786 parse_func = cloudkey_parse_hash;
8787 sort_by_digest = sort_by_digest_4_8;
8788 opti_type = OPTI_TYPE_ZERO_BYTE;
8789 dgst_pos0 = 0;
8790 dgst_pos1 = 1;
8791 dgst_pos2 = 2;
8792 dgst_pos3 = 3;
8793 break;
8794
8795 case 8300: hash_type = HASH_TYPE_SHA1;
8796 salt_type = SALT_TYPE_EMBEDDED;
8797 attack_exec = ATTACK_EXEC_ON_GPU;
8798 opts_type = OPTS_TYPE_PT_GENERATE_LE
8799 | OPTS_TYPE_ST_HEX
8800 | OPTS_TYPE_ST_ADD80;
8801 kern_type = KERN_TYPE_NSEC3;
8802 dgst_size = DGST_SIZE_4_5;
8803 parse_func = nsec3_parse_hash;
8804 sort_by_digest = sort_by_digest_4_5;
8805 opti_type = OPTI_TYPE_ZERO_BYTE;
8806 dgst_pos0 = 3;
8807 dgst_pos1 = 4;
8808 dgst_pos2 = 2;
8809 dgst_pos3 = 1;
8810 break;
8811
8812 case 8400: hash_type = HASH_TYPE_SHA1;
8813 salt_type = SALT_TYPE_INTERN;
8814 attack_exec = ATTACK_EXEC_ON_GPU;
8815 opts_type = OPTS_TYPE_PT_GENERATE_BE
8816 | OPTS_TYPE_PT_ADD80
8817 | OPTS_TYPE_PT_ADDBITS15;
8818 kern_type = KERN_TYPE_WBB3;
8819 dgst_size = DGST_SIZE_4_5;
8820 parse_func = wbb3_parse_hash;
8821 sort_by_digest = sort_by_digest_4_5;
8822 opti_type = OPTI_TYPE_ZERO_BYTE
8823 | OPTI_TYPE_PRECOMPUTE_INIT
8824 | OPTI_TYPE_NOT_ITERATED;
8825 dgst_pos0 = 3;
8826 dgst_pos1 = 4;
8827 dgst_pos2 = 2;
8828 dgst_pos3 = 1;
8829 break;
8830
8831 case 8500: hash_type = HASH_TYPE_DESRACF;
8832 salt_type = SALT_TYPE_EMBEDDED;
8833 attack_exec = ATTACK_EXEC_ON_GPU;
8834 opts_type = OPTS_TYPE_PT_GENERATE_LE
8835 | OPTS_TYPE_ST_UPPER;
8836 kern_type = KERN_TYPE_RACF;
8837 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8838 parse_func = racf_parse_hash;
8839 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8840 opti_type = OPTI_TYPE_ZERO_BYTE
8841 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8842 dgst_pos0 = 0;
8843 dgst_pos1 = 1;
8844 dgst_pos2 = 2;
8845 dgst_pos3 = 3;
8846 break;
8847
8848 case 8600: hash_type = HASH_TYPE_LOTUS5;
8849 salt_type = SALT_TYPE_NONE;
8850 attack_exec = ATTACK_EXEC_ON_GPU;
8851 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8852 kern_type = KERN_TYPE_LOTUS5;
8853 dgst_size = DGST_SIZE_4_4;
8854 parse_func = lotus5_parse_hash;
8855 sort_by_digest = sort_by_digest_4_4;
8856 opti_type = OPTI_TYPE_EARLY_SKIP
8857 | OPTI_TYPE_NOT_ITERATED
8858 | OPTI_TYPE_NOT_SALTED
8859 | OPTI_TYPE_RAW_HASH;
8860 dgst_pos0 = 0;
8861 dgst_pos1 = 1;
8862 dgst_pos2 = 2;
8863 dgst_pos3 = 3;
8864 break;
8865
8866 case 8700: hash_type = HASH_TYPE_LOTUS6;
8867 salt_type = SALT_TYPE_EMBEDDED;
8868 attack_exec = ATTACK_EXEC_ON_GPU;
8869 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8870 kern_type = KERN_TYPE_LOTUS6;
8871 dgst_size = DGST_SIZE_4_4;
8872 parse_func = lotus6_parse_hash;
8873 sort_by_digest = sort_by_digest_4_4;
8874 opti_type = OPTI_TYPE_EARLY_SKIP
8875 | OPTI_TYPE_NOT_ITERATED
8876 | OPTI_TYPE_RAW_HASH;
8877 dgst_pos0 = 0;
8878 dgst_pos1 = 1;
8879 dgst_pos2 = 2;
8880 dgst_pos3 = 3;
8881 break;
8882
8883 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
8884 salt_type = SALT_TYPE_EMBEDDED;
8885 attack_exec = ATTACK_EXEC_ON_CPU;
8886 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8887 kern_type = KERN_TYPE_ANDROIDFDE;
8888 dgst_size = DGST_SIZE_4_4;
8889 parse_func = androidfde_parse_hash;
8890 sort_by_digest = sort_by_digest_4_4;
8891 opti_type = OPTI_TYPE_ZERO_BYTE;
8892 dgst_pos0 = 0;
8893 dgst_pos1 = 1;
8894 dgst_pos2 = 2;
8895 dgst_pos3 = 3;
8896 break;
8897
8898 case 8900: hash_type = HASH_TYPE_SCRYPT;
8899 salt_type = SALT_TYPE_EMBEDDED;
8900 attack_exec = ATTACK_EXEC_ON_CPU;
8901 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8902 kern_type = KERN_TYPE_SCRYPT;
8903 dgst_size = DGST_SIZE_4_8;
8904 parse_func = scrypt_parse_hash;
8905 sort_by_digest = sort_by_digest_4_8;
8906 opti_type = OPTI_TYPE_ZERO_BYTE;
8907 dgst_pos0 = 0;
8908 dgst_pos1 = 1;
8909 dgst_pos2 = 2;
8910 dgst_pos3 = 3;
8911 break;
8912
8913 case 9000: hash_type = HASH_TYPE_SHA1;
8914 salt_type = SALT_TYPE_EMBEDDED;
8915 attack_exec = ATTACK_EXEC_ON_CPU;
8916 opts_type = OPTS_TYPE_PT_GENERATE_LE
8917 | OPTS_TYPE_ST_GENERATE_LE;
8918 kern_type = KERN_TYPE_PSAFE2;
8919 dgst_size = DGST_SIZE_4_5;
8920 parse_func = psafe2_parse_hash;
8921 sort_by_digest = sort_by_digest_4_5;
8922 opti_type = OPTI_TYPE_ZERO_BYTE;
8923 dgst_pos0 = 0;
8924 dgst_pos1 = 1;
8925 dgst_pos2 = 2;
8926 dgst_pos3 = 3;
8927 break;
8928
8929 case 9100: hash_type = HASH_TYPE_LOTUS8;
8930 salt_type = SALT_TYPE_EMBEDDED;
8931 attack_exec = ATTACK_EXEC_ON_CPU;
8932 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8933 kern_type = KERN_TYPE_LOTUS8;
8934 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8935 parse_func = lotus8_parse_hash;
8936 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8937 opti_type = OPTI_TYPE_ZERO_BYTE;
8938 dgst_pos0 = 0;
8939 dgst_pos1 = 1;
8940 dgst_pos2 = 2;
8941 dgst_pos3 = 3;
8942 break;
8943
8944 case 9200: hash_type = HASH_TYPE_SHA256;
8945 salt_type = SALT_TYPE_EMBEDDED;
8946 attack_exec = ATTACK_EXEC_ON_CPU;
8947 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8948 kern_type = KERN_TYPE_PBKDF2_SHA256;
8949 dgst_size = DGST_SIZE_4_32;
8950 parse_func = cisco8_parse_hash;
8951 sort_by_digest = sort_by_digest_4_32;
8952 opti_type = OPTI_TYPE_ZERO_BYTE;
8953 dgst_pos0 = 0;
8954 dgst_pos1 = 1;
8955 dgst_pos2 = 2;
8956 dgst_pos3 = 3;
8957 break;
8958
8959 case 9300: hash_type = HASH_TYPE_SCRYPT;
8960 salt_type = SALT_TYPE_EMBEDDED;
8961 attack_exec = ATTACK_EXEC_ON_CPU;
8962 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8963 kern_type = KERN_TYPE_SCRYPT;
8964 dgst_size = DGST_SIZE_4_8;
8965 parse_func = cisco9_parse_hash;
8966 sort_by_digest = sort_by_digest_4_8;
8967 opti_type = OPTI_TYPE_ZERO_BYTE;
8968 dgst_pos0 = 0;
8969 dgst_pos1 = 1;
8970 dgst_pos2 = 2;
8971 dgst_pos3 = 3;
8972 break;
8973
8974 case 9400: hash_type = HASH_TYPE_OFFICE2007;
8975 salt_type = SALT_TYPE_EMBEDDED;
8976 attack_exec = ATTACK_EXEC_ON_CPU;
8977 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8978 kern_type = KERN_TYPE_OFFICE2007;
8979 dgst_size = DGST_SIZE_4_4;
8980 parse_func = office2007_parse_hash;
8981 sort_by_digest = sort_by_digest_4_4;
8982 opti_type = OPTI_TYPE_ZERO_BYTE;
8983 dgst_pos0 = 0;
8984 dgst_pos1 = 1;
8985 dgst_pos2 = 2;
8986 dgst_pos3 = 3;
8987 break;
8988
8989 case 9500: hash_type = HASH_TYPE_OFFICE2010;
8990 salt_type = SALT_TYPE_EMBEDDED;
8991 attack_exec = ATTACK_EXEC_ON_CPU;
8992 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8993 kern_type = KERN_TYPE_OFFICE2010;
8994 dgst_size = DGST_SIZE_4_4;
8995 parse_func = office2010_parse_hash;
8996 sort_by_digest = sort_by_digest_4_4;
8997 opti_type = OPTI_TYPE_ZERO_BYTE;
8998 dgst_pos0 = 0;
8999 dgst_pos1 = 1;
9000 dgst_pos2 = 2;
9001 dgst_pos3 = 3;
9002 break;
9003
9004 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9005 salt_type = SALT_TYPE_EMBEDDED;
9006 attack_exec = ATTACK_EXEC_ON_CPU;
9007 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9008 kern_type = KERN_TYPE_OFFICE2013;
9009 dgst_size = DGST_SIZE_4_4;
9010 parse_func = office2013_parse_hash;
9011 sort_by_digest = sort_by_digest_4_4;
9012 opti_type = OPTI_TYPE_ZERO_BYTE;
9013 dgst_pos0 = 0;
9014 dgst_pos1 = 1;
9015 dgst_pos2 = 2;
9016 dgst_pos3 = 3;
9017 break;
9018
9019 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9020 salt_type = SALT_TYPE_EMBEDDED;
9021 attack_exec = ATTACK_EXEC_ON_GPU;
9022 opts_type = OPTS_TYPE_PT_GENERATE_LE
9023 | OPTS_TYPE_PT_ADD80
9024 | OPTS_TYPE_PT_UNICODE;
9025 kern_type = KERN_TYPE_OLDOFFICE01;
9026 dgst_size = DGST_SIZE_4_4;
9027 parse_func = oldoffice01_parse_hash;
9028 sort_by_digest = sort_by_digest_4_4;
9029 opti_type = OPTI_TYPE_ZERO_BYTE
9030 | OPTI_TYPE_PRECOMPUTE_INIT
9031 | OPTI_TYPE_NOT_ITERATED;
9032 dgst_pos0 = 0;
9033 dgst_pos1 = 1;
9034 dgst_pos2 = 2;
9035 dgst_pos3 = 3;
9036 break;
9037
9038 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9039 salt_type = SALT_TYPE_EMBEDDED;
9040 attack_exec = ATTACK_EXEC_ON_GPU;
9041 opts_type = OPTS_TYPE_PT_GENERATE_LE
9042 | OPTS_TYPE_PT_ADD80;
9043 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9044 dgst_size = DGST_SIZE_4_4;
9045 parse_func = oldoffice01cm1_parse_hash;
9046 sort_by_digest = sort_by_digest_4_4;
9047 opti_type = OPTI_TYPE_ZERO_BYTE
9048 | OPTI_TYPE_PRECOMPUTE_INIT
9049 | OPTI_TYPE_NOT_ITERATED;
9050 dgst_pos0 = 0;
9051 dgst_pos1 = 1;
9052 dgst_pos2 = 2;
9053 dgst_pos3 = 3;
9054 break;
9055
9056 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9057 salt_type = SALT_TYPE_EMBEDDED;
9058 attack_exec = ATTACK_EXEC_ON_GPU;
9059 opts_type = OPTS_TYPE_PT_GENERATE_LE
9060 | OPTS_TYPE_PT_ADD80
9061 | OPTS_TYPE_PT_UNICODE
9062 | OPTS_TYPE_PT_NEVERCRACK;
9063 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9064 dgst_size = DGST_SIZE_4_4;
9065 parse_func = oldoffice01cm2_parse_hash;
9066 sort_by_digest = sort_by_digest_4_4;
9067 opti_type = OPTI_TYPE_ZERO_BYTE
9068 | OPTI_TYPE_PRECOMPUTE_INIT
9069 | OPTI_TYPE_NOT_ITERATED;
9070 dgst_pos0 = 0;
9071 dgst_pos1 = 1;
9072 dgst_pos2 = 2;
9073 dgst_pos3 = 3;
9074 break;
9075
9076 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9077 salt_type = SALT_TYPE_EMBEDDED;
9078 attack_exec = ATTACK_EXEC_ON_GPU;
9079 opts_type = OPTS_TYPE_PT_GENERATE_BE
9080 | OPTS_TYPE_PT_ADD80
9081 | OPTS_TYPE_PT_UNICODE;
9082 kern_type = KERN_TYPE_OLDOFFICE34;
9083 dgst_size = DGST_SIZE_4_4;
9084 parse_func = oldoffice34_parse_hash;
9085 sort_by_digest = sort_by_digest_4_4;
9086 opti_type = OPTI_TYPE_ZERO_BYTE
9087 | OPTI_TYPE_PRECOMPUTE_INIT
9088 | OPTI_TYPE_NOT_ITERATED;
9089 dgst_pos0 = 0;
9090 dgst_pos1 = 1;
9091 dgst_pos2 = 2;
9092 dgst_pos3 = 3;
9093 break;
9094
9095 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9096 salt_type = SALT_TYPE_EMBEDDED;
9097 attack_exec = ATTACK_EXEC_ON_GPU;
9098 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9099 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9100 dgst_size = DGST_SIZE_4_4;
9101 parse_func = oldoffice34cm1_parse_hash;
9102 sort_by_digest = sort_by_digest_4_4;
9103 opti_type = OPTI_TYPE_ZERO_BYTE
9104 | OPTI_TYPE_PRECOMPUTE_INIT
9105 | OPTI_TYPE_NOT_ITERATED;
9106 dgst_pos0 = 0;
9107 dgst_pos1 = 1;
9108 dgst_pos2 = 2;
9109 dgst_pos3 = 3;
9110 break;
9111
9112 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9113 salt_type = SALT_TYPE_EMBEDDED;
9114 attack_exec = ATTACK_EXEC_ON_GPU;
9115 opts_type = OPTS_TYPE_PT_GENERATE_BE
9116 | OPTS_TYPE_PT_ADD80
9117 | OPTS_TYPE_PT_UNICODE
9118 | OPTS_TYPE_PT_NEVERCRACK;
9119 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9120 dgst_size = DGST_SIZE_4_4;
9121 parse_func = oldoffice34cm2_parse_hash;
9122 sort_by_digest = sort_by_digest_4_4;
9123 opti_type = OPTI_TYPE_ZERO_BYTE
9124 | OPTI_TYPE_PRECOMPUTE_INIT
9125 | OPTI_TYPE_NOT_ITERATED;
9126 dgst_pos0 = 0;
9127 dgst_pos1 = 1;
9128 dgst_pos2 = 2;
9129 dgst_pos3 = 3;
9130 break;
9131
9132 case 9900: hash_type = HASH_TYPE_MD5;
9133 salt_type = SALT_TYPE_NONE;
9134 attack_exec = ATTACK_EXEC_ON_GPU;
9135 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9136 kern_type = KERN_TYPE_RADMIN2;
9137 dgst_size = DGST_SIZE_4_4;
9138 parse_func = radmin2_parse_hash;
9139 sort_by_digest = sort_by_digest_4_4;
9140 opti_type = OPTI_TYPE_ZERO_BYTE
9141 | OPTI_TYPE_PRECOMPUTE_INIT
9142 | OPTI_TYPE_EARLY_SKIP
9143 | OPTI_TYPE_NOT_ITERATED
9144 | OPTI_TYPE_NOT_SALTED;
9145 dgst_pos0 = 0;
9146 dgst_pos1 = 3;
9147 dgst_pos2 = 2;
9148 dgst_pos3 = 1;
9149 break;
9150
9151 case 10000: hash_type = HASH_TYPE_SHA256;
9152 salt_type = SALT_TYPE_EMBEDDED;
9153 attack_exec = ATTACK_EXEC_ON_CPU;
9154 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9155 kern_type = KERN_TYPE_PBKDF2_SHA256;
9156 dgst_size = DGST_SIZE_4_32;
9157 parse_func = djangopbkdf2_parse_hash;
9158 sort_by_digest = sort_by_digest_4_32;
9159 opti_type = OPTI_TYPE_ZERO_BYTE;
9160 dgst_pos0 = 0;
9161 dgst_pos1 = 1;
9162 dgst_pos2 = 2;
9163 dgst_pos3 = 3;
9164 break;
9165
9166 case 10100: hash_type = HASH_TYPE_SIPHASH;
9167 salt_type = SALT_TYPE_EMBEDDED;
9168 attack_exec = ATTACK_EXEC_ON_GPU;
9169 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9170 kern_type = KERN_TYPE_SIPHASH;
9171 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9172 parse_func = siphash_parse_hash;
9173 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9174 opti_type = OPTI_TYPE_ZERO_BYTE
9175 | OPTI_TYPE_NOT_ITERATED
9176 | OPTI_TYPE_RAW_HASH;
9177 dgst_pos0 = 0;
9178 dgst_pos1 = 1;
9179 dgst_pos2 = 2;
9180 dgst_pos3 = 3;
9181 break;
9182
9183 case 10200: hash_type = HASH_TYPE_MD5;
9184 salt_type = SALT_TYPE_EMBEDDED;
9185 attack_exec = ATTACK_EXEC_ON_GPU;
9186 opts_type = OPTS_TYPE_PT_GENERATE_LE
9187 | OPTS_TYPE_ST_ADD80
9188 | OPTS_TYPE_ST_ADDBITS14;
9189 kern_type = KERN_TYPE_HMACMD5_PW;
9190 dgst_size = DGST_SIZE_4_4;
9191 parse_func = crammd5_parse_hash;
9192 sort_by_digest = sort_by_digest_4_4;
9193 opti_type = OPTI_TYPE_ZERO_BYTE
9194 | OPTI_TYPE_NOT_ITERATED;
9195 dgst_pos0 = 0;
9196 dgst_pos1 = 3;
9197 dgst_pos2 = 2;
9198 dgst_pos3 = 1;
9199 break;
9200
9201 case 10300: hash_type = HASH_TYPE_SHA1;
9202 salt_type = SALT_TYPE_EMBEDDED;
9203 attack_exec = ATTACK_EXEC_ON_CPU;
9204 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9205 kern_type = KERN_TYPE_SAPH_SHA1;
9206 dgst_size = DGST_SIZE_4_5;
9207 parse_func = saph_sha1_parse_hash;
9208 sort_by_digest = sort_by_digest_4_5;
9209 opti_type = OPTI_TYPE_ZERO_BYTE;
9210 dgst_pos0 = 0;
9211 dgst_pos1 = 1;
9212 dgst_pos2 = 2;
9213 dgst_pos3 = 3;
9214 break;
9215
9216 case 10400: hash_type = HASH_TYPE_PDFU16;
9217 salt_type = SALT_TYPE_EMBEDDED;
9218 attack_exec = ATTACK_EXEC_ON_GPU;
9219 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9220 kern_type = KERN_TYPE_PDF11;
9221 dgst_size = DGST_SIZE_4_4;
9222 parse_func = pdf11_parse_hash;
9223 sort_by_digest = sort_by_digest_4_4;
9224 opti_type = OPTI_TYPE_ZERO_BYTE
9225 | OPTI_TYPE_NOT_ITERATED;
9226 dgst_pos0 = 0;
9227 dgst_pos1 = 1;
9228 dgst_pos2 = 2;
9229 dgst_pos3 = 3;
9230 break;
9231
9232 case 10410: hash_type = HASH_TYPE_PDFU16;
9233 salt_type = SALT_TYPE_EMBEDDED;
9234 attack_exec = ATTACK_EXEC_ON_GPU;
9235 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9236 kern_type = KERN_TYPE_PDF11CM1;
9237 dgst_size = DGST_SIZE_4_4;
9238 parse_func = pdf11cm1_parse_hash;
9239 sort_by_digest = sort_by_digest_4_4;
9240 opti_type = OPTI_TYPE_ZERO_BYTE
9241 | OPTI_TYPE_NOT_ITERATED;
9242 dgst_pos0 = 0;
9243 dgst_pos1 = 1;
9244 dgst_pos2 = 2;
9245 dgst_pos3 = 3;
9246 break;
9247
9248 case 10420: hash_type = HASH_TYPE_PDFU16;
9249 salt_type = SALT_TYPE_EMBEDDED;
9250 attack_exec = ATTACK_EXEC_ON_GPU;
9251 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9252 kern_type = KERN_TYPE_PDF11CM2;
9253 dgst_size = DGST_SIZE_4_4;
9254 parse_func = pdf11cm2_parse_hash;
9255 sort_by_digest = sort_by_digest_4_4;
9256 opti_type = OPTI_TYPE_ZERO_BYTE
9257 | OPTI_TYPE_NOT_ITERATED;
9258 dgst_pos0 = 0;
9259 dgst_pos1 = 1;
9260 dgst_pos2 = 2;
9261 dgst_pos3 = 3;
9262 break;
9263
9264 case 10500: hash_type = HASH_TYPE_PDFU16;
9265 salt_type = SALT_TYPE_EMBEDDED;
9266 attack_exec = ATTACK_EXEC_ON_CPU;
9267 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9268 kern_type = KERN_TYPE_PDF14;
9269 dgst_size = DGST_SIZE_4_4;
9270 parse_func = pdf14_parse_hash;
9271 sort_by_digest = sort_by_digest_4_4;
9272 opti_type = OPTI_TYPE_ZERO_BYTE
9273 | OPTI_TYPE_NOT_ITERATED;
9274 dgst_pos0 = 0;
9275 dgst_pos1 = 1;
9276 dgst_pos2 = 2;
9277 dgst_pos3 = 3;
9278 break;
9279
9280 case 10600: hash_type = HASH_TYPE_SHA256;
9281 salt_type = SALT_TYPE_EMBEDDED;
9282 attack_exec = ATTACK_EXEC_ON_GPU;
9283 opts_type = OPTS_TYPE_PT_GENERATE_BE
9284 | OPTS_TYPE_ST_ADD80
9285 | OPTS_TYPE_ST_ADDBITS15
9286 | OPTS_TYPE_HASH_COPY;
9287 kern_type = KERN_TYPE_SHA256_PWSLT;
9288 dgst_size = DGST_SIZE_4_8;
9289 parse_func = pdf17l3_parse_hash;
9290 sort_by_digest = sort_by_digest_4_8;
9291 opti_type = OPTI_TYPE_ZERO_BYTE
9292 | OPTI_TYPE_PRECOMPUTE_INIT
9293 | OPTI_TYPE_PRECOMPUTE_MERKLE
9294 | OPTI_TYPE_EARLY_SKIP
9295 | OPTI_TYPE_NOT_ITERATED
9296 | OPTI_TYPE_APPENDED_SALT
9297 | OPTI_TYPE_RAW_HASH;
9298 dgst_pos0 = 3;
9299 dgst_pos1 = 7;
9300 dgst_pos2 = 2;
9301 dgst_pos3 = 6;
9302 break;
9303
9304 case 10700: hash_type = HASH_TYPE_PDFU32;
9305 salt_type = SALT_TYPE_EMBEDDED;
9306 attack_exec = ATTACK_EXEC_ON_CPU;
9307 opts_type = OPTS_TYPE_PT_GENERATE_LE
9308 | OPTS_TYPE_HASH_COPY;
9309 kern_type = KERN_TYPE_PDF17L8;
9310 dgst_size = DGST_SIZE_4_8;
9311 parse_func = pdf17l8_parse_hash;
9312 sort_by_digest = sort_by_digest_4_8;
9313 opti_type = OPTI_TYPE_ZERO_BYTE
9314 | OPTI_TYPE_NOT_ITERATED;
9315 dgst_pos0 = 0;
9316 dgst_pos1 = 1;
9317 dgst_pos2 = 2;
9318 dgst_pos3 = 3;
9319 break;
9320
9321 case 10800: hash_type = HASH_TYPE_SHA384;
9322 salt_type = SALT_TYPE_NONE;
9323 attack_exec = ATTACK_EXEC_ON_GPU;
9324 opts_type = OPTS_TYPE_PT_GENERATE_BE
9325 | OPTS_TYPE_PT_ADD80
9326 | OPTS_TYPE_PT_ADDBITS15;
9327 kern_type = KERN_TYPE_SHA384;
9328 dgst_size = DGST_SIZE_8_8;
9329 parse_func = sha384_parse_hash;
9330 sort_by_digest = sort_by_digest_8_8;
9331 opti_type = OPTI_TYPE_ZERO_BYTE
9332 | OPTI_TYPE_PRECOMPUTE_INIT
9333 | OPTI_TYPE_PRECOMPUTE_MERKLE
9334 | OPTI_TYPE_EARLY_SKIP
9335 | OPTI_TYPE_NOT_ITERATED
9336 | OPTI_TYPE_NOT_SALTED
9337 | OPTI_TYPE_RAW_HASH;
9338 dgst_pos0 = 6;
9339 dgst_pos1 = 7;
9340 dgst_pos2 = 4;
9341 dgst_pos3 = 5;
9342 break;
9343
9344 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9345 salt_type = SALT_TYPE_EMBEDDED;
9346 attack_exec = ATTACK_EXEC_ON_CPU;
9347 opts_type = OPTS_TYPE_PT_GENERATE_LE
9348 | OPTS_TYPE_ST_BASE64
9349 | OPTS_TYPE_HASH_COPY;
9350 kern_type = KERN_TYPE_PBKDF2_SHA256;
9351 dgst_size = DGST_SIZE_4_32;
9352 parse_func = pbkdf2_sha256_parse_hash;
9353 sort_by_digest = sort_by_digest_4_32;
9354 opti_type = OPTI_TYPE_ZERO_BYTE;
9355 dgst_pos0 = 0;
9356 dgst_pos1 = 1;
9357 dgst_pos2 = 2;
9358 dgst_pos3 = 3;
9359 break;
9360
9361 case 11000: hash_type = HASH_TYPE_MD5;
9362 salt_type = SALT_TYPE_INTERN;
9363 attack_exec = ATTACK_EXEC_ON_GPU;
9364 opts_type = OPTS_TYPE_PT_GENERATE_LE
9365 | OPTS_TYPE_PT_ADD80;
9366 kern_type = KERN_TYPE_PRESTASHOP;
9367 dgst_size = DGST_SIZE_4_4;
9368 parse_func = prestashop_parse_hash;
9369 sort_by_digest = sort_by_digest_4_4;
9370 opti_type = OPTI_TYPE_ZERO_BYTE
9371 | OPTI_TYPE_PRECOMPUTE_INIT
9372 | OPTI_TYPE_NOT_ITERATED
9373 | OPTI_TYPE_PREPENDED_SALT;
9374 dgst_pos0 = 0;
9375 dgst_pos1 = 3;
9376 dgst_pos2 = 2;
9377 dgst_pos3 = 1;
9378 break;
9379
9380 case 11100: hash_type = HASH_TYPE_MD5;
9381 salt_type = SALT_TYPE_EMBEDDED;
9382 attack_exec = ATTACK_EXEC_ON_GPU;
9383 opts_type = OPTS_TYPE_PT_GENERATE_LE
9384 | OPTS_TYPE_ST_ADD80;
9385 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9386 dgst_size = DGST_SIZE_4_4;
9387 parse_func = postgresql_auth_parse_hash;
9388 sort_by_digest = sort_by_digest_4_4;
9389 opti_type = OPTI_TYPE_ZERO_BYTE
9390 | OPTI_TYPE_PRECOMPUTE_INIT
9391 | OPTI_TYPE_PRECOMPUTE_MERKLE
9392 | OPTI_TYPE_EARLY_SKIP;
9393 dgst_pos0 = 0;
9394 dgst_pos1 = 3;
9395 dgst_pos2 = 2;
9396 dgst_pos3 = 1;
9397 break;
9398
9399 case 11200: hash_type = HASH_TYPE_SHA1;
9400 salt_type = SALT_TYPE_EMBEDDED;
9401 attack_exec = ATTACK_EXEC_ON_GPU;
9402 opts_type = OPTS_TYPE_PT_GENERATE_BE
9403 | OPTS_TYPE_PT_ADD80
9404 | OPTS_TYPE_ST_HEX;
9405 kern_type = KERN_TYPE_MYSQL_AUTH;
9406 dgst_size = DGST_SIZE_4_5;
9407 parse_func = mysql_auth_parse_hash;
9408 sort_by_digest = sort_by_digest_4_5;
9409 opti_type = OPTI_TYPE_ZERO_BYTE
9410 | OPTI_TYPE_EARLY_SKIP;
9411 dgst_pos0 = 3;
9412 dgst_pos1 = 4;
9413 dgst_pos2 = 2;
9414 dgst_pos3 = 1;
9415 break;
9416
9417 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9418 salt_type = SALT_TYPE_EMBEDDED;
9419 attack_exec = ATTACK_EXEC_ON_CPU;
9420 opts_type = OPTS_TYPE_PT_GENERATE_LE
9421 | OPTS_TYPE_ST_HEX
9422 | OPTS_TYPE_ST_ADD80;
9423 kern_type = KERN_TYPE_BITCOIN_WALLET;
9424 dgst_size = DGST_SIZE_4_4;
9425 parse_func = bitcoin_wallet_parse_hash;
9426 sort_by_digest = sort_by_digest_4_4;
9427 opti_type = OPTI_TYPE_ZERO_BYTE;
9428 dgst_pos0 = 0;
9429 dgst_pos1 = 1;
9430 dgst_pos2 = 2;
9431 dgst_pos3 = 3;
9432 break;
9433
9434 case 11400: hash_type = HASH_TYPE_MD5;
9435 salt_type = SALT_TYPE_EMBEDDED;
9436 attack_exec = ATTACK_EXEC_ON_GPU;
9437 opts_type = OPTS_TYPE_PT_GENERATE_LE
9438 | OPTS_TYPE_PT_ADD80
9439 | OPTS_TYPE_HASH_COPY;
9440 kern_type = KERN_TYPE_SIP_AUTH;
9441 dgst_size = DGST_SIZE_4_4;
9442 parse_func = sip_auth_parse_hash;
9443 sort_by_digest = sort_by_digest_4_4;
9444 opti_type = OPTI_TYPE_ZERO_BYTE;
9445 dgst_pos0 = 0;
9446 dgst_pos1 = 3;
9447 dgst_pos2 = 2;
9448 dgst_pos3 = 1;
9449 break;
9450
9451 case 11500: hash_type = HASH_TYPE_CRC32;
9452 salt_type = SALT_TYPE_INTERN;
9453 attack_exec = ATTACK_EXEC_ON_GPU;
9454 opts_type = OPTS_TYPE_PT_GENERATE_LE
9455 | OPTS_TYPE_ST_GENERATE_LE
9456 | OPTS_TYPE_ST_HEX;
9457 kern_type = KERN_TYPE_CRC32;
9458 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9459 parse_func = crc32_parse_hash;
9460 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9461 opti_type = OPTI_TYPE_ZERO_BYTE;
9462 dgst_pos0 = 0;
9463 dgst_pos1 = 1;
9464 dgst_pos2 = 2;
9465 dgst_pos3 = 3;
9466 break;
9467
9468 case 11600: hash_type = HASH_TYPE_AES;
9469 salt_type = SALT_TYPE_EMBEDDED;
9470 attack_exec = ATTACK_EXEC_ON_CPU;
9471 opts_type = OPTS_TYPE_PT_GENERATE_LE
9472 | OPTS_TYPE_PT_NEVERCRACK;
9473 kern_type = KERN_TYPE_SEVEN_ZIP;
9474 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9475 parse_func = seven_zip_parse_hash;
9476 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
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 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9485 salt_type = SALT_TYPE_NONE;
9486 attack_exec = ATTACK_EXEC_ON_GPU;
9487 opts_type = OPTS_TYPE_PT_GENERATE_LE
9488 | OPTS_TYPE_PT_ADD01;
9489 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9490 dgst_size = DGST_SIZE_4_8;
9491 parse_func = gost2012sbog_256_parse_hash;
9492 sort_by_digest = sort_by_digest_4_8;
9493 opti_type = OPTI_TYPE_ZERO_BYTE;
9494 dgst_pos0 = 0;
9495 dgst_pos1 = 1;
9496 dgst_pos2 = 2;
9497 dgst_pos3 = 3;
9498 break;
9499
9500 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9501 salt_type = SALT_TYPE_NONE;
9502 attack_exec = ATTACK_EXEC_ON_GPU;
9503 opts_type = OPTS_TYPE_PT_GENERATE_LE
9504 | OPTS_TYPE_PT_ADD01;
9505 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9506 dgst_size = DGST_SIZE_4_16;
9507 parse_func = gost2012sbog_512_parse_hash;
9508 sort_by_digest = sort_by_digest_4_16;
9509 opti_type = OPTI_TYPE_ZERO_BYTE;
9510 dgst_pos0 = 0;
9511 dgst_pos1 = 1;
9512 dgst_pos2 = 2;
9513 dgst_pos3 = 3;
9514 break;
9515
9516 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9517 salt_type = SALT_TYPE_EMBEDDED;
9518 attack_exec = ATTACK_EXEC_ON_CPU;
9519 opts_type = OPTS_TYPE_PT_GENERATE_LE
9520 | OPTS_TYPE_ST_BASE64
9521 | OPTS_TYPE_HASH_COPY;
9522 kern_type = KERN_TYPE_PBKDF2_MD5;
9523 dgst_size = DGST_SIZE_4_32;
9524 parse_func = pbkdf2_md5_parse_hash;
9525 sort_by_digest = sort_by_digest_4_32;
9526 opti_type = OPTI_TYPE_ZERO_BYTE;
9527 dgst_pos0 = 0;
9528 dgst_pos1 = 1;
9529 dgst_pos2 = 2;
9530 dgst_pos3 = 3;
9531 break;
9532
9533 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
9534 salt_type = SALT_TYPE_EMBEDDED;
9535 attack_exec = ATTACK_EXEC_ON_CPU;
9536 opts_type = OPTS_TYPE_PT_GENERATE_LE
9537 | OPTS_TYPE_ST_BASE64
9538 | OPTS_TYPE_HASH_COPY;
9539 kern_type = KERN_TYPE_PBKDF2_SHA1;
9540 dgst_size = DGST_SIZE_4_32;
9541 parse_func = pbkdf2_sha1_parse_hash;
9542 sort_by_digest = sort_by_digest_4_32;
9543 opti_type = OPTI_TYPE_ZERO_BYTE;
9544 dgst_pos0 = 0;
9545 dgst_pos1 = 1;
9546 dgst_pos2 = 2;
9547 dgst_pos3 = 3;
9548 break;
9549
9550 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
9551 salt_type = SALT_TYPE_EMBEDDED;
9552 attack_exec = ATTACK_EXEC_ON_CPU;
9553 opts_type = OPTS_TYPE_PT_GENERATE_LE
9554 | OPTS_TYPE_ST_BASE64
9555 | OPTS_TYPE_HASH_COPY;
9556 kern_type = KERN_TYPE_PBKDF2_SHA512;
9557 dgst_size = DGST_SIZE_8_16;
9558 parse_func = pbkdf2_sha512_parse_hash;
9559 sort_by_digest = sort_by_digest_8_16;
9560 opti_type = OPTI_TYPE_ZERO_BYTE;
9561 dgst_pos0 = 0;
9562 dgst_pos1 = 1;
9563 dgst_pos2 = 2;
9564 dgst_pos3 = 3;
9565 break;
9566
9567 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
9568 salt_type = SALT_TYPE_EMBEDDED;
9569 attack_exec = ATTACK_EXEC_ON_CPU;
9570 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9571 kern_type = KERN_TYPE_ECRYPTFS;
9572 dgst_size = DGST_SIZE_8_8;
9573 parse_func = ecryptfs_parse_hash;
9574 sort_by_digest = sort_by_digest_8_8;
9575 opti_type = OPTI_TYPE_ZERO_BYTE;
9576 dgst_pos0 = 0;
9577 dgst_pos1 = 1;
9578 dgst_pos2 = 2;
9579 dgst_pos3 = 3;
9580 break;
9581
9582 case 12300: hash_type = HASH_TYPE_ORACLET;
9583 salt_type = SALT_TYPE_EMBEDDED;
9584 attack_exec = ATTACK_EXEC_ON_CPU;
9585 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9586 kern_type = KERN_TYPE_ORACLET;
9587 dgst_size = DGST_SIZE_8_16;
9588 parse_func = oraclet_parse_hash;
9589 sort_by_digest = sort_by_digest_8_16;
9590 opti_type = OPTI_TYPE_ZERO_BYTE;
9591 dgst_pos0 = 0;
9592 dgst_pos1 = 1;
9593 dgst_pos2 = 2;
9594 dgst_pos3 = 3;
9595 break;
9596
9597 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
9598 salt_type = SALT_TYPE_EMBEDDED;
9599 attack_exec = ATTACK_EXEC_ON_CPU;
9600 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9601 kern_type = KERN_TYPE_BSDICRYPT;
9602 dgst_size = DGST_SIZE_4_4;
9603 parse_func = bsdicrypt_parse_hash;
9604 sort_by_digest = sort_by_digest_4_4;
9605 opti_type = OPTI_TYPE_ZERO_BYTE
9606 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9607 dgst_pos0 = 0;
9608 dgst_pos1 = 1;
9609 dgst_pos2 = 2;
9610 dgst_pos3 = 3;
9611 break;
9612
9613 case 12500: hash_type = HASH_TYPE_RAR3HP;
9614 salt_type = SALT_TYPE_EMBEDDED;
9615 attack_exec = ATTACK_EXEC_ON_CPU;
9616 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9617 kern_type = KERN_TYPE_RAR3;
9618 dgst_size = DGST_SIZE_4_4;
9619 parse_func = rar3hp_parse_hash;
9620 sort_by_digest = sort_by_digest_4_4;
9621 opti_type = OPTI_TYPE_ZERO_BYTE;
9622 dgst_pos0 = 0;
9623 dgst_pos1 = 1;
9624 dgst_pos2 = 2;
9625 dgst_pos3 = 3;
9626 break;
9627
9628 case 12600: hash_type = HASH_TYPE_SHA256;
9629 salt_type = SALT_TYPE_INTERN;
9630 attack_exec = ATTACK_EXEC_ON_GPU;
9631 opts_type = OPTS_TYPE_PT_GENERATE_BE
9632 | OPTS_TYPE_PT_ADD80;
9633 kern_type = KERN_TYPE_CF10;
9634 dgst_size = DGST_SIZE_4_8;
9635 parse_func = cf10_parse_hash;
9636 sort_by_digest = sort_by_digest_4_8;
9637 opti_type = OPTI_TYPE_ZERO_BYTE
9638 | OPTI_TYPE_PRECOMPUTE_INIT
9639 | OPTI_TYPE_EARLY_SKIP
9640 | OPTI_TYPE_NOT_ITERATED;
9641 dgst_pos0 = 3;
9642 dgst_pos1 = 7;
9643 dgst_pos2 = 2;
9644 dgst_pos3 = 6;
9645 break;
9646
9647 case 12700: hash_type = HASH_TYPE_AES;
9648 salt_type = SALT_TYPE_EMBEDDED;
9649 attack_exec = ATTACK_EXEC_ON_CPU;
9650 opts_type = OPTS_TYPE_PT_GENERATE_LE
9651 | OPTS_TYPE_HASH_COPY;
9652 kern_type = KERN_TYPE_MYWALLET;
9653 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9654 parse_func = mywallet_parse_hash;
9655 sort_by_digest = sort_by_digest_4_5;
9656 opti_type = OPTI_TYPE_ZERO_BYTE;
9657 dgst_pos0 = 0;
9658 dgst_pos1 = 1;
9659 dgst_pos2 = 2;
9660 dgst_pos3 = 3;
9661 break;
9662
9663 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
9664 salt_type = SALT_TYPE_EMBEDDED;
9665 attack_exec = ATTACK_EXEC_ON_CPU;
9666 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9667 kern_type = KERN_TYPE_MS_DRSR;
9668 dgst_size = DGST_SIZE_4_8;
9669 parse_func = ms_drsr_parse_hash;
9670 sort_by_digest = sort_by_digest_4_8;
9671 opti_type = OPTI_TYPE_ZERO_BYTE;
9672 dgst_pos0 = 0;
9673 dgst_pos1 = 1;
9674 dgst_pos2 = 2;
9675 dgst_pos3 = 3;
9676 break;
9677
9678 default: usage_mini_print (PROGNAME); return (-1);
9679 }
9680
9681 /**
9682 * transpose
9683 */
9684
9685 data.parse_func = parse_func;
9686
9687 /**
9688 * misc stuff
9689 */
9690
9691 if (hex_salt)
9692 {
9693 if (salt_type == SALT_TYPE_INTERN)
9694 {
9695 opts_type |= OPTS_TYPE_ST_HEX;
9696 }
9697 else
9698 {
9699 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
9700
9701 return (-1);
9702 }
9703 }
9704
9705 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
9706 | (salt_type == SALT_TYPE_EXTERN)
9707 | (salt_type == SALT_TYPE_EMBEDDED)
9708 | (salt_type == SALT_TYPE_VIRTUAL));
9709
9710 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
9711
9712 data.hash_type = hash_type;
9713 data.attack_mode = attack_mode;
9714 data.attack_kern = attack_kern;
9715 data.attack_exec = attack_exec;
9716 data.kern_type = kern_type;
9717 data.opts_type = opts_type;
9718 data.dgst_size = dgst_size;
9719 data.salt_type = salt_type;
9720 data.isSalted = isSalted;
9721 data.sort_by_digest = sort_by_digest;
9722 data.dgst_pos0 = dgst_pos0;
9723 data.dgst_pos1 = dgst_pos1;
9724 data.dgst_pos2 = dgst_pos2;
9725 data.dgst_pos3 = dgst_pos3;
9726
9727 esalt_size = 0;
9728
9729 switch (hash_mode)
9730 {
9731 case 2500: esalt_size = sizeof (wpa_t); break;
9732 case 5300: esalt_size = sizeof (ikepsk_t); break;
9733 case 5400: esalt_size = sizeof (ikepsk_t); break;
9734 case 5500: esalt_size = sizeof (netntlm_t); break;
9735 case 5600: esalt_size = sizeof (netntlm_t); break;
9736 case 6211:
9737 case 6212:
9738 case 6213:
9739 case 6221:
9740 case 6222:
9741 case 6223:
9742 case 6231:
9743 case 6232:
9744 case 6233:
9745 case 6241:
9746 case 6242:
9747 case 6243: esalt_size = sizeof (tc_t); break;
9748 case 6600: esalt_size = sizeof (agilekey_t); break;
9749 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
9750 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
9751 case 7300: esalt_size = sizeof (rakp_t); break;
9752 case 7500: esalt_size = sizeof (krb5pa_t); break;
9753 case 8200: esalt_size = sizeof (cloudkey_t); break;
9754 case 8800: esalt_size = sizeof (androidfde_t); break;
9755 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
9756 case 9400: esalt_size = sizeof (office2007_t); break;
9757 case 9500: esalt_size = sizeof (office2010_t); break;
9758 case 9600: esalt_size = sizeof (office2013_t); break;
9759 case 9700: esalt_size = sizeof (oldoffice01_t); break;
9760 case 9710: esalt_size = sizeof (oldoffice01_t); break;
9761 case 9720: esalt_size = sizeof (oldoffice01_t); break;
9762 case 9800: esalt_size = sizeof (oldoffice34_t); break;
9763 case 9810: esalt_size = sizeof (oldoffice34_t); break;
9764 case 9820: esalt_size = sizeof (oldoffice34_t); break;
9765 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
9766 case 10200: esalt_size = sizeof (cram_md5_t); break;
9767 case 10400: esalt_size = sizeof (pdf_t); break;
9768 case 10410: esalt_size = sizeof (pdf_t); break;
9769 case 10420: esalt_size = sizeof (pdf_t); break;
9770 case 10500: esalt_size = sizeof (pdf_t); break;
9771 case 10600: esalt_size = sizeof (pdf_t); break;
9772 case 10700: esalt_size = sizeof (pdf_t); break;
9773 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
9774 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
9775 case 11400: esalt_size = sizeof (sip_t); break;
9776 case 11600: esalt_size = sizeof (seven_zip_t); break;
9777 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
9778 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
9779 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
9780 }
9781
9782 data.esalt_size = esalt_size;
9783
9784 /**
9785 * choose dictionary parser
9786 */
9787
9788 if (hash_type == HASH_TYPE_LM)
9789 {
9790 get_next_word_func = get_next_word_lm;
9791 }
9792 else if (opts_type & OPTS_TYPE_PT_UPPER)
9793 {
9794 get_next_word_func = get_next_word_uc;
9795 }
9796 else
9797 {
9798 get_next_word_func = get_next_word_std;
9799 }
9800
9801 /**
9802 * dictstat
9803 */
9804
9805 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
9806
9807 #ifdef _POSIX
9808 size_t dictstat_nmemb = 0;
9809 #endif
9810
9811 #ifdef _WIN
9812 uint dictstat_nmemb = 0;
9813 #endif
9814
9815 char dictstat[256];
9816
9817 FILE *dictstat_fp = NULL;
9818
9819 if (keyspace == 0)
9820 {
9821 memset (dictstat, 0, sizeof (dictstat));
9822
9823 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s.dictstat", install_dir, PROGNAME);
9824
9825 dictstat_fp = fopen (dictstat, "rb");
9826
9827 if (dictstat_fp)
9828 {
9829 #ifdef _POSIX
9830 struct stat tmpstat;
9831
9832 fstat (fileno (dictstat_fp), &tmpstat);
9833 #endif
9834
9835 #ifdef _WIN
9836 struct stat64 tmpstat;
9837
9838 _fstat64 (fileno (dictstat_fp), &tmpstat);
9839 #endif
9840
9841 if (tmpstat.st_mtime < COMPTIME)
9842 {
9843 /* with v0.15 the format changed so we have to ensure user is using a good version
9844 since there is no version-header in the dictstat file */
9845
9846 fclose (dictstat_fp);
9847
9848 unlink (dictstat);
9849 }
9850 else
9851 {
9852 while (!feof (dictstat_fp))
9853 {
9854 dictstat_t d;
9855
9856 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
9857
9858 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
9859
9860 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
9861 {
9862 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
9863
9864 return -1;
9865 }
9866 }
9867
9868 fclose (dictstat_fp);
9869 }
9870 }
9871 }
9872
9873 /**
9874 * potfile
9875 */
9876
9877 char potfile[256];
9878
9879 memset (potfile, 0, sizeof (potfile));
9880
9881 snprintf (potfile, sizeof (potfile) - 1, "%s.pot", session);
9882
9883 data.pot_fp = NULL;
9884
9885 FILE *out_fp = NULL;
9886 FILE *pot_fp = NULL;
9887
9888 if (show == 1 || left == 1)
9889 {
9890 pot_fp = fopen (potfile, "rb");
9891
9892 if (pot_fp == NULL)
9893 {
9894 log_error ("ERROR: %s: %s", potfile, strerror (errno));
9895
9896 return (-1);
9897 }
9898
9899 if (outfile != NULL)
9900 {
9901 if ((out_fp = fopen (outfile, "ab")) == NULL)
9902 {
9903 log_error ("ERROR: %s: %s", outfile, strerror (errno));
9904
9905 fclose (pot_fp);
9906
9907 return (-1);
9908 }
9909 }
9910 else
9911 {
9912 out_fp = stdout;
9913 }
9914 }
9915 else
9916 {
9917 if (potfile_disable == 0)
9918 {
9919 pot_fp = fopen (potfile, "ab");
9920
9921 if (pot_fp == NULL)
9922 {
9923 log_error ("ERROR: %s: %s", potfile, strerror (errno));
9924
9925 return (-1);
9926 }
9927
9928 data.pot_fp = pot_fp;
9929 }
9930 }
9931
9932 pot_t *pot = NULL;
9933
9934 uint pot_cnt = 0;
9935 uint pot_avail = 0;
9936
9937 if (show == 1 || left == 1)
9938 {
9939 SUPPRESS_OUTPUT = 1;
9940
9941 pot_avail = count_lines (pot_fp);
9942
9943 rewind (pot_fp);
9944
9945 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
9946
9947 uint pot_hashes_avail = 0;
9948
9949 uint line_num = 0;
9950
9951 while (!feof (pot_fp))
9952 {
9953 line_num++;
9954
9955 char line_buf[BUFSIZ];
9956
9957 int line_len = fgetl (pot_fp, line_buf);
9958
9959 if (line_len == 0) continue;
9960
9961 char *plain_buf = line_buf + line_len;
9962
9963 pot_t *pot_ptr = &pot[pot_cnt];
9964
9965 hash_t *hashes_buf = &pot_ptr->hash;
9966
9967 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
9968 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
9969
9970 if (pot_cnt == pot_hashes_avail)
9971 {
9972 uint pos = 0;
9973
9974 for (pos = 0; pos < INCR_POT; pos++)
9975 {
9976 if ((pot_cnt + pos) >= pot_avail) break;
9977
9978 pot_t *tmp_pot = &pot[pot_cnt + pos];
9979
9980 hash_t *tmp_hash = &tmp_pot->hash;
9981
9982 tmp_hash->digest = mymalloc (dgst_size);
9983
9984 if (isSalted)
9985 {
9986 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
9987 }
9988
9989 if (esalt_size)
9990 {
9991 tmp_hash->esalt = mymalloc (esalt_size);
9992 }
9993
9994 pot_hashes_avail++;
9995 }
9996 }
9997
9998 int plain_len = 0;
9999
10000 int parser_status;
10001
10002 int iter = MAX_CUT_TRIES;
10003
10004 do
10005 {
10006 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10007 {
10008 if (line_buf[i] == ':')
10009 {
10010 line_len--;
10011
10012 break;
10013 }
10014 }
10015
10016 if (data.hash_mode != 2500)
10017 {
10018 parser_status = parse_func (line_buf, line_len, hashes_buf);
10019 }
10020 else
10021 {
10022 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10023
10024 if (line_len > max_salt_size)
10025 {
10026 parser_status = PARSER_GLOBAL_LENGTH;
10027 }
10028 else
10029 {
10030 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10031
10032 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10033
10034 hashes_buf->salt->salt_len = line_len;
10035
10036 parser_status = PARSER_OK;
10037 }
10038 }
10039
10040 // if NOT parsed without error, we add the ":" to the plain
10041
10042 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10043 {
10044 plain_len++;
10045 plain_buf--;
10046 }
10047
10048 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10049
10050 if (parser_status < PARSER_GLOBAL_ZERO)
10051 {
10052 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10053
10054 continue;
10055 }
10056
10057 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10058
10059 pot_ptr->plain_len = plain_len;
10060
10061 pot_cnt++;
10062 }
10063
10064 fclose (pot_fp);
10065
10066 SUPPRESS_OUTPUT = 0;
10067
10068 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10069 }
10070
10071 /**
10072 * gpu accel and loops auto adjustment
10073 */
10074
10075 if (gpu_accel_chgd == 0) gpu_accel = set_gpu_accel (hash_mode);
10076 if (gpu_loops_chgd == 0) gpu_loops = set_gpu_loops (hash_mode);
10077
10078 if (workload_profile == 1)
10079 {
10080 gpu_loops /= 8;
10081 gpu_accel /= 4;
10082
10083 if (gpu_loops == 0) gpu_loops = 8;
10084 if (gpu_accel == 0) gpu_accel = 2;
10085 }
10086 else if (workload_profile == 3)
10087 {
10088 gpu_loops *= 8;
10089 gpu_accel *= 4;
10090
10091 if (gpu_loops > 1024) gpu_loops = 1024;
10092 if (gpu_accel > 256) gpu_accel = 256; // causes memory problems otherwise
10093 }
10094
10095 // those hashes *must* run at a specific gpu_loops count because of some optimization inside the kernel
10096
10097 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
10098 {
10099 gpu_loops = 1024;
10100 }
10101
10102 if (hash_mode == 12500)
10103 {
10104 gpu_loops = ROUNDS_RAR3 / 16;
10105 }
10106
10107 data.gpu_accel = gpu_accel;
10108 data.gpu_loops = gpu_loops;
10109
10110 /**
10111 * word len
10112 */
10113
10114 uint pw_min = PW_MIN;
10115 uint pw_max = PW_MAX;
10116
10117 switch (hash_mode)
10118 {
10119 case 400: if (pw_max > 40) pw_max = 40;
10120 break;
10121 case 500: if (pw_max > 16) pw_max = 16;
10122 break;
10123 case 1500: if (pw_max > 8) pw_max = 8;
10124 break;
10125 case 1600: if (pw_max > 16) pw_max = 16;
10126 break;
10127 case 1800: if (pw_max > 16) pw_max = 16;
10128 break;
10129 case 2100: if (pw_max > 16) pw_max = 16;
10130 break;
10131 case 2500: if (pw_min < 8) pw_min = 8;
10132 break;
10133 case 3000: if (pw_max > 7) pw_max = 7;
10134 break;
10135 case 5200: if (pw_max > 24) pw_max = 24;
10136 break;
10137 case 5800: if (pw_max > 16) pw_max = 16;
10138 break;
10139 case 6300: if (pw_max > 16) pw_max = 16;
10140 break;
10141 case 7400: if (pw_max > 16) pw_max = 16;
10142 break;
10143 case 7900: if (pw_max > 48) pw_max = 48;
10144 break;
10145 case 8500: if (pw_max > 8) pw_max = 8;
10146 break;
10147 case 8600: if (pw_max > 16) pw_max = 16;
10148 break;
10149 case 9710: pw_min = 5;
10150 pw_max = 5;
10151 break;
10152 case 9810: pw_min = 5;
10153 pw_max = 5;
10154 break;
10155 case 10410: pw_min = 5;
10156 pw_max = 5;
10157 break;
10158 case 10300: if (pw_max < 3) pw_min = 3;
10159 if (pw_max > 40) pw_max = 40;
10160 break;
10161 case 10500: if (pw_max < 3) pw_min = 3;
10162 if (pw_max > 40) pw_max = 40;
10163 break;
10164 case 10700: if (pw_max > 16) pw_max = 16;
10165 break;
10166 case 11300: if (pw_max > 40) pw_max = 40;
10167 break;
10168 case 12500: if (pw_max > 20) pw_max = 20;
10169 break;
10170 case 12800: if (pw_max > 24) pw_max = 24;
10171 break;
10172 }
10173
10174 if (attack_exec == ATTACK_EXEC_ON_GPU)
10175 {
10176 switch (attack_kern)
10177 {
10178 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10179 break;
10180 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10181 break;
10182 }
10183 }
10184
10185 /**
10186 * charsets : keep them together for more easy maintainnce
10187 */
10188
10189 cs_t mp_sys[6];
10190 cs_t mp_usr[4];
10191
10192 memset (mp_sys, 0, sizeof (mp_sys));
10193 memset (mp_usr, 0, sizeof (mp_usr));
10194
10195 mp_setup_sys (mp_sys);
10196
10197 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10198 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10199 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10200 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10201
10202 /**
10203 * load hashes, part I: find input mode, count hashes
10204 */
10205
10206 uint hashlist_mode = 0;
10207 uint hashlist_format = HLFMT_HASHCAT;
10208
10209 uint hashes_avail = 0;
10210
10211 if (benchmark == 0)
10212 {
10213 struct stat f;
10214
10215 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10216
10217 if ((hash_mode == 2500) ||
10218 (hash_mode == 5200) ||
10219 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10220 (hash_mode == 9000))
10221 {
10222 hashlist_mode = HL_MODE_ARG;
10223
10224 char *hashfile = myargv[optind];
10225
10226 data.hashfile = hashfile;
10227
10228 logfile_top_var_string ("target", hashfile);
10229 }
10230
10231 if (hashlist_mode == HL_MODE_ARG)
10232 {
10233 if (hash_mode == 2500)
10234 {
10235 struct stat st;
10236
10237 if (stat (data.hashfile, &st) == -1)
10238 {
10239 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10240
10241 return (-1);
10242 }
10243
10244 hashes_avail = st.st_size / sizeof (hccap_t);
10245 }
10246 else
10247 {
10248 hashes_avail = 1;
10249 }
10250 }
10251 else if (hashlist_mode == HL_MODE_FILE)
10252 {
10253 char *hashfile = myargv[optind];
10254
10255 data.hashfile = hashfile;
10256
10257 logfile_top_var_string ("target", hashfile);
10258
10259 FILE *fp = NULL;
10260
10261 if ((fp = fopen (hashfile, "rb")) == NULL)
10262 {
10263 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10264
10265 return (-1);
10266 }
10267
10268 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10269
10270 hashes_avail = count_lines (fp);
10271
10272 rewind (fp);
10273
10274 if (hashes_avail == 0)
10275 {
10276 log_error ("ERROR: hashfile is empty or corrupt");
10277
10278 fclose (fp);
10279
10280 return (-1);
10281 }
10282
10283 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10284
10285 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10286 {
10287 log_error ("ERROR: remove not supported in native hashfile-format mode");
10288
10289 fclose (fp);
10290
10291 return (-1);
10292 }
10293
10294 fclose (fp);
10295 }
10296 }
10297 else
10298 {
10299 hashlist_mode = HL_MODE_ARG;
10300
10301 hashes_avail = 1;
10302 }
10303
10304 if (hash_mode == 3000) hashes_avail *= 2;
10305
10306 data.hashlist_mode = hashlist_mode;
10307 data.hashlist_format = hashlist_format;
10308
10309 logfile_top_uint (hashlist_mode);
10310 logfile_top_uint (hashlist_format);
10311
10312 /**
10313 * load hashes, part II: allocate required memory, set pointers
10314 */
10315
10316 hash_t *hashes_buf = NULL;
10317 void *digests_buf = NULL;
10318 salt_t *salts_buf = NULL;
10319 void *esalts_buf = NULL;
10320
10321 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10322
10323 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10324
10325 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10326 {
10327 uint32_t hash_pos;
10328
10329 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10330 {
10331 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10332
10333 hashes_buf[hash_pos].hash_info = hash_info;
10334
10335 if (username && (remove || show || left))
10336 {
10337 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10338 }
10339
10340 if (benchmark)
10341 {
10342 hash_info->orighash = (char *) mymalloc (256);
10343 }
10344 }
10345 }
10346
10347 if (isSalted)
10348 {
10349 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10350
10351 if (esalt_size)
10352 {
10353 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10354 }
10355 }
10356 else
10357 {
10358 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10359 }
10360
10361 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10362 {
10363 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10364
10365 if (isSalted)
10366 {
10367 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10368
10369 if (esalt_size)
10370 {
10371 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10372 }
10373 }
10374 else
10375 {
10376 hashes_buf[hash_pos].salt = &salts_buf[0];
10377 }
10378 }
10379
10380 /**
10381 * load hashes, part III: parse hashes or generate them if benchmark
10382 */
10383
10384 uint hashes_cnt = 0;
10385
10386 if (benchmark == 0)
10387 {
10388 if (keyspace == 1)
10389 {
10390 // useless to read hash file for keyspace, cheat a little bit w/ optind
10391 }
10392 else if (hashes_avail == 0)
10393 {
10394 }
10395 else if (hashlist_mode == HL_MODE_ARG)
10396 {
10397 char *input_buf = myargv[optind];
10398
10399 uint input_len = strlen (input_buf);
10400
10401 logfile_top_var_string ("target", input_buf);
10402
10403 char *hash_buf = NULL;
10404 int hash_len = 0;
10405
10406 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10407
10408 if (hash_len)
10409 {
10410 if (opts_type & OPTS_TYPE_HASH_COPY)
10411 {
10412 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10413
10414 hash_info_tmp->orighash = mystrdup (hash_buf);
10415 }
10416
10417 if (isSalted)
10418 {
10419 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10420 }
10421
10422 int parser_status = PARSER_OK;
10423
10424 if (hash_mode == 2500)
10425 {
10426 if (hash_len == 0)
10427 {
10428 log_error ("ERROR: hccap file not specified");
10429
10430 return (-1);
10431 }
10432
10433 hashlist_mode = HL_MODE_FILE;
10434
10435 data.hashlist_mode = hashlist_mode;
10436
10437 FILE *fp = fopen (hash_buf, "rb");
10438
10439 if (fp == NULL)
10440 {
10441 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10442
10443 return (-1);
10444 }
10445
10446 if (hashes_avail < 1)
10447 {
10448 log_error ("ERROR: hccap file is empty or corrupt");
10449
10450 fclose (fp);
10451
10452 return (-1);
10453 }
10454
10455 uint hccap_size = sizeof (hccap_t);
10456
10457 char in[hccap_size];
10458
10459 while (!feof (fp))
10460 {
10461 int n = fread (&in, hccap_size, 1, fp);
10462
10463 if (n != 1)
10464 {
10465 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
10466
10467 break;
10468 }
10469
10470 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
10471
10472 if (parser_status != PARSER_OK)
10473 {
10474 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
10475
10476 continue;
10477 }
10478
10479 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
10480
10481 if ((show == 1) || (left == 1))
10482 {
10483 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
10484
10485 char *salt_ptr = (char *) tmp_salt->salt_buf;
10486
10487 int cur_pos = tmp_salt->salt_len;
10488 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10489
10490 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
10491
10492 unsigned char *pke_ptr = (unsigned char *) wpa->pke;
10493
10494 // do the appending task
10495
10496 snprintf (salt_ptr + cur_pos,
10497 rem_len,
10498 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
10499 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
10500 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
10501
10502
10503 // memset () the remaining part of the salt
10504
10505 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
10506 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10507
10508 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
10509
10510 tmp_salt->salt_len += 1 + 12 + 1 + 12;
10511 }
10512
10513 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);
10514 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);
10515
10516 hashes_cnt++;
10517 }
10518
10519 fclose (fp);
10520 }
10521 else if (hash_mode == 3000)
10522 {
10523 if (hash_len == 32)
10524 {
10525 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10526
10527 hash_t *lm_hash_left = NULL;
10528
10529 if (parser_status == PARSER_OK)
10530 {
10531 lm_hash_left = &hashes_buf[hashes_cnt];
10532
10533 hashes_cnt++;
10534 }
10535 else
10536 {
10537 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10538 }
10539
10540
10541 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10542
10543 hash_t *lm_hash_right = NULL;
10544
10545 if (parser_status == PARSER_OK)
10546 {
10547 lm_hash_right = &hashes_buf[hashes_cnt];
10548
10549 hashes_cnt++;
10550 }
10551 else
10552 {
10553 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10554 }
10555
10556 // show / left
10557
10558 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
10559 {
10560 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);
10561 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);
10562 }
10563 }
10564 else
10565 {
10566 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10567
10568 if (parser_status == PARSER_OK)
10569 {
10570 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10571 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10572 }
10573
10574 if (parser_status == PARSER_OK)
10575 {
10576 hashes_cnt++;
10577 }
10578 else
10579 {
10580 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10581 }
10582 }
10583 }
10584 else
10585 {
10586 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10587
10588 if (parser_status == PARSER_OK)
10589 {
10590 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10591 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10592 }
10593
10594 if (parser_status == PARSER_OK)
10595 {
10596 hashes_cnt++;
10597 }
10598 else
10599 {
10600 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10601 }
10602 }
10603 }
10604 }
10605 else if (hashlist_mode == HL_MODE_FILE)
10606 {
10607 char *hashfile = data.hashfile;
10608
10609 FILE *fp;
10610
10611 if ((fp = fopen (hashfile, "rb")) == NULL)
10612 {
10613 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10614
10615 return (-1);
10616 }
10617
10618 uint line_num = 0;
10619
10620 while (!feof (fp))
10621 {
10622 line_num++;
10623
10624 char line_buf[BUFSIZ];
10625
10626 int line_len = fgetl (fp, line_buf);
10627
10628 if (line_len == 0) continue;
10629
10630 char *hash_buf = NULL;
10631 int hash_len = 0;
10632
10633 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
10634
10635 if (username)
10636 {
10637 char *user_buf = NULL;
10638 int user_len = 0;
10639
10640 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
10641
10642 if (remove || show)
10643 {
10644 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
10645
10646 *user = (user_t *) malloc (sizeof (user_t));
10647
10648 user_t *user_ptr = *user;
10649
10650 if (user_buf != NULL)
10651 {
10652 user_ptr->user_name = mystrdup (user_buf);
10653 }
10654 else
10655 {
10656 user_ptr->user_name = mystrdup ("");
10657 }
10658
10659 user_ptr->user_len = user_len;
10660 }
10661 }
10662
10663 if (opts_type & OPTS_TYPE_HASH_COPY)
10664 {
10665 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10666
10667 hash_info_tmp->orighash = mystrdup (hash_buf);
10668 }
10669
10670 if (isSalted)
10671 {
10672 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
10673 }
10674
10675 if (hash_mode == 3000)
10676 {
10677 if (hash_len == 32)
10678 {
10679 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10680
10681 if (parser_status < PARSER_GLOBAL_ZERO)
10682 {
10683 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10684
10685 continue;
10686 }
10687
10688 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
10689
10690 hashes_cnt++;
10691
10692 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10693
10694 if (parser_status < PARSER_GLOBAL_ZERO)
10695 {
10696 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10697
10698 continue;
10699 }
10700
10701 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
10702
10703 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);
10704
10705 hashes_cnt++;
10706
10707 // show / left
10708
10709 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);
10710 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);
10711 }
10712 else
10713 {
10714 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10715
10716 if (parser_status < PARSER_GLOBAL_ZERO)
10717 {
10718 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10719
10720 continue;
10721 }
10722
10723 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);
10724
10725 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10726 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10727
10728 hashes_cnt++;
10729 }
10730 }
10731 else
10732 {
10733 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10734
10735 if (parser_status < PARSER_GLOBAL_ZERO)
10736 {
10737 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10738
10739 continue;
10740 }
10741
10742 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);
10743
10744 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10745 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10746
10747 hashes_cnt++;
10748 }
10749 }
10750
10751 fclose (fp);
10752
10753 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
10754
10755 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
10756 }
10757 }
10758 else
10759 {
10760 if (isSalted)
10761 {
10762 hashes_buf[0].salt->salt_len = 8;
10763
10764 // special salt handling
10765
10766 switch (hash_mode)
10767 {
10768 case 1500: hashes_buf[0].salt->salt_len = 2;
10769 break;
10770 case 1731: hashes_buf[0].salt->salt_len = 4;
10771 break;
10772 case 2410: hashes_buf[0].salt->salt_len = 4;
10773 break;
10774 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
10775 break;
10776 case 3100: hashes_buf[0].salt->salt_len = 1;
10777 break;
10778 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
10779 break;
10780 case 5800: hashes_buf[0].salt->salt_len = 16;
10781 break;
10782 case 6800: hashes_buf[0].salt->salt_len = 32;
10783 break;
10784 case 8400: hashes_buf[0].salt->salt_len = 40;
10785 break;
10786 case 8800: hashes_buf[0].salt->salt_len = 16;
10787 break;
10788 case 8900: hashes_buf[0].salt->salt_len = 16;
10789 hashes_buf[0].salt->scrypt_N = 1024;
10790 hashes_buf[0].salt->scrypt_r = 1;
10791 hashes_buf[0].salt->scrypt_p = 1;
10792 break;
10793 case 9100: hashes_buf[0].salt->salt_len = 16;
10794 break;
10795 case 9300: hashes_buf[0].salt->salt_len = 14;
10796 hashes_buf[0].salt->scrypt_N = 16384;
10797 hashes_buf[0].salt->scrypt_r = 1;
10798 hashes_buf[0].salt->scrypt_p = 1;
10799 break;
10800 case 9400: hashes_buf[0].salt->salt_len = 16;
10801 break;
10802 case 9500: hashes_buf[0].salt->salt_len = 16;
10803 break;
10804 case 9600: hashes_buf[0].salt->salt_len = 16;
10805 break;
10806 case 9700: hashes_buf[0].salt->salt_len = 16;
10807 break;
10808 case 9710: hashes_buf[0].salt->salt_len = 16;
10809 break;
10810 case 9720: hashes_buf[0].salt->salt_len = 16;
10811 break;
10812 case 9800: hashes_buf[0].salt->salt_len = 16;
10813 break;
10814 case 9810: hashes_buf[0].salt->salt_len = 16;
10815 break;
10816 case 9820: hashes_buf[0].salt->salt_len = 16;
10817 break;
10818 case 10300: hashes_buf[0].salt->salt_len = 12;
10819 break;
10820 case 11500: hashes_buf[0].salt->salt_len = 4;
10821 break;
10822 case 11600: hashes_buf[0].salt->salt_len = 4;
10823 break;
10824 case 12400: hashes_buf[0].salt->salt_len = 4;
10825 break;
10826 case 12500: hashes_buf[0].salt->salt_len = 8;
10827 break;
10828 case 12600: hashes_buf[0].salt->salt_len = 64;
10829 break;
10830 }
10831
10832 // special esalt handling
10833
10834 switch (hash_mode)
10835 {
10836 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
10837 break;
10838 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
10839 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
10840 break;
10841 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
10842 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
10843 break;
10844 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
10845 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
10846 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
10847 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
10848 break;
10849 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
10850 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
10851 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
10852 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
10853 break;
10854 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
10855 break;
10856 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10857 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
10858 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
10859 break;
10860 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10861 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
10862 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
10863 break;
10864 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10865 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
10866 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
10867 break;
10868 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10869 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
10870 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
10871 break;
10872 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10873 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
10874 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
10875 break;
10876 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10877 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
10878 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
10879 break;
10880 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
10881 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
10882 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
10883 break;
10884 }
10885 }
10886
10887 // set hashfile
10888
10889 switch (hash_mode)
10890 {
10891 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
10892 break;
10893 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
10894 break;
10895 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
10896 break;
10897 case 6211:
10898 case 6212:
10899 case 6213:
10900 case 6221:
10901 case 6222:
10902 case 6223:
10903 case 6231:
10904 case 6232:
10905 case 6233:
10906 case 6241:
10907 case 6242:
10908 case 6243: data.hashfile = mystrdup ("hashcat.tc");
10909 break;
10910 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
10911 break;
10912 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
10913 break;
10914 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
10915 break;
10916 }
10917
10918 // set default iterations
10919
10920 switch (hash_mode)
10921 {
10922 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
10923 break;
10924 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
10925 break;
10926 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
10927 break;
10928 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
10929 break;
10930 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
10931 break;
10932 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
10933 break;
10934 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
10935 break;
10936 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
10937 break;
10938 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
10939 break;
10940 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
10941 break;
10942 case 6211:
10943 case 6212:
10944 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
10945 break;
10946 case 6221:
10947 case 6222:
10948 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
10949 break;
10950 case 6231:
10951 case 6232:
10952 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
10953 break;
10954 case 6241:
10955 case 6242:
10956 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
10957 break;
10958 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
10959 break;
10960 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
10961 break;
10962 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
10963 break;
10964 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
10965 break;
10966 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
10967 break;
10968 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
10969 break;
10970 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
10971 break;
10972 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
10973 break;
10974 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
10975 break;
10976 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
10977 break;
10978 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
10979 break;
10980 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
10981 break;
10982 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
10983 break;
10984 case 8900: hashes_buf[0].salt->salt_iter = 1;
10985 break;
10986 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
10987 break;
10988 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
10989 break;
10990 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
10991 break;
10992 case 9300: hashes_buf[0].salt->salt_iter = 1;
10993 break;
10994 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
10995 break;
10996 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
10997 break;
10998 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
10999 break;
11000 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11001 break;
11002 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11003 break;
11004 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11005 break;
11006 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11007 break;
11008 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11009 break;
11010 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11011 break;
11012 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11013 break;
11014 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11015 break;
11016 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11017 break;
11018 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11019 break;
11020 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11021 break;
11022 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11023 break;
11024 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11025 break;
11026 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11027 break;
11028 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11029 break;
11030 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11031 break;
11032 }
11033
11034 // set special tuning for benchmark-mode 1
11035
11036 if (benchmark_mode == 1)
11037 {
11038 gpu_loops *= 8;
11039 gpu_accel *= 4;
11040
11041 switch (hash_mode)
11042 {
11043 case 400: gpu_loops = ROUNDS_PHPASS;
11044 gpu_accel = 32;
11045 break;
11046 case 500: gpu_loops = ROUNDS_MD5CRYPT;
11047 gpu_accel = 32;
11048 break;
11049 case 501: gpu_loops = ROUNDS_MD5CRYPT;
11050 gpu_accel = 32;
11051 break;
11052 case 1600: gpu_loops = ROUNDS_MD5CRYPT;
11053 gpu_accel = 32;
11054 break;
11055 case 1800: gpu_loops = ROUNDS_SHA512CRYPT;
11056 gpu_accel = 8;
11057 break;
11058 case 2100: gpu_loops = ROUNDS_DCC2;
11059 gpu_accel = 16;
11060 break;
11061 case 2500: gpu_loops = ROUNDS_WPA2;
11062 gpu_accel = 32;
11063 break;
11064 case 3200: gpu_loops = ROUNDS_BCRYPT;
11065 gpu_accel = 2;
11066 break;
11067 case 5200: gpu_loops = ROUNDS_PSAFE3;
11068 gpu_accel = 16;
11069 break;
11070 case 5800: gpu_loops = ROUNDS_ANDROIDPIN;
11071 gpu_accel = 16;
11072 break;
11073 case 6211: gpu_loops = ROUNDS_TRUECRYPT_2K;
11074 gpu_accel = 64;
11075 break;
11076 case 6212: gpu_loops = ROUNDS_TRUECRYPT_2K;
11077 gpu_accel = 32;
11078 break;
11079 case 6213: gpu_loops = ROUNDS_TRUECRYPT_2K;
11080 gpu_accel = 32;
11081 break;
11082 case 6221: gpu_loops = ROUNDS_TRUECRYPT_1K;
11083 gpu_accel = 8;
11084 break;
11085 case 6222: gpu_loops = ROUNDS_TRUECRYPT_1K;
11086 gpu_accel = 8;
11087 break;
11088 case 6223: gpu_loops = ROUNDS_TRUECRYPT_1K;
11089 gpu_accel = 8;
11090 break;
11091 case 6231: gpu_loops = ROUNDS_TRUECRYPT_1K;
11092 gpu_accel = 8;
11093 break;
11094 case 6232: gpu_loops = ROUNDS_TRUECRYPT_1K;
11095 gpu_accel = 8;
11096 break;
11097 case 6233: gpu_loops = ROUNDS_TRUECRYPT_1K;
11098 gpu_accel = 8;
11099 break;
11100 case 6241: gpu_loops = ROUNDS_TRUECRYPT_1K;
11101 gpu_accel = 128;
11102 break;
11103 case 6242: gpu_loops = ROUNDS_TRUECRYPT_1K;
11104 gpu_accel = 64;
11105 break;
11106 case 6243: gpu_loops = ROUNDS_TRUECRYPT_1K;
11107 gpu_accel = 64;
11108 break;
11109 case 6300: gpu_loops = ROUNDS_MD5CRYPT;
11110 gpu_accel = 32;
11111 break;
11112 case 6700: gpu_loops = ROUNDS_SHA1AIX;
11113 gpu_accel = 128;
11114 break;
11115 case 6400: gpu_loops = ROUNDS_SHA256AIX;
11116 gpu_accel = 128;
11117 break;
11118 case 6500: gpu_loops = ROUNDS_SHA512AIX;
11119 gpu_accel = 32;
11120 break;
11121 case 6600: gpu_loops = ROUNDS_AGILEKEY;
11122 gpu_accel = 64;
11123 break;
11124 case 6800: gpu_loops = ROUNDS_LASTPASS;
11125 gpu_accel = 64;
11126 break;
11127 case 7100: gpu_loops = ROUNDS_SHA512OSX;
11128 gpu_accel = 2;
11129 break;
11130 case 7200: gpu_loops = ROUNDS_GRUB;
11131 gpu_accel = 2;
11132 break;
11133 case 7400: gpu_loops = ROUNDS_SHA256CRYPT;
11134 gpu_accel = 4;
11135 break;
11136 case 7900: gpu_loops = ROUNDS_DRUPAL7;
11137 gpu_accel = 8;
11138 break;
11139 case 8200: gpu_loops = ROUNDS_CLOUDKEY;
11140 gpu_accel = 2;
11141 break;
11142 case 8800: gpu_loops = ROUNDS_ANDROIDFDE;
11143 gpu_accel = 32;
11144 break;
11145 case 8900: gpu_loops = 1;
11146 gpu_accel = 64;
11147 break;
11148 case 9000: gpu_loops = ROUNDS_PSAFE2;
11149 gpu_accel = 16;
11150 break;
11151 case 9100: gpu_loops = ROUNDS_LOTUS8;
11152 gpu_accel = 64;
11153 break;
11154 case 9200: gpu_loops = ROUNDS_CISCO8;
11155 gpu_accel = 8;
11156 break;
11157 case 9300: gpu_loops = 1;
11158 gpu_accel = 4;
11159 break;
11160 case 9400: gpu_loops = ROUNDS_OFFICE2007;
11161 gpu_accel = 32;
11162 break;
11163 case 9500: gpu_loops = ROUNDS_OFFICE2010;
11164 gpu_accel = 32;
11165 break;
11166 case 9600: gpu_loops = ROUNDS_OFFICE2013;
11167 gpu_accel = 4;
11168 break;
11169 case 10000: gpu_loops = ROUNDS_DJANGOPBKDF2;
11170 gpu_accel = 8;
11171 break;
11172 case 10300: gpu_loops = ROUNDS_SAPH_SHA1;
11173 gpu_accel = 16;
11174 break;
11175 case 10500: gpu_loops = ROUNDS_PDF14;
11176 gpu_accel = 256;
11177 break;
11178 case 10700: gpu_loops = ROUNDS_PDF17L8;
11179 gpu_accel = 8;
11180 break;
11181 case 10900: gpu_loops = ROUNDS_PBKDF2_SHA256;
11182 gpu_accel = 8;
11183 break;
11184 case 11300: gpu_loops = ROUNDS_BITCOIN_WALLET;
11185 gpu_accel = 2;
11186 break;
11187 case 11600: gpu_loops = ROUNDS_SEVEN_ZIP;
11188 gpu_accel = 4;
11189 break;
11190 case 11900: gpu_loops = ROUNDS_PBKDF2_MD5;
11191 gpu_accel = 8;
11192 break;
11193 case 12000: gpu_loops = ROUNDS_PBKDF2_SHA1;
11194 gpu_accel = 8;
11195 break;
11196 case 12100: gpu_loops = ROUNDS_PBKDF2_SHA512;
11197 gpu_accel = 8;
11198 break;
11199 case 12200: gpu_loops = ROUNDS_ECRYPTFS;
11200 gpu_accel = 8;
11201 break;
11202 case 12300: gpu_loops = ROUNDS_ORACLET;
11203 gpu_accel = 8;
11204 break;
11205 case 12500: gpu_loops = ROUNDS_RAR3;
11206 gpu_accel = 32;
11207 break;
11208 case 12700: gpu_loops = ROUNDS_MYWALLET;
11209 gpu_accel = 512;
11210 break;
11211 case 12800: gpu_loops = ROUNDS_MS_DRSR;
11212 gpu_accel = 512;
11213 break;
11214 }
11215
11216 // some algorithm collide too fast, make that impossible
11217
11218 switch (hash_mode)
11219 {
11220 case 11500: ((uint *) digests_buf)[1] = 1;
11221 break;
11222 }
11223
11224 if (gpu_loops > 1024) gpu_loops = 1024;
11225 if (gpu_accel > 256) gpu_accel = 256; // causes memory problems otherwise
11226 }
11227
11228 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
11229 {
11230 gpu_loops = 1024;
11231 }
11232
11233 if (hash_mode == 12500)
11234 {
11235 gpu_loops = ROUNDS_RAR3 / 16;
11236 }
11237
11238 data.gpu_accel = gpu_accel;
11239 data.gpu_loops = gpu_loops;
11240
11241 hashes_cnt = 1;
11242 }
11243
11244 if (show == 1 || left == 1)
11245 {
11246 for (uint i = 0; i < pot_cnt; i++)
11247 {
11248 pot_t *pot_ptr = &pot[i];
11249
11250 hash_t *hashes_buf = &pot_ptr->hash;
11251
11252 local_free (hashes_buf->digest);
11253
11254 if (isSalted)
11255 {
11256 local_free (hashes_buf->salt);
11257 }
11258 }
11259
11260 local_free (pot);
11261
11262 if (data.quiet == 0) log_info_nn ("");
11263
11264 return (0);
11265 }
11266
11267 if (keyspace == 0)
11268 {
11269 if (hashes_cnt == 0)
11270 {
11271 log_error ("ERROR: No hashes loaded");
11272
11273 return (-1);
11274 }
11275 }
11276
11277 /**
11278 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11279 */
11280
11281 if (data.outfile != NULL)
11282 {
11283 if (data.hashfile != NULL)
11284 {
11285 #ifdef _POSIX
11286 struct stat tmpstat_outfile;
11287 struct stat tmpstat_hashfile;
11288 #endif
11289
11290 #ifdef _WIN
11291 struct stat64 tmpstat_outfile;
11292 struct stat64 tmpstat_hashfile;
11293 #endif
11294
11295 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11296
11297 if (tmp_outfile_fp)
11298 {
11299 #ifdef _POSIX
11300 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11301 #endif
11302
11303 #ifdef _WIN
11304 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11305 #endif
11306
11307 fclose (tmp_outfile_fp);
11308 }
11309
11310 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11311
11312 if (tmp_hashfile_fp)
11313 {
11314 #ifdef _POSIX
11315 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11316 #endif
11317
11318 #ifdef _WIN
11319 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11320 #endif
11321
11322 fclose (tmp_hashfile_fp);
11323 }
11324
11325 if (tmp_outfile_fp && tmp_outfile_fp)
11326 {
11327 tmpstat_outfile.st_mode = 0;
11328 tmpstat_outfile.st_nlink = 0;
11329 tmpstat_outfile.st_uid = 0;
11330 tmpstat_outfile.st_gid = 0;
11331 tmpstat_outfile.st_rdev = 0;
11332 tmpstat_outfile.st_atime = 0;
11333
11334 tmpstat_hashfile.st_mode = 0;
11335 tmpstat_hashfile.st_nlink = 0;
11336 tmpstat_hashfile.st_uid = 0;
11337 tmpstat_hashfile.st_gid = 0;
11338 tmpstat_hashfile.st_rdev = 0;
11339 tmpstat_hashfile.st_atime = 0;
11340
11341 #ifdef _POSIX
11342 tmpstat_outfile.st_blksize = 0;
11343 tmpstat_outfile.st_blocks = 0;
11344
11345 tmpstat_hashfile.st_blksize = 0;
11346 tmpstat_hashfile.st_blocks = 0;
11347 #endif
11348
11349 #ifdef _POSIX
11350 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11351 {
11352 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11353
11354 return (-1);
11355 }
11356 #endif
11357
11358 #ifdef _WIN
11359 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11360 {
11361 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11362
11363 return (-1);
11364 }
11365 #endif
11366 }
11367 }
11368 }
11369
11370 /**
11371 * Remove duplicates
11372 */
11373
11374 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11375
11376 if (isSalted)
11377 {
11378 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11379 }
11380 else
11381 {
11382 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11383 }
11384
11385 uint hashes_cnt_orig = hashes_cnt;
11386
11387 hashes_cnt = 1;
11388
11389 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11390 {
11391 if (isSalted)
11392 {
11393 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11394 {
11395 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11396 }
11397 }
11398 else
11399 {
11400 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11401 }
11402
11403 if (hashes_pos > hashes_cnt)
11404 {
11405 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11406 }
11407
11408 hashes_cnt++;
11409 }
11410
11411 /**
11412 * Potfile removes
11413 */
11414
11415 uint potfile_remove_cracks = 0;
11416
11417 if (potfile_disable == 0)
11418 {
11419 hash_t hash_buf;
11420
11421 hash_buf.digest = mymalloc (dgst_size);
11422 hash_buf.salt = NULL;
11423 hash_buf.esalt = NULL;
11424 hash_buf.hash_info = NULL;
11425 hash_buf.cracked = 0;
11426
11427 if (isSalted)
11428 {
11429 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11430 }
11431
11432 if (esalt_size)
11433 {
11434 hash_buf.esalt = mymalloc (esalt_size);
11435 }
11436
11437 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11438
11439 // no solution for these special hash types (for instane because they use hashfile in output etc)
11440 if ((hash_mode != 5200) &&
11441 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11442 (hash_mode != 9000))
11443 {
11444 FILE *fp = fopen (potfile, "rb");
11445
11446 if (fp != NULL)
11447 {
11448 while (!feof (fp))
11449 {
11450 char line_buf[BUFSIZ];
11451
11452 memset (line_buf, 0, BUFSIZ);
11453
11454 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11455
11456 if (ptr == NULL) break;
11457
11458 int line_len = strlen (line_buf);
11459
11460 if (line_len == 0) continue;
11461
11462 int iter = MAX_CUT_TRIES;
11463
11464 for (int i = line_len - 1; i && iter; i--, line_len--)
11465 {
11466 if (line_buf[i] != ':') continue;
11467
11468 if (isSalted)
11469 {
11470 memset (hash_buf.salt, 0, sizeof (salt_t));
11471 }
11472
11473 hash_t *found = NULL;
11474
11475 if (hash_mode == 6800)
11476 {
11477 if (i < 48) // 48 = 12 * uint in salt_buf[]
11478 {
11479 // manipulate salt_buf
11480 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11481
11482 hash_buf.salt->salt_len = i;
11483
11484 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11485 }
11486 }
11487 else if (hash_mode == 2500)
11488 {
11489 if (i < 48) // 48 = 12 * uint in salt_buf[]
11490 {
11491 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11492 // manipulate salt_buf
11493
11494 // to be safe work with a copy (because of line_len loop, i etc)
11495
11496 char line_buf_cpy[BUFSIZ];
11497 memset (line_buf_cpy, 0, BUFSIZ);
11498
11499 memset (line_buf_cpy, 0, sizeof (line_buf_cpy));
11500
11501 memcpy (line_buf_cpy, line_buf, i);
11502
11503 char *mac2_pos = strrchr (line_buf_cpy, ':');
11504
11505 if (mac2_pos == NULL) continue;
11506
11507 mac2_pos[0] = 0;
11508 mac2_pos++;
11509
11510 if (strlen (mac2_pos) != 12) continue;
11511
11512 char *mac1_pos = strrchr (line_buf_cpy, ':');
11513
11514 if (mac1_pos == NULL) continue;
11515
11516 mac1_pos[0] = 0;
11517 mac1_pos++;
11518
11519 if (strlen (mac1_pos) != 12) continue;
11520
11521 uint essid_length = mac1_pos - line_buf_cpy - 1;
11522
11523 // here we need the ESSID
11524 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11525
11526 hash_buf.salt->salt_len = essid_length;
11527
11528 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11529
11530 if (found)
11531 {
11532 wpa_t *wpa = (wpa_t *) found->esalt;
11533
11534 uint pke[25];
11535
11536 char *pke_ptr = (char *) pke;
11537
11538 for (uint i = 0; i < 25; i++)
11539 {
11540 pke[i] = byte_swap_32 (wpa->pke[i]);
11541 }
11542
11543 unsigned char mac1[6];
11544 unsigned char mac2[6];
11545
11546 memcpy (mac1, pke_ptr + 23, 6);
11547 memcpy (mac2, pke_ptr + 29, 6);
11548
11549 // compare hex string(s) vs binary MAC address(es)
11550
11551 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11552 {
11553 if (mac1[i] != (unsigned char) hex_to_char (&mac1_pos[j]))
11554 {
11555 found = NULL;
11556 break;
11557 }
11558 }
11559
11560 // early skip ;)
11561 if (!found) continue;
11562
11563 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11564 {
11565 if (mac2[i] != (unsigned char) hex_to_char (&mac2_pos[j]))
11566 {
11567 found = NULL;
11568 break;
11569 }
11570 }
11571 }
11572 }
11573 }
11574 else
11575 {
11576 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11577
11578 if (parser_status == PARSER_OK)
11579 {
11580 if (isSalted)
11581 {
11582 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11583 }
11584 else
11585 {
11586 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11587 }
11588 }
11589 }
11590
11591 if (found == NULL) continue;
11592
11593 if (!found->cracked) potfile_remove_cracks++;
11594
11595 found->cracked = 1;
11596
11597 if (found) break;
11598
11599 iter--;
11600 }
11601 }
11602
11603 fclose (fp);
11604 }
11605 }
11606
11607 if (esalt_size)
11608 {
11609 local_free (hash_buf.esalt);
11610 }
11611
11612 if (isSalted)
11613 {
11614 local_free (hash_buf.salt);
11615 }
11616
11617 local_free (hash_buf.digest);
11618 }
11619
11620 /**
11621 * Now generate all the buffers required for later
11622 */
11623
11624 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11625
11626 salt_t *salts_buf_new = NULL;
11627 void *esalts_buf_new = NULL;
11628
11629 if (isSalted)
11630 {
11631 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11632
11633 if (esalt_size)
11634 {
11635 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
11636 }
11637 }
11638 else
11639 {
11640 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
11641 }
11642
11643 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
11644
11645 uint digests_cnt = hashes_cnt;
11646 uint digests_done = 0;
11647
11648 uint size_digests = digests_cnt * dgst_size;
11649 uint size_shown = digests_cnt * sizeof (uint);
11650
11651 uint *digests_shown = (uint *) mymalloc (size_shown);
11652 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
11653
11654 uint salts_cnt = 0;
11655 uint salts_done = 0;
11656
11657 hashinfo_t **hash_info = NULL;
11658
11659 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11660 {
11661 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
11662
11663 if (username && (remove || show))
11664 {
11665 uint user_pos;
11666
11667 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
11668 {
11669 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
11670
11671 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
11672 }
11673 }
11674 }
11675
11676 uint *salts_shown = (uint *) mymalloc (size_shown);
11677
11678 salt_t *salt_buf;
11679
11680 {
11681 // copied from inner loop
11682
11683 salt_buf = &salts_buf_new[salts_cnt];
11684
11685 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
11686
11687 if (esalt_size)
11688 {
11689 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
11690 }
11691
11692 salt_buf->digests_cnt = 0;
11693 salt_buf->digests_done = 0;
11694 salt_buf->digests_offset = 0;
11695
11696 salts_cnt++;
11697 }
11698
11699 if (hashes_buf[0].cracked == 1)
11700 {
11701 digests_shown[0] = 1;
11702
11703 digests_done++;
11704
11705 salt_buf->digests_done++;
11706 }
11707
11708 salt_buf->digests_cnt++;
11709
11710 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
11711
11712 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11713 {
11714 hash_info[0] = hashes_buf[0].hash_info;
11715 }
11716
11717 // copy from inner loop
11718
11719 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
11720 {
11721 if (isSalted)
11722 {
11723 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
11724 {
11725 salt_buf = &salts_buf_new[salts_cnt];
11726
11727 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
11728
11729 if (esalt_size)
11730 {
11731 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
11732 }
11733
11734 salt_buf->digests_cnt = 0;
11735 salt_buf->digests_done = 0;
11736 salt_buf->digests_offset = hashes_pos;
11737
11738 salts_cnt++;
11739 }
11740 }
11741
11742 if (hashes_buf[hashes_pos].cracked == 1)
11743 {
11744 digests_shown[hashes_pos] = 1;
11745
11746 digests_done++;
11747
11748 salt_buf->digests_done++;
11749 }
11750
11751 salt_buf->digests_cnt++;
11752
11753 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
11754
11755 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11756 {
11757 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
11758 }
11759 }
11760
11761 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
11762 {
11763 salt_t *salt_buf = &salts_buf_new[salt_pos];
11764
11765 if (salt_buf->digests_done == salt_buf->digests_cnt)
11766 {
11767 salts_shown[salt_pos] = 1;
11768
11769 salts_done++;
11770 }
11771
11772 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
11773 }
11774
11775 local_free (digests_buf);
11776 local_free (salts_buf);
11777 local_free (esalts_buf);
11778
11779 digests_buf = digests_buf_new;
11780 salts_buf = salts_buf_new;
11781 esalts_buf = esalts_buf_new;
11782
11783 local_free (hashes_buf);
11784
11785 /**
11786 * special modification not set from parser
11787 */
11788
11789 switch (hash_mode)
11790 {
11791 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
11792 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
11793 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
11794 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
11795 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
11796 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
11797 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
11798 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
11799 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
11800 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
11801 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
11802 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
11803 }
11804
11805 if (truecrypt_keyfiles)
11806 {
11807 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
11808
11809 char *keyfiles = strdup (truecrypt_keyfiles);
11810
11811 char *keyfile = strtok (keyfiles, ",");
11812
11813 do
11814 {
11815 truecrypt_crc32 (keyfile, (unsigned char *) keyfile_buf);
11816
11817 } while ((keyfile = strtok (NULL, ",")) != NULL);
11818
11819 free (keyfiles);
11820 }
11821
11822 data.digests_cnt = digests_cnt;
11823 data.digests_done = digests_done;
11824 data.digests_buf = digests_buf;
11825 data.digests_shown = digests_shown;
11826 data.digests_shown_tmp = digests_shown_tmp;
11827
11828 data.salts_cnt = salts_cnt;
11829 data.salts_done = salts_done;
11830 data.salts_buf = salts_buf;
11831 data.salts_shown = salts_shown;
11832
11833 data.esalts_buf = esalts_buf;
11834 data.hash_info = hash_info;
11835
11836 /**
11837 * Automatic Optimizers
11838 */
11839
11840 if (salts_cnt == 1)
11841 opti_type |= OPTI_TYPE_SINGLE_SALT;
11842
11843 if (digests_cnt == 1)
11844 opti_type |= OPTI_TYPE_SINGLE_HASH;
11845
11846 if (attack_exec == ATTACK_EXEC_ON_GPU)
11847 opti_type |= OPTI_TYPE_NOT_ITERATED;
11848
11849 if (attack_mode == ATTACK_MODE_BF)
11850 opti_type |= OPTI_TYPE_BRUTE_FORCE;
11851
11852 data.opti_type = opti_type;
11853
11854 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
11855 {
11856 if (opti_type & OPTI_TYPE_SINGLE_HASH)
11857 {
11858 if (opti_type & OPTI_TYPE_APPENDED_SALT)
11859 {
11860 if (opts_type & OPTS_TYPE_ST_ADD80)
11861 {
11862 opts_type &= ~OPTS_TYPE_ST_ADD80;
11863 opts_type |= OPTS_TYPE_PT_ADD80;
11864 }
11865
11866 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
11867 {
11868 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
11869 opts_type |= OPTS_TYPE_PT_ADDBITS14;
11870 }
11871
11872 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
11873 {
11874 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
11875 opts_type |= OPTS_TYPE_PT_ADDBITS15;
11876 }
11877 }
11878 }
11879 }
11880
11881 /**
11882 * Some algorithm, like descrypt, can benefit from JIT compilation
11883 */
11884
11885 uint force_jit_compilation = 0;
11886
11887 if (hash_mode == 8900)
11888 {
11889 force_jit_compilation = 8900;
11890 }
11891 else if (hash_mode == 9300)
11892 {
11893 force_jit_compilation = 8900;
11894 }
11895 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
11896 {
11897 force_jit_compilation = 1500;
11898 }
11899
11900 /**
11901 * generate bitmap tables
11902 */
11903
11904 const uint bitmap_shift1 = 5;
11905 const uint bitmap_shift2 = 13;
11906
11907 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
11908
11909 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
11910 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
11911 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
11912 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
11913 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
11914 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
11915 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
11916 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
11917
11918 uint bitmap_bits;
11919 uint bitmap_nums;
11920 uint bitmap_mask;
11921 uint bitmap_size;
11922
11923 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
11924 {
11925 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
11926
11927 bitmap_nums = 1 << bitmap_bits;
11928
11929 bitmap_mask = bitmap_nums - 1;
11930
11931 bitmap_size = bitmap_nums * sizeof (uint);
11932
11933 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
11934
11935 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;
11936 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;
11937
11938 break;
11939 }
11940
11941 bitmap_nums = 1 << bitmap_bits;
11942
11943 bitmap_mask = bitmap_nums - 1;
11944
11945 bitmap_size = bitmap_nums * sizeof (uint);
11946
11947 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);
11948 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);
11949
11950 /**
11951 * prepare quick rule
11952 */
11953
11954 data.rule_buf_l = rule_buf_l;
11955 data.rule_buf_r = rule_buf_r;
11956
11957 int rule_len_l = (int) strlen (rule_buf_l);
11958 int rule_len_r = (int) strlen (rule_buf_r);
11959
11960 data.rule_len_l = rule_len_l;
11961 data.rule_len_r = rule_len_r;
11962
11963 /**
11964 * load rules
11965 */
11966
11967 uint *all_gpu_rules_cnt = NULL;
11968
11969 gpu_rule_t **all_gpu_rules_buf = NULL;
11970
11971 if (rp_files_cnt)
11972 {
11973 all_gpu_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
11974
11975 all_gpu_rules_buf = (gpu_rule_t **) mycalloc (rp_files_cnt, sizeof (gpu_rule_t *));
11976 }
11977
11978 char rule_buf[BUFSIZ];
11979
11980 int rule_len = 0;
11981
11982 for (uint i = 0; i < rp_files_cnt; i++)
11983 {
11984 uint gpu_rules_avail = 0;
11985
11986 uint gpu_rules_cnt = 0;
11987
11988 gpu_rule_t *gpu_rules_buf = NULL;
11989
11990 char *rp_file = rp_files[i];
11991
11992 char in[BLOCK_SIZE];
11993 char out[BLOCK_SIZE];
11994
11995 FILE *fp = NULL;
11996
11997 uint rule_line = 0;
11998
11999 if ((fp = fopen (rp_file, "rb")) == NULL)
12000 {
12001 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12002
12003 return (-1);
12004 }
12005
12006 while (!feof (fp))
12007 {
12008 memset (rule_buf, 0, BUFSIZ);
12009
12010 rule_len = fgetl (fp, rule_buf);
12011
12012 rule_line++;
12013
12014 if (rule_len == 0) continue;
12015
12016 if (rule_buf[0] == '#') continue;
12017
12018 if (gpu_rules_avail == gpu_rules_cnt)
12019 {
12020 gpu_rules_buf = (gpu_rule_t *) myrealloc (gpu_rules_buf, gpu_rules_avail * sizeof (gpu_rule_t), INCR_RULES * sizeof (gpu_rule_t));
12021
12022 gpu_rules_avail += INCR_RULES;
12023 }
12024
12025 memset (in, 0, BLOCK_SIZE);
12026 memset (out, 0, BLOCK_SIZE);
12027
12028 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12029
12030 if (result == -1)
12031 {
12032 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12033
12034 continue;
12035 }
12036
12037 if (cpu_rule_to_gpu_rule (rule_buf, rule_len, &gpu_rules_buf[gpu_rules_cnt]) == -1)
12038 {
12039 log_info ("WARNING: Cannot convert rule for use on GPU in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12040
12041 memset (&gpu_rules_buf[gpu_rules_cnt], 0, sizeof (gpu_rule_t)); // needs to be cleared otherwise we could have some remaining data
12042
12043 continue;
12044 }
12045
12046 /* its so slow
12047 if (rulefind (&gpu_rules_buf[gpu_rules_cnt], gpu_rules_buf, gpu_rules_cnt, sizeof (gpu_rule_t), sort_by_gpu_rule))
12048 {
12049 log_info ("Duplicate rule for use on GPU in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12050
12051 continue;
12052 }
12053 */
12054
12055 gpu_rules_cnt++;
12056 }
12057
12058 fclose (fp);
12059
12060 all_gpu_rules_cnt[i] = gpu_rules_cnt;
12061
12062 all_gpu_rules_buf[i] = gpu_rules_buf;
12063 }
12064
12065 /**
12066 * merge rules or automatic rule generator
12067 */
12068
12069 uint gpu_rules_cnt = 0;
12070
12071 gpu_rule_t *gpu_rules_buf = NULL;
12072
12073 if (attack_mode == ATTACK_MODE_STRAIGHT)
12074 {
12075 if (rp_files_cnt)
12076 {
12077 gpu_rules_cnt = 1;
12078
12079 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12080
12081 repeats[0] = gpu_rules_cnt;
12082
12083 for (uint i = 0; i < rp_files_cnt; i++)
12084 {
12085 gpu_rules_cnt *= all_gpu_rules_cnt[i];
12086
12087 repeats[i + 1] = gpu_rules_cnt;
12088 }
12089
12090 gpu_rules_buf = (gpu_rule_t *) mycalloc (gpu_rules_cnt, sizeof (gpu_rule_t));
12091
12092 memset (gpu_rules_buf, 0, gpu_rules_cnt * sizeof (gpu_rule_t));
12093
12094 for (uint i = 0; i < gpu_rules_cnt; i++)
12095 {
12096 uint out_pos = 0;
12097
12098 gpu_rule_t *out = &gpu_rules_buf[i];
12099
12100 for (uint j = 0; j < rp_files_cnt; j++)
12101 {
12102 uint in_off = (i / repeats[j]) % all_gpu_rules_cnt[j];
12103 uint in_pos;
12104
12105 gpu_rule_t *in = &all_gpu_rules_buf[j][in_off];
12106
12107 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12108 {
12109 if (out_pos == RULES_MAX - 1)
12110 {
12111 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12112
12113 break;
12114 }
12115
12116 out->cmds[out_pos] = in->cmds[in_pos];
12117 }
12118 }
12119 }
12120
12121 local_free (repeats);
12122 }
12123 else if (rp_gen)
12124 {
12125 uint gpu_rules_avail = 0;
12126
12127 while (gpu_rules_cnt < rp_gen)
12128 {
12129 if (gpu_rules_avail == gpu_rules_cnt)
12130 {
12131 gpu_rules_buf = (gpu_rule_t *) myrealloc (gpu_rules_buf, gpu_rules_avail * sizeof (gpu_rule_t), INCR_RULES * sizeof (gpu_rule_t));
12132
12133 gpu_rules_avail += INCR_RULES;
12134 }
12135
12136 memset (rule_buf, 0, BLOCK_SIZE);
12137
12138 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12139
12140 if (cpu_rule_to_gpu_rule (rule_buf, rule_len, &gpu_rules_buf[gpu_rules_cnt]) == -1) continue;
12141
12142 gpu_rules_cnt++;
12143 }
12144 }
12145 }
12146
12147 /**
12148 * generate NOP rules
12149 */
12150
12151 if (gpu_rules_cnt == 0)
12152 {
12153 gpu_rules_buf = (gpu_rule_t *) mymalloc (sizeof (gpu_rule_t));
12154
12155 gpu_rules_buf[gpu_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12156
12157 gpu_rules_cnt++;
12158 }
12159
12160 data.gpu_rules_cnt = gpu_rules_cnt;
12161 data.gpu_rules_buf = gpu_rules_buf;
12162
12163 /**
12164 * platform
12165 */
12166
12167 cl_platform_id CL_platforms[CL_PLATFORMS_MAX];
12168
12169 uint CL_platforms_cnt = 0;
12170
12171 hc_clGetPlatformIDs (CL_PLATFORMS_MAX, CL_platforms, &CL_platforms_cnt);
12172
12173 if (CL_platforms_cnt == 0)
12174 {
12175 log_error ("ERROR: No OpenCL compatible platform found");
12176
12177 return (-1);
12178 }
12179
12180 if (CL_platforms_cnt > 1)
12181 {
12182 log_error ("ERROR: Too many OpenCL compatible platforms found");
12183
12184 return (-1);
12185 }
12186
12187 cl_platform_id CL_platform = CL_platforms[0];
12188
12189 char CL_platform_vendor[INFOSZ];
12190
12191 memset (CL_platform_vendor, 0, sizeof (CL_platform_vendor));
12192
12193 hc_clGetPlatformInfo (CL_platform, CL_PLATFORM_VENDOR, sizeof (CL_platform_vendor), CL_platform_vendor, NULL);
12194
12195 uint vendor_id;
12196
12197 if (strcmp (CL_platform_vendor, CL_VENDOR_AMD) == 0)
12198 {
12199 vendor_id = VENDOR_ID_AMD;
12200 }
12201 else if (strcmp (CL_platform_vendor, CL_VENDOR_NV) == 0)
12202 {
12203 vendor_id = VENDOR_ID_NV;
12204 }
12205 else
12206 {
12207 vendor_id = VENDOR_ID_UNKNOWN;
12208 }
12209
12210 data.vendor_id = vendor_id;
12211
12212 /**
12213 * devices
12214 */
12215
12216 cl_device_id devices_all[DEVICES_MAX];
12217 cl_device_id devices[DEVICES_MAX];
12218
12219 uint devices_all_cnt = 0;
12220
12221 hc_clGetDeviceIDs (CL_platform, CL_DEVICE_TYPE_GPU, DEVICES_MAX, devices_all, (uint *) &devices_all_cnt);
12222
12223 int hm_adapters_all = devices_all_cnt;
12224
12225 hm_attrs_t hm_adapter_all[DEVICES_MAX];
12226
12227 memset (hm_adapter_all, 0, sizeof (hm_adapter_all));
12228
12229 /*
12230 if (gpu_temp_disable == 0)
12231 {
12232 if (vendor_id == VENDOR_ID_NV)
12233 {
12234 #ifdef LINUX
12235 if (hc_NVML_nvmlInit () == NVML_SUCCESS)
12236 {
12237 HM_ADAPTER nvGPUHandle[DEVICES_MAX];
12238
12239 int tmp_in = hm_get_adapter_index (nvGPUHandle);
12240
12241 int tmp_out = 0;
12242
12243 for (int i = 0; i < tmp_in; i++)
12244 {
12245 hm_adapter_all[tmp_out++].adapter_index = nvGPUHandle[i];
12246 }
12247
12248 hm_adapters_all = tmp_out;
12249
12250 for (int i = 0; i < tmp_out; i++)
12251 {
12252 unsigned int speed;
12253
12254 if (nvmlDeviceGetFanSpeed (hm_adapter_all[i].adapter_index, &speed) != NVML_ERROR_NOT_SUPPORTED) hm_adapter_all[i].fan_supported = 1;
12255 }
12256 }
12257 #endif
12258
12259 #ifdef WIN
12260 if (NvAPI_Initialize () == NVAPI_OK)
12261 {
12262 HM_ADAPTER nvGPUHandle[DEVICES_MAX];
12263
12264 int tmp_in = hm_get_adapter_index (nvGPUHandle);
12265
12266 int tmp_out = 0;
12267
12268 for (int i = 0; i < tmp_in; i++)
12269 {
12270 hm_adapter_all[tmp_out++].adapter_index = nvGPUHandle[i];
12271 }
12272
12273 hm_adapters_all = tmp_out;
12274
12275 for (int i = 0; i < tmp_out; i++)
12276 {
12277 NvU32 speed;
12278
12279 if (NvAPI_GPU_GetTachReading (hm_adapter_all[i].adapter_index, &speed) != NVAPI_NOT_SUPPORTED) hm_adapter_all[i].fan_supported = 1;
12280 }
12281 }
12282 #endif
12283 }
12284
12285 if (vendor_id == VENDOR_ID_AMD)
12286 {
12287 HM_LIB hm_dll = hm_init ();
12288
12289 data.hm_dll = hm_dll;
12290
12291 if (hc_ADL_Main_Control_Create (hm_dll, ADL_Main_Memory_Alloc, 0) == ADL_OK)
12292 {
12293 // total number of adapters
12294
12295 int hm_adapters_num;
12296
12297 if (get_adapters_num (hm_dll, &hm_adapters_num) != 0) return (-1);
12298
12299 // adapter info
12300
12301 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info (hm_dll, hm_adapters_num);
12302
12303 if (lpAdapterInfo == NULL) return (-1);
12304
12305 // get a list (of ids of) valid/usable adapters
12306
12307 int num_adl_adapters = 0;
12308
12309 uint32_t *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
12310
12311 if (num_adl_adapters > 0)
12312 {
12313 hc_thread_mutex_lock (mux_adl);
12314
12315 // hm_get_opencl_busid_devid (hm_adapter_all, devices_all_cnt, devices_all);
12316
12317 hm_get_adapter_index (hm_adapter_all, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12318
12319 hm_get_overdrive_version (hm_dll, hm_adapter_all, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12320 hm_check_fanspeed_control (hm_dll, hm_adapter_all, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12321
12322 hc_thread_mutex_unlock (mux_adl);
12323 }
12324
12325 hm_adapters_all = num_adl_adapters;
12326
12327 myfree (valid_adl_device_list);
12328 myfree (lpAdapterInfo);
12329 }
12330 }
12331 }
12332
12333 if (hm_adapters_all == 0)
12334 {
12335 gpu_temp_disable = 1;
12336 }
12337
12338 if (gpu_temp_disable == 1)
12339 {
12340 gpu_temp_abort = 0;
12341 gpu_temp_retain = 0;
12342 }
12343 */
12344
12345 /**
12346 * enable custom signal handler(s)
12347 */
12348
12349 if (benchmark == 0)
12350 {
12351 hc_signal (sigHandler_default);
12352 }
12353 else
12354 {
12355 hc_signal (sigHandler_benchmark);
12356 }
12357
12358 /**
12359 * devices mask and properties
12360 */
12361
12362 uint devices_cnt = 0;
12363
12364 for (uint device_all_id = 0; device_all_id < devices_all_cnt; device_all_id++)
12365 {
12366 if (gpu_devicemask)
12367 {
12368 uint device_all_id_mask = 1 << device_all_id;
12369
12370 if ((device_all_id_mask & gpu_devicemask) != device_all_id_mask)
12371 {
12372 if (quiet == 0 && algorithm_pos == 0) log_info ("Device #%d: skipped by user", device_all_id_mask + 1);
12373
12374 continue;
12375 }
12376 }
12377
12378 const uint device_id = devices_cnt;
12379
12380 devices[device_id] = devices_all[device_all_id];
12381
12382 memcpy (&data.hm_device[device_id], &hm_adapter_all[device_all_id], sizeof (hm_attrs_t));
12383
12384 char device_name[INFOSZ];
12385
12386 memset (device_name, 0, sizeof (device_name));
12387
12388 cl_ulong global_mem_size;
12389 cl_uint max_clock_frequency;
12390 cl_uint max_compute_units;
12391
12392 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_NAME, sizeof (device_name), &device_name, NULL);
12393 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (global_mem_size), &global_mem_size, NULL);
12394 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (max_clock_frequency), &max_clock_frequency, NULL);
12395 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (max_compute_units), &max_compute_units, NULL);
12396
12397 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12398 {
12399 log_info ("Device #%u: %s, %luMB, %dMhz, %uMCU",
12400 device_all_id + 1,
12401 device_name,
12402 (unsigned int) (global_mem_size / 1024 / 1024),
12403 (unsigned int) (max_clock_frequency),
12404 (unsigned int) max_compute_units);
12405 }
12406
12407 devices_cnt++;
12408 }
12409
12410 if (devices_cnt == 0)
12411 {
12412 log_error ("ERROR: No devices left that matches your specification.");
12413
12414 return (-1);
12415 }
12416
12417 data.devices_cnt = devices_cnt;
12418
12419 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12420 {
12421 log_info ("");
12422 }
12423
12424 /**
12425 * inform the user
12426 */
12427
12428 // gpu temp sanity check
12429
12430 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
12431 {
12432 if (gpu_temp_abort < gpu_temp_retain)
12433 {
12434 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
12435
12436 return (-1);
12437 }
12438 }
12439
12440 data.gpu_temp_disable = gpu_temp_disable;
12441 data.gpu_temp_abort = gpu_temp_abort;
12442 data.gpu_temp_retain = gpu_temp_retain;
12443
12444 if (data.quiet == 0)
12445 {
12446 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
12447
12448 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);
12449
12450 if (attack_mode == ATTACK_MODE_STRAIGHT)
12451 {
12452 log_info ("Rules: %u", gpu_rules_cnt);
12453 }
12454
12455 if (opti_type)
12456 {
12457 log_info ("Applicable Optimizers:");
12458
12459 for (uint i = 0; i < 32; i++)
12460 {
12461 const uint opti_bit = 1 << i;
12462
12463 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
12464 }
12465 }
12466
12467 /**
12468 * Watchdog and Temperature balance
12469 */
12470
12471 if (gpu_temp_abort == 0)
12472 {
12473 log_info ("Watchdog: Temperature abort trigger disabled");
12474 }
12475 else
12476 {
12477 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
12478 }
12479
12480 if (gpu_temp_retain == 0)
12481 {
12482 log_info ("Watchdog: Temperature retain trigger disabled");
12483 }
12484 else
12485 {
12486 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
12487 }
12488 }
12489
12490 /**
12491 * devices init
12492 */
12493
12494 int *temp_retain_fanspeed_value = (int *) mycalloc (devices_cnt, sizeof (int));
12495
12496 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (devices_cnt, sizeof (ADLOD6MemClockState));
12497
12498 int *od_power_control_status = (int *) mycalloc (devices_cnt, sizeof (int));
12499
12500 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (devices_cnt, sizeof (hc_device_param_t));
12501
12502 data.devices_param = devices_param;
12503
12504 for (uint device_id = 0; device_id < devices_cnt; device_id++)
12505 {
12506 hc_device_param_t *device_param = &data.devices_param[device_id];
12507
12508 cl_device_id device = devices[device_id];
12509
12510 device_param->device = device;
12511
12512 cl_uint max_compute_units = 0;
12513
12514 hc_clGetDeviceInfo (device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (max_compute_units), &max_compute_units, NULL);
12515
12516 device_param->gpu_processors = max_compute_units;
12517
12518 cl_ulong max_mem_alloc_size = 0;
12519
12520 hc_clGetDeviceInfo (device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (max_mem_alloc_size), &max_mem_alloc_size, NULL);
12521
12522 device_param->gpu_maxmem_alloc = max_mem_alloc_size;
12523
12524 char tmp[INFOSZ], t1[64];
12525
12526 memset (tmp, 0, sizeof (tmp));
12527
12528 hc_clGetDeviceInfo (device, CL_DEVICE_NAME, sizeof (tmp), &tmp, NULL);
12529
12530 device_param->device_name = mystrdup (tmp);
12531
12532 memset (tmp, 0, sizeof (tmp));
12533
12534 hc_clGetDeviceInfo (device, CL_DEVICE_VERSION, sizeof (tmp), &tmp, NULL);
12535
12536 memset (t1, 0, sizeof (t1));
12537
12538 sscanf (tmp, "%*16s %*16s %*16s (%[^)]16s)", t1);
12539
12540 device_param->device_version = mystrdup (t1);
12541
12542 memset (tmp, 0, sizeof (tmp));
12543
12544 hc_clGetDeviceInfo (device, CL_DRIVER_VERSION, sizeof (tmp), &tmp, NULL);
12545
12546 device_param->driver_version = mystrdup (tmp);
12547
12548 if (vendor_id == VENDOR_ID_NV)
12549 {
12550 cl_uint sm_minor = 0;
12551 cl_uint sm_major = 0;
12552
12553 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12554 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12555
12556 hc_clGetDeviceInfo (device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12557 hc_clGetDeviceInfo (device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12558
12559 device_param->sm_minor = sm_minor;
12560 device_param->sm_major = sm_major;
12561 }
12562
12563 /**
12564 * catalyst driver check
12565 */
12566
12567 if (vendor_id == VENDOR_ID_AMD)
12568 {
12569 int catalyst_check = (force == 1) ? 0 : 1;
12570
12571 int catalyst_warn = 0;
12572
12573 int catalyst_broken = 0;
12574
12575 if (catalyst_check == 1)
12576 {
12577 catalyst_warn = 1;
12578
12579 // v14.9 and higher
12580 if ((atoi (device_param->device_version) >= 1573)
12581 && (atoi (device_param->driver_version) >= 1573))
12582 {
12583 catalyst_warn = 0;
12584 }
12585
12586 /*
12587 // v14.9
12588 if ((strstr (device_param->device_version, "1573.") != NULL)
12589 && (strstr (device_param->driver_version, "1573.") != NULL))
12590 {
12591 catalyst_warn = 0;
12592 }
12593
12594 // v14.12 -- version overlaps with v15.4 beta
12595 if ((strstr (device_param->device_version, "1642.") != NULL)
12596 && (strstr (device_param->driver_version, "1642.") != NULL))
12597 {
12598 catalyst_broken = 1;
12599 }
12600
12601 // v15.4 (Beta, Windows only release)
12602 if ((strstr (device_param->device_version, "1642.") != NULL)
12603 && (strstr (device_param->driver_version, "1642.") != NULL))
12604 {
12605 catalyst_warn = 0;
12606 }
12607
12608 // v15.5 (Release, Linux)
12609 if ((strstr (device_param->device_version, "1702.") != NULL)
12610 && (strstr (device_param->driver_version, "1702.") != NULL))
12611 {
12612 catalyst_warn = 0;
12613 }
12614
12615 // v15.3 (Beta, Ubuntu repository release)
12616 if ((strstr (device_param->device_version, "1729.") != NULL)
12617 && (strstr (device_param->driver_version, "1729.") != NULL))
12618 {
12619 catalyst_warn = 0;
12620 }
12621 */
12622
12623 catalyst_check = 0;
12624 }
12625
12626 if (catalyst_broken == 1)
12627 {
12628 log_error ("");
12629 log_error ("ATTENTION! The installed GPU driver in your system is known to be broken!");
12630 log_error ("It will pass over cracked hashes and does not report them as cracked");
12631 log_error ("You are STRONGLY encouraged not to use it");
12632 log_error ("You can use --force to override this but do not post error reports if you do so");
12633
12634 return (-1);
12635 }
12636
12637 if (catalyst_warn == 1)
12638 {
12639 log_error ("");
12640 log_error ("ATTENTION! Unsupported or incorrect installed GPU driver detected!");
12641 log_error ("You are STRONGLY encouraged to use the official supported GPU driver for good reasons");
12642 log_error ("See oclHashcat's homepage for official supported GPU drivers");
12643 #ifdef _WIN
12644 log_error ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12645 #endif
12646 log_error ("You can use --force to override this but do not post error reports if you do so");
12647
12648 return (-1);
12649 }
12650 }
12651 }
12652
12653 /*
12654 * Temporary fix:
12655 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
12656 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
12657 * were not working @ full speed (setting hc_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
12658 * Driver / ADL bug?
12659 *
12660
12661
12662 if (vendor_id == VENDOR_ID_AMD)
12663 {
12664 if (powertune_enable == 1)
12665 {
12666 hc_thread_mutex_lock (mux_adl);
12667
12668 for (uint i = 0; i < devices_cnt; i++)
12669 {
12670 if (data.hm_device[i].od_version == 6)
12671 {
12672 // set powertune value only
12673
12674 int powertune_supported = 0;
12675
12676 int ADL_rc = 0;
12677
12678 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll, data.hm_device[i].adapter_index, &powertune_supported)) != ADL_OK)
12679 {
12680 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
12681
12682 return (-1);
12683 }
12684
12685 if (powertune_supported != 0)
12686 {
12687 // powertune set
12688 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
12689
12690 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll, data.hm_device[i].adapter_index, &powertune)) != ADL_OK)
12691 {
12692 log_error ("ERROR: Failed to get current ADL PowerControl settings");
12693
12694 return (-1);
12695 }
12696
12697 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll, data.hm_device[i].adapter_index, powertune.iMaxValue)) != ADL_OK)
12698 {
12699 log_error ("ERROR: Failed to set new ADL PowerControl values");
12700
12701 return (-1);
12702 }
12703 }
12704 }
12705 }
12706
12707 hc_thread_mutex_unlock (mux_adl);
12708 }
12709 }
12710 */
12711
12712 uint gpu_blocks_all = 0;
12713
12714 for (uint device_id = 0; device_id < devices_cnt; device_id++)
12715 {
12716 /**
12717 * host buffer
12718 */
12719
12720 hc_device_param_t *device_param = &data.devices_param[device_id];
12721
12722 /**
12723 * device properties
12724 */
12725
12726 char *device_name = device_param->device_name;
12727 char *device_version = device_param->device_version;
12728 char *driver_version = device_param->driver_version;
12729
12730 uint gpu_processors = device_param->gpu_processors;
12731
12732 /**
12733 * create context for each device
12734 */
12735
12736 device_param->context = hc_clCreateContext (NULL, 1, &device_param->device, NULL, NULL);
12737
12738 /**
12739 * create command-queue
12740 */
12741
12742 // not support with NV
12743 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
12744
12745 device_param->command_queue = hc_clCreateCommandQueue (device_param->context, device_param->device, 0);
12746
12747 /**
12748 * create input buffers on device
12749 */
12750
12751 uint gpu_threads = GPU_THREADS;
12752
12753 if (hash_mode == 3200) gpu_threads = 8;
12754 if (hash_mode == 9000) gpu_threads = 8;
12755
12756 uint gpu_power = gpu_processors * gpu_threads * gpu_accel;
12757 uint gpu_blocks = gpu_power;
12758
12759 device_param->gpu_threads = gpu_threads;
12760 device_param->gpu_power_user = gpu_power;
12761 device_param->gpu_blocks_user = gpu_blocks;
12762
12763 gpu_blocks_all += gpu_blocks;
12764
12765 uint size_pws = gpu_power * sizeof (pw_t);
12766
12767 uint size_tmps = 4;
12768
12769 switch (hash_mode)
12770 {
12771 case 400: size_tmps = gpu_blocks * sizeof (phpass_tmp_t); break;
12772 case 500: size_tmps = gpu_blocks * sizeof (md5crypt_tmp_t); break;
12773 case 501: size_tmps = gpu_blocks * sizeof (md5crypt_tmp_t); break;
12774 case 1600: size_tmps = gpu_blocks * sizeof (md5crypt_tmp_t); break;
12775 case 1800: size_tmps = gpu_blocks * sizeof (sha512crypt_tmp_t); break;
12776 case 2100: size_tmps = gpu_blocks * sizeof (dcc2_tmp_t); break;
12777 case 2500: size_tmps = gpu_blocks * sizeof (wpa_tmp_t); break;
12778 case 3200: size_tmps = gpu_blocks * sizeof (bcrypt_tmp_t); break;
12779 case 5200: size_tmps = gpu_blocks * sizeof (pwsafe3_tmp_t); break;
12780 case 5800: size_tmps = gpu_blocks * sizeof (androidpin_tmp_t); break;
12781 case 6211:
12782 case 6212:
12783 case 6213: size_tmps = gpu_blocks * sizeof (tc_tmp_t); break;
12784 case 6221:
12785 case 6222:
12786 case 6223: size_tmps = gpu_blocks * sizeof (tc64_tmp_t); break;
12787 case 6231:
12788 case 6232:
12789 case 6233: size_tmps = gpu_blocks * sizeof (tc_tmp_t); break;
12790 case 6241:
12791 case 6242:
12792 case 6243: size_tmps = gpu_blocks * sizeof (tc_tmp_t); break;
12793 case 6300: size_tmps = gpu_blocks * sizeof (md5crypt_tmp_t); break;
12794 case 6400: size_tmps = gpu_blocks * sizeof (sha256aix_tmp_t); break;
12795 case 6500: size_tmps = gpu_blocks * sizeof (sha512aix_tmp_t); break;
12796 case 6600: size_tmps = gpu_blocks * sizeof (agilekey_tmp_t); break;
12797 case 6700: size_tmps = gpu_blocks * sizeof (sha1aix_tmp_t); break;
12798 case 6800: size_tmps = gpu_blocks * sizeof (lastpass_tmp_t); break;
12799 case 7100: size_tmps = gpu_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
12800 case 7200: size_tmps = gpu_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
12801 case 7400: size_tmps = gpu_blocks * sizeof (sha256crypt_tmp_t); break;
12802 case 7900: size_tmps = gpu_blocks * sizeof (drupal7_tmp_t); break;
12803 case 8200: size_tmps = gpu_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
12804 case 8800: size_tmps = gpu_blocks * sizeof (androidfde_tmp_t); break;
12805 case 8900: size_tmps = gpu_blocks * sizeof (scrypt_tmp_t); break;
12806 case 9000: size_tmps = gpu_blocks * sizeof (pwsafe2_tmp_t); break;
12807 case 9100: size_tmps = gpu_blocks * sizeof (lotus8_tmp_t); break;
12808 case 9200: size_tmps = gpu_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
12809 case 9300: size_tmps = gpu_blocks * sizeof (scrypt_tmp_t); break;
12810 case 9400: size_tmps = gpu_blocks * sizeof (office2007_tmp_t); break;
12811 case 9500: size_tmps = gpu_blocks * sizeof (office2010_tmp_t); break;
12812 case 9600: size_tmps = gpu_blocks * sizeof (office2013_tmp_t); break;
12813 case 10000: size_tmps = gpu_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
12814 case 10200: size_tmps = gpu_blocks * sizeof (cram_md5_t); break;
12815 case 10300: size_tmps = gpu_blocks * sizeof (saph_sha1_tmp_t); break;
12816 case 10500: size_tmps = gpu_blocks * sizeof (pdf14_tmp_t); break;
12817 case 10700: size_tmps = gpu_blocks * sizeof (pdf17l8_tmp_t); break;
12818 case 10900: size_tmps = gpu_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
12819 case 11300: size_tmps = gpu_blocks * sizeof (bitcoin_wallet_tmp_t); break;
12820 case 11600: size_tmps = gpu_blocks * sizeof (seven_zip_tmp_t); break;
12821 case 11900: size_tmps = gpu_blocks * sizeof (pbkdf2_md5_tmp_t); break;
12822 case 12000: size_tmps = gpu_blocks * sizeof (pbkdf2_sha1_tmp_t); break;
12823 case 12100: size_tmps = gpu_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
12824 case 12200: size_tmps = gpu_blocks * sizeof (ecryptfs_tmp_t); break;
12825 case 12300: size_tmps = gpu_blocks * sizeof (oraclet_tmp_t); break;
12826 case 12400: size_tmps = gpu_blocks * sizeof (bsdicrypt_tmp_t); break;
12827 case 12500: size_tmps = gpu_blocks * sizeof (rar3_tmp_t); break;
12828 case 12700: size_tmps = gpu_blocks * sizeof (mywallet_tmp_t); break;
12829 case 12800: size_tmps = gpu_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
12830 };
12831
12832 uint size_hooks = 4;
12833
12834 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
12835 {
12836 // insert correct hook size
12837 }
12838
12839 // we can optimize some stuff here...
12840
12841 device_param->size_pws = size_pws;
12842 device_param->size_tmps = size_tmps;
12843 device_param->size_hooks = size_hooks;
12844
12845 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
12846 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
12847
12848 device_param->size_root_css = size_root_css;
12849 device_param->size_markov_css = size_markov_css;
12850
12851 uint size_results = GPU_THREADS * sizeof (uint);
12852
12853 device_param->size_results = size_results;
12854
12855 uint size_rules = gpu_rules_cnt * sizeof (gpu_rule_t);
12856 uint size_rules_c = GPU_RULES * sizeof (gpu_rule_t);
12857 uint size_plains = digests_cnt * sizeof (plain_t);
12858 uint size_salts = salts_cnt * sizeof (salt_t);
12859 uint size_esalts = salts_cnt * esalt_size;
12860
12861 device_param->size_plains = size_plains;
12862 device_param->size_digests = size_digests;
12863 device_param->size_shown = size_shown;
12864 device_param->size_salts = size_salts;
12865
12866 uint size_combs = GPU_COMBS * sizeof (comb_t);
12867 uint size_bfs = GPU_BFS * sizeof (bf_t);
12868 uint size_tm = 32 * sizeof (bs_word_t);
12869
12870 uint64_t size_scryptV = 1;
12871
12872 if ((hash_mode == 8900) || (hash_mode == 9300))
12873 {
12874 #define SHADER_PER_MP 8
12875 #define WAVEFRONTS 64
12876
12877 uint tmto_start = 2;
12878 uint tmto_stop = 1024;
12879
12880 if (scrypt_tmto)
12881 {
12882 tmto_start = 1 << scrypt_tmto;
12883 tmto_stop = tmto_start + 1;
12884 }
12885
12886 for (uint tmto = tmto_start; tmto < tmto_stop; tmto <<= 1)
12887 {
12888 // todo -- make sure all salts get the new tmto value
12889
12890 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
12891
12892 size_scryptV /= tmto;
12893
12894 size_scryptV *= gpu_processors * WAVEFRONTS * SHADER_PER_MP;
12895
12896 if (size_scryptV > (device_param->gpu_maxmem_alloc / 2)) continue;
12897
12898 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
12899 {
12900 data.salts_buf[salts_pos].scrypt_tmto = tmto;
12901 data.salts_buf[salts_pos].scrypt_phy = gpu_processors * WAVEFRONTS * SHADER_PER_MP;
12902 }
12903
12904 break;
12905 }
12906
12907 if (data.salts_buf[0].scrypt_tmto == 0)
12908 {
12909 log_error ("ERROR: can't allocate enough GPU memory");
12910
12911 return -1;
12912 }
12913
12914 if (quiet == 0) log_info ("");
12915 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u\n", data.salts_buf[0].scrypt_tmto);
12916 }
12917
12918 /**
12919 * kernel find
12920 */
12921
12922 char build_opts[100];
12923
12924 // we don't have sm_* on AMD but it doesn't matter
12925
12926 sprintf (build_opts, "-I. -IOpenCL/ -DVENDOR_ID=%d -DCUDA_ARCH=%d", vendor_id, (device_param->sm_major * 100) + device_param->sm_minor);
12927
12928 struct stat st;
12929
12930 char kernel_file[256];
12931
12932 memset (kernel_file, 0, sizeof (kernel_file));
12933
12934 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
12935
12936 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
12937
12938 #ifdef BINARY_KERNEL
12939 if (force_jit_compilation == 0)
12940 {
12941 if (attack_exec == ATTACK_EXEC_ON_GPU)
12942 {
12943 if (attack_kern == ATTACK_KERN_STRAIGHT)
12944 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);
12945 else if (attack_kern == ATTACK_KERN_COMBI)
12946 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);
12947 else if (attack_kern == ATTACK_KERN_BF)
12948 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);
12949 }
12950 else
12951 {
12952 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);
12953
12954 if ((hash_mode == 8900) || (hash_mode == 9300))
12955 {
12956 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);
12957 }
12958 }
12959
12960 if (stat (kernel_file, &st) == -1)
12961 {
12962 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, kernel_file);
12963
12964 char module_file[256];
12965
12966 memset (module_file, 0, sizeof (module_file));
12967
12968 if (attack_exec == ATTACK_EXEC_ON_GPU)
12969 {
12970 if (attack_kern == ATTACK_KERN_STRAIGHT)
12971 snprintf (module_file, sizeof (module_file) - 1, "%s/kernels/4098/m%05d_a0.llvmir", install_dir, (int) kern_type);
12972 else if (attack_kern == ATTACK_KERN_COMBI)
12973 snprintf (module_file, sizeof (module_file) - 1, "%s/kernels/4098/m%05d_a1.llvmir", install_dir, (int) kern_type);
12974 else if (attack_kern == ATTACK_KERN_BF)
12975 snprintf (module_file, sizeof (module_file) - 1, "%s/kernels/4098/m%05d_a3.llvmir", install_dir, (int) kern_type);
12976 }
12977 else
12978 {
12979 snprintf (module_file, sizeof (module_file) - 1, "%s/kernels/4098/m%05d.llvmir", install_dir, (int) kern_type);
12980
12981 if ((hash_mode == 8900) || (hash_mode == 9300))
12982 {
12983 snprintf (module_file, sizeof (module_file) - 1, "%s/kernels/4098/m%05d_%d_%d_%d_%d.llvmir", install_dir, (int) kern_type, data.salts_buf[0].scrypt_N, data.salts_buf[0].scrypt_r, data.salts_buf[0].scrypt_p, data.salts_buf[0].scrypt_tmto);
12984 }
12985 }
12986
12987 load_kernel (module_file, 1, kernel_lengths, kernel_sources);
12988
12989 cl_program program = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
12990
12991 local_free (kernel_sources[0]);
12992
12993 hc_clBuildProgram (program, 1, &device_param->device, build_opts, NULL, NULL);
12994
12995 size_t binary_size;
12996
12997 clGetProgramInfo (program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
12998
12999 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13000
13001 clGetProgramInfo (program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13002
13003 writeProgramBin (kernel_file, binary, binary_size);
13004
13005 local_free (binary);
13006
13007 stat (kernel_file, &st); // to reload filesize
13008 }
13009 }
13010 else
13011 {
13012 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, install_dir, kernel_file);
13013
13014 if (stat (kernel_file, &st) == -1)
13015 {
13016 log_error ("ERROR: %s: %s", kernel_file, strerror (errno));
13017
13018 return -1;
13019 }
13020 }
13021
13022 #else
13023
13024 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, install_dir, kernel_file);
13025
13026 if (stat (kernel_file, &st) == -1)
13027 {
13028 log_error ("ERROR: %s: %s", kernel_file, strerror (errno));
13029
13030 return -1;
13031 }
13032
13033 #endif
13034
13035 load_kernel (kernel_file, 1, kernel_lengths, kernel_sources);
13036
13037 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, kernel_file, st.st_size);
13038
13039 #ifdef BINARY_KERNEL
13040 if (force_jit_compilation == 0)
13041 {
13042 device_param->program = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13043 }
13044 else
13045 {
13046 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13047 }
13048 #else
13049 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13050 #endif
13051
13052 local_free (kernel_lengths);
13053
13054 local_free (kernel_sources[0]);
13055
13056 local_free (kernel_sources)
13057
13058 /**
13059 * kernel mp find
13060 */
13061
13062 if (attack_mode != ATTACK_MODE_STRAIGHT)
13063 {
13064 char kernel_mp_file[256];
13065
13066 memset (kernel_mp_file, 0, sizeof (kernel_mp_file));
13067
13068 size_t *kernel_mp_lengths = (size_t *) mymalloc (sizeof (size_t));
13069
13070 const unsigned char **kernel_mp_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13071
13072 #ifdef BINARY_KERNEL
13073 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
13074 {
13075 snprintf (kernel_mp_file, sizeof (kernel_mp_file) - 1, "%s/kernels/4098/markov_be.%s_%s_%s_%d.kernel", install_dir, device_name, device_version, driver_version, COMPTIME);
13076 }
13077 else
13078 {
13079 snprintf (kernel_mp_file, sizeof (kernel_mp_file) - 1, "%s/kernels/4098/markov_le.%s_%s_%s_%d.kernel", install_dir, device_name, device_version, driver_version, COMPTIME);
13080 }
13081
13082 if (stat (kernel_mp_file, &st) == -1)
13083 {
13084 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, kernel_mp_file);
13085
13086 char module_mp_file[256];
13087
13088 memset (module_mp_file, 0, sizeof (module_mp_file));
13089
13090 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
13091 {
13092 snprintf (module_mp_file, sizeof (module_mp_file) - 1, "%s/kernels/4098/markov_be.llvmir", install_dir);
13093 }
13094 else
13095 {
13096 snprintf (module_mp_file, sizeof (module_mp_file) - 1, "%s/kernels/4098/markov_le.llvmir", install_dir);
13097 }
13098
13099 load_kernel (module_mp_file, 1, kernel_mp_lengths, kernel_mp_sources);
13100
13101 cl_program program_mp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_mp_lengths, (const unsigned char **) kernel_mp_sources, NULL);
13102
13103 local_free (kernel_mp_sources[0]);
13104
13105 hc_clBuildProgram (program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13106
13107 size_t binary_mp_size;
13108
13109 clGetProgramInfo (program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_mp_size, NULL);
13110
13111 unsigned char *binary_mp = (unsigned char *) mymalloc (binary_mp_size);
13112
13113 clGetProgramInfo (program_mp, CL_PROGRAM_BINARIES, sizeof (binary_mp), &binary_mp, NULL);
13114
13115 writeProgramBin (kernel_mp_file, binary_mp, binary_mp_size);
13116
13117 local_free (binary_mp);
13118
13119 stat (kernel_mp_file, &st); // to reload filesize
13120 }
13121
13122 #else
13123 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
13124 {
13125 snprintf (kernel_mp_file, sizeof (kernel_mp_file) - 1, "%s/OpenCL/markov_be.cl", install_dir);
13126 }
13127 else
13128 {
13129 snprintf (kernel_mp_file, sizeof (kernel_mp_file) - 1, "%s/OpenCL/markov_le.cl", install_dir);
13130 }
13131
13132 if (stat (kernel_mp_file, &st) == -1)
13133 {
13134 log_error ("ERROR: %s: %s", kernel_mp_file, strerror (errno));
13135
13136 return -1;
13137 }
13138
13139 #endif
13140
13141 load_kernel (kernel_mp_file, 1, kernel_mp_lengths, kernel_mp_sources);
13142
13143 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, kernel_mp_file, st.st_size);
13144
13145 #ifdef BINARY_KERNEL
13146 device_param->program_mp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_mp_lengths, (const unsigned char **) kernel_mp_sources, NULL);
13147 #else
13148 device_param->program_mp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_mp_sources, NULL);
13149 #endif
13150
13151 local_free (kernel_mp_lengths);
13152
13153 local_free (kernel_mp_sources[0]);
13154
13155 local_free (kernel_mp_sources);
13156 }
13157
13158 /**
13159 * kernel amp find
13160 */
13161
13162 if (attack_exec == ATTACK_EXEC_ON_GPU)
13163 {
13164 // nothing to do
13165 }
13166 else
13167 {
13168 char kernel_amp_file[256];
13169
13170 memset (kernel_amp_file, 0, sizeof (kernel_amp_file));
13171
13172 size_t *kernel_amp_lengths = (size_t *) mymalloc (sizeof (size_t));
13173
13174 const unsigned char **kernel_amp_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13175
13176 #ifdef BINARY_KERNEL
13177 snprintf (kernel_amp_file, sizeof (kernel_amp_file) - 1, "%s/kernels/4098/amp_a%d.%s_%s_%s_%d.kernel", install_dir, attack_kern, device_name, device_version, driver_version, COMPTIME);
13178
13179 if (stat (kernel_amp_file, &st) == -1)
13180 {
13181 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, kernel_amp_file);
13182
13183 char module_amp_file[256];
13184
13185 memset (module_amp_file, 0, sizeof (module_amp_file));
13186
13187 snprintf (module_amp_file, sizeof (module_amp_file) - 1, "%s/kernels/4098/amp_a%d.llvmir", install_dir, attack_kern);
13188
13189 load_kernel (module_amp_file, 1, kernel_amp_lengths, kernel_amp_sources);
13190
13191 cl_program program_amp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_amp_lengths, (const unsigned char **) kernel_amp_sources, NULL);
13192
13193 local_free (kernel_amp_sources[0]);
13194
13195 hc_clBuildProgram (program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13196
13197 size_t binary_amp_size;
13198
13199 clGetProgramInfo (program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_amp_size, NULL);
13200
13201 unsigned char *binary_amp = (unsigned char *) mymalloc (binary_amp_size);
13202
13203 clGetProgramInfo (program_amp, CL_PROGRAM_BINARIES, sizeof (binary_amp), &binary_amp, NULL);
13204
13205 writeProgramBin (kernel_amp_file, binary_amp, binary_amp_size);
13206
13207 local_free (binary_amp);
13208
13209 stat (kernel_amp_file, &st); // to reload filesize
13210 }
13211 #else
13212 snprintf (kernel_amp_file, sizeof (kernel_amp_file) - 1, "%s/OpenCL/amp_a%d.cl", install_dir, attack_kern);
13213
13214 if (stat (kernel_amp_file, &st) == -1)
13215 {
13216 log_error ("ERROR: %s: %s", kernel_amp_file, strerror (errno));
13217
13218 return -1;
13219 }
13220 #endif
13221
13222 load_kernel (kernel_amp_file, 1, kernel_amp_lengths, kernel_amp_sources);
13223
13224 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, kernel_amp_file, st.st_size);
13225
13226 #ifdef BINARY_KERNEL
13227 device_param->program_amp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_amp_lengths, (const unsigned char **) kernel_amp_sources, NULL);
13228 #else
13229 device_param->program_amp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_amp_sources, NULL);
13230 #endif
13231
13232 local_free (kernel_amp_lengths);
13233
13234 local_free (kernel_amp_sources[0]);
13235
13236 local_free (kernel_amp_sources);
13237 }
13238
13239 /**
13240 * kernel compile
13241 */
13242
13243 #ifdef BINARY_KERNEL
13244
13245 if (force_jit_compilation == 0)
13246 {
13247 // nothing to do
13248 }
13249 else if (force_jit_compilation == 1500)
13250 {
13251 sprintf (build_opts, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13252 }
13253 else if (force_jit_compilation == 8900)
13254 {
13255 sprintf (build_opts, "%s -DSCRYPT_N=%d -DSCRYPT_R=%d -DSCRYPT_P=%d -DSCRYPT_TMTO=%d", build_opts, data.salts_buf[0].scrypt_N, data.salts_buf[0].scrypt_r, data.salts_buf[0].scrypt_p, data.salts_buf[0].scrypt_tmto);
13256 }
13257
13258 #endif
13259
13260 clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13261
13262 size_t ret_val_size = 0;
13263
13264 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13265
13266 if (ret_val_size > 1)
13267 {
13268 char *build_log = (char *) malloc (ret_val_size + 1);
13269
13270 memset (build_log, 0, ret_val_size + 1);
13271
13272 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13273
13274 puts (build_log);
13275
13276 free (build_log);
13277 }
13278
13279 if (attack_mode != ATTACK_MODE_STRAIGHT)
13280 {
13281 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13282 }
13283
13284 if (attack_exec == ATTACK_EXEC_ON_GPU)
13285 {
13286 // nothing to do
13287 }
13288 else
13289 {
13290 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13291 }
13292
13293 /**
13294 * amp is not independent
13295 */
13296
13297 if (attack_exec == ATTACK_EXEC_ON_GPU)
13298 {
13299 // nothing to do
13300 }
13301 else
13302 {
13303 device_param->kernel_amp = hc_clCreateKernel (device_param->program_amp, "amp");
13304 }
13305
13306 /**
13307 * global buffers
13308 */
13309
13310 device_param->d_pws_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13311 device_param->d_pws_amp_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13312 device_param->d_tmps = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
13313 device_param->d_hooks = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
13314 device_param->d_bitmap_s1_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13315 device_param->d_bitmap_s1_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13316 device_param->d_bitmap_s1_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13317 device_param->d_bitmap_s1_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13318 device_param->d_bitmap_s2_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13319 device_param->d_bitmap_s2_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13320 device_param->d_bitmap_s2_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13321 device_param->d_bitmap_s2_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13322 device_param->d_plain_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
13323 device_param->d_digests_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
13324 device_param->d_digests_shown = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
13325 device_param->d_salt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
13326 device_param->d_result = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
13327 device_param->d_scryptV_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
13328
13329 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_a, CL_TRUE, 0, bitmap_size, bitmap_s1_a, 0, NULL, NULL);
13330 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_b, CL_TRUE, 0, bitmap_size, bitmap_s1_b, 0, NULL, NULL);
13331 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_c, CL_TRUE, 0, bitmap_size, bitmap_s1_c, 0, NULL, NULL);
13332 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_d, CL_TRUE, 0, bitmap_size, bitmap_s1_d, 0, NULL, NULL);
13333 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_a, CL_TRUE, 0, bitmap_size, bitmap_s2_a, 0, NULL, NULL);
13334 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_b, CL_TRUE, 0, bitmap_size, bitmap_s2_b, 0, NULL, NULL);
13335 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_c, CL_TRUE, 0, bitmap_size, bitmap_s2_c, 0, NULL, NULL);
13336 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_d, CL_TRUE, 0, bitmap_size, bitmap_s2_d, 0, NULL, NULL);
13337 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
13338 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
13339 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
13340
13341 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
13342 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
13343 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
13344 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
13345 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
13346 run_kernel_bzero (device_param, device_param->d_result, size_results);
13347
13348 /**
13349 * special buffers
13350 */
13351
13352 if (attack_kern == ATTACK_KERN_STRAIGHT)
13353 {
13354 device_param->d_rules = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
13355 device_param->d_rules_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
13356
13357 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, gpu_rules_buf, 0, NULL, NULL);
13358
13359 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
13360 }
13361 else if (attack_kern == ATTACK_KERN_COMBI)
13362 {
13363 device_param->d_combs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13364 device_param->d_combs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13365 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13366 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13367
13368 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
13369 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
13370 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13371 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13372 }
13373 else if (attack_kern == ATTACK_KERN_BF)
13374 {
13375 device_param->d_bfs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13376 device_param->d_bfs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13377 device_param->d_tm_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
13378 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13379 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13380
13381 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
13382 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
13383 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
13384 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13385 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13386 }
13387
13388 if (size_esalts)
13389 {
13390 device_param->d_esalt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
13391
13392 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
13393 }
13394
13395 /**
13396 * main host data
13397 */
13398
13399 uint *result = (uint *) mymalloc (size_results);
13400
13401 memset (result, 0, size_results);
13402
13403 device_param->result = result;
13404
13405 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
13406
13407 memset (pws_buf, 0, size_pws);
13408
13409 device_param->pws_buf = pws_buf;
13410
13411 pw_cache_t *pw_caches = (pw_cache_t *) mycalloc (64, sizeof (pw_cache_t));
13412
13413 for (int i = 0; i < 64; i++)
13414 {
13415 pw_caches[i].pw_buf.pw_len = i;
13416 pw_caches[i].cnt = 0;
13417 }
13418
13419 device_param->pw_caches = pw_caches;
13420
13421 comb_t *combs_buf = (comb_t *) mycalloc (GPU_COMBS, sizeof (comb_t));
13422
13423 device_param->combs_buf = combs_buf;
13424
13425 void *hooks_buf = mymalloc (size_hooks);
13426
13427 device_param->hooks_buf = hooks_buf;
13428
13429 device_param->pw_transpose = pw_transpose_to_hi1;
13430 device_param->pw_add = pw_add_to_hc1;
13431
13432 /**
13433 * kernel args
13434 */
13435
13436 device_param->kernel_params_buf32[21] = bitmap_mask;
13437 device_param->kernel_params_buf32[22] = bitmap_shift1;
13438 device_param->kernel_params_buf32[23] = bitmap_shift2;
13439 device_param->kernel_params_buf32[24] = 0; // salt_pos
13440 device_param->kernel_params_buf32[25] = 0; // loop_pos
13441 device_param->kernel_params_buf32[26] = 0; // loop_cnt
13442 device_param->kernel_params_buf32[27] = 0; // gpu_rules_cnt
13443 device_param->kernel_params_buf32[28] = 0; // digests_cnt
13444 device_param->kernel_params_buf32[29] = 0; // digests_offset
13445 device_param->kernel_params_buf32[30] = 0; // combs_mode
13446 device_param->kernel_params_buf32[31] = 0; // gid_max
13447
13448 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_ON_GPU)
13449 ? &device_param->d_pws_buf
13450 : &device_param->d_pws_amp_buf;
13451 device_param->kernel_params[ 1] = &device_param->d_rules_c;
13452 device_param->kernel_params[ 2] = &device_param->d_combs_c;
13453 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
13454 device_param->kernel_params[ 4] = &device_param->d_tmps;
13455 device_param->kernel_params[ 5] = &device_param->d_hooks;
13456 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
13457 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
13458 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
13459 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
13460 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
13461 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
13462 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
13463 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
13464 device_param->kernel_params[14] = &device_param->d_plain_bufs;
13465 device_param->kernel_params[15] = &device_param->d_digests_buf;
13466 device_param->kernel_params[16] = &device_param->d_digests_shown;
13467 device_param->kernel_params[17] = &device_param->d_salt_bufs;
13468 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
13469 device_param->kernel_params[19] = &device_param->d_result;
13470 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
13471 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
13472 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
13473 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
13474 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
13475 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
13476 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
13477 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
13478 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
13479 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
13480 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
13481 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
13482
13483 device_param->kernel_params_mp_buf64[3] = 0;
13484 device_param->kernel_params_mp_buf32[4] = 0;
13485 device_param->kernel_params_mp_buf32[5] = 0;
13486 device_param->kernel_params_mp_buf32[6] = 0;
13487 device_param->kernel_params_mp_buf32[7] = 0;
13488 device_param->kernel_params_mp_buf32[8] = 0;
13489
13490 device_param->kernel_params_mp[0] = NULL;
13491 device_param->kernel_params_mp[1] = NULL;
13492 device_param->kernel_params_mp[2] = NULL;
13493 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
13494 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
13495 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
13496 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
13497 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
13498 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
13499
13500 device_param->kernel_params_mp_l_buf64[3] = 0;
13501 device_param->kernel_params_mp_l_buf32[4] = 0;
13502 device_param->kernel_params_mp_l_buf32[5] = 0;
13503 device_param->kernel_params_mp_l_buf32[6] = 0;
13504 device_param->kernel_params_mp_l_buf32[7] = 0;
13505 device_param->kernel_params_mp_l_buf32[8] = 0;
13506 device_param->kernel_params_mp_l_buf32[9] = 0;
13507
13508 device_param->kernel_params_mp_l[0] = NULL;
13509 device_param->kernel_params_mp_l[1] = NULL;
13510 device_param->kernel_params_mp_l[2] = NULL;
13511 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
13512 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
13513 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
13514 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
13515 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
13516 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
13517 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
13518
13519 device_param->kernel_params_mp_r_buf64[3] = 0;
13520 device_param->kernel_params_mp_r_buf32[4] = 0;
13521 device_param->kernel_params_mp_r_buf32[5] = 0;
13522 device_param->kernel_params_mp_r_buf32[6] = 0;
13523 device_param->kernel_params_mp_r_buf32[7] = 0;
13524 device_param->kernel_params_mp_r_buf32[8] = 0;
13525
13526 device_param->kernel_params_mp_r[0] = NULL;
13527 device_param->kernel_params_mp_r[1] = NULL;
13528 device_param->kernel_params_mp_r[2] = NULL;
13529 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
13530 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
13531 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
13532 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
13533 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
13534 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
13535
13536 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
13537 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
13538
13539 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
13540 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
13541 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
13542 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
13543 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
13544 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
13545 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
13546
13547 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
13548
13549 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
13550 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
13551
13552 /**
13553 * kernel name
13554 */
13555
13556 char kernel_name[64];
13557
13558 memset (kernel_name, 0, sizeof (kernel_name));
13559
13560 if (attack_exec == ATTACK_EXEC_ON_GPU)
13561 {
13562 if (opti_type & OPTI_TYPE_SINGLE_HASH)
13563 {
13564 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
13565
13566 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
13567
13568 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
13569
13570 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
13571
13572 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
13573
13574 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
13575 }
13576 else
13577 {
13578 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
13579
13580 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
13581
13582 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
13583
13584 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
13585
13586 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
13587
13588 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
13589 }
13590
13591 if (data.attack_mode == ATTACK_MODE_BF)
13592 {
13593 if (opts_type & OPTS_TYPE_PT_BITSLICE)
13594 {
13595 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
13596
13597 device_param->kernel_tb = hc_clCreateKernel (device_param->program, kernel_name);
13598
13599 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
13600
13601 device_param->kernel_tm = hc_clCreateKernel (device_param->program, kernel_name);
13602 }
13603 }
13604 }
13605 else
13606 {
13607 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
13608
13609 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
13610
13611 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
13612
13613 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
13614
13615 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
13616
13617 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
13618
13619 if (opts_type & OPTS_TYPE_HOOK12)
13620 {
13621 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
13622
13623 device_param->kernel12 = hc_clCreateKernel (device_param->program, kernel_name);
13624 }
13625
13626 if (opts_type & OPTS_TYPE_HOOK23)
13627 {
13628 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
13629
13630 device_param->kernel23 = hc_clCreateKernel (device_param->program, kernel_name);
13631 }
13632 }
13633
13634 for (uint i = 0; i <= 20; i++)
13635 {
13636 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
13637 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
13638 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
13639
13640 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
13641 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
13642 }
13643
13644 for (uint i = 21; i <= 31; i++)
13645 {
13646 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
13647 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
13648 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
13649
13650 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
13651 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
13652 }
13653
13654 if (attack_mode == ATTACK_MODE_BF)
13655 {
13656 device_param->kernel_mp_l = hc_clCreateKernel (device_param->program_mp, "l_markov");
13657 device_param->kernel_mp_r = hc_clCreateKernel (device_param->program_mp, "r_markov");
13658
13659 if (opts_type & OPTS_TYPE_PT_BITSLICE)
13660 {
13661 hc_clSetKernelArg (device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
13662
13663 hc_clSetKernelArg (device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
13664 hc_clSetKernelArg (device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
13665 }
13666 }
13667 else if (attack_mode == ATTACK_MODE_HYBRID1)
13668 {
13669 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
13670 }
13671 else if (attack_mode == ATTACK_MODE_HYBRID2)
13672 {
13673 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
13674 }
13675
13676 if (attack_exec == ATTACK_EXEC_ON_GPU)
13677 {
13678 // nothing to do
13679 }
13680 else
13681 {
13682 for (uint i = 0; i < 5; i++)
13683 {
13684 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
13685 }
13686
13687 for (uint i = 5; i < 7; i++)
13688 {
13689 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
13690 }
13691 }
13692
13693 /**
13694 * Store initial fanspeed if gpu_temp_retain is enabled
13695 */
13696
13697 int gpu_temp_retain_set = 0;
13698
13699 /*
13700 if (gpu_temp_disable == 0)
13701 {
13702 if (gpu_temp_retain != 0)
13703 {
13704 hc_thread_mutex_lock (mux_adl);
13705
13706 if (data.hm_device[device_id].fan_supported == 1)
13707 {
13708 if (gpu_temp_retain_chgd == 0)
13709 {
13710 uint cur_temp = 0;
13711 uint default_temp = 0;
13712
13713 int ADL_rc = hc_ADL_Overdrive6_TargetTemperatureData_Get (data.hm_dll, data.hm_device[device_id].adapter_index, (int *) &cur_temp, (int *) &default_temp);
13714
13715 if (ADL_rc == ADL_OK)
13716 {
13717 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
13718
13719 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
13720
13721 // special case with multi gpu setups: always use minimum retain
13722
13723 if (gpu_temp_retain_set == 0)
13724 {
13725 gpu_temp_retain = gpu_temp_retain_target;
13726 gpu_temp_retain_set = 1;
13727 }
13728 else
13729 {
13730 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
13731 }
13732
13733 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
13734 }
13735 }
13736
13737 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
13738
13739 temp_retain_fanspeed_value[device_id] = fan_speed;
13740
13741 if (fan_speed == -1)
13742 {
13743 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
13744
13745 temp_retain_fanspeed_value[device_id] = 0;
13746 }
13747 }
13748
13749 hc_thread_mutex_unlock (mux_adl);
13750 }
13751 }
13752 */
13753
13754 /**
13755 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
13756 */
13757
13758 /*
13759 if (powertune_enable == 1)
13760 {
13761 hc_thread_mutex_lock (mux_adl);
13762
13763 if (data.hm_device[device_id].od_version == 6)
13764 {
13765 int ADL_rc;
13766
13767 // check powertune capabilities first, if not available then skip device
13768
13769 int powertune_supported = 0;
13770
13771 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll, data.hm_device[device_id].adapter_index, &powertune_supported)) != ADL_OK)
13772 {
13773 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13774
13775 return (-1);
13776 }
13777
13778 if (powertune_supported != 0)
13779 {
13780 // powercontrol settings
13781
13782 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13783
13784 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll, data.hm_device[device_id].adapter_index, &powertune)) == ADL_OK)
13785 {
13786 ADL_rc = hc_ADL_Overdrive_PowerControl_Get (data.hm_dll, data.hm_device[device_id].adapter_index, &od_power_control_status[device_id]);
13787 }
13788
13789 if (ADL_rc != ADL_OK)
13790 {
13791 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13792
13793 return (-1);
13794 }
13795
13796 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll, data.hm_device[device_id].adapter_index, powertune.iMaxValue)) != ADL_OK)
13797 {
13798 log_error ("ERROR: Failed to set new ADL PowerControl values");
13799
13800 return (-1);
13801 }
13802
13803 // clocks
13804
13805 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
13806
13807 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
13808
13809 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)
13810 {
13811 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
13812
13813 return (-1);
13814 }
13815
13816 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
13817
13818 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
13819
13820 if ((ADL_rc = hc_ADL_Overdrive_Capabilities_Get (data.hm_dll, data.hm_device[device_id].adapter_index, &caps)) != ADL_OK)
13821 {
13822 log_error ("ERROR: Failed to get ADL device capabilities");
13823
13824 return (-1);
13825 }
13826
13827 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
13828 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
13829
13830 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
13831 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
13832
13833 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
13834 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
13835
13836 // warning if profile has to low max values
13837
13838 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
13839 {
13840 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
13841 }
13842
13843 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
13844 {
13845 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
13846 }
13847
13848 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
13849
13850 performance_state->iNumberOfPerformanceLevels = 2;
13851
13852 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
13853 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
13854 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
13855 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
13856
13857 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)
13858 {
13859 log_info ("ERROR: Failed to set ADL performance state");
13860
13861 return (-1);
13862 }
13863
13864 local_free (performance_state);
13865 }
13866 }
13867
13868 hc_thread_mutex_unlock (mux_adl);
13869 }
13870 */
13871 }
13872
13873 data.gpu_blocks_all = gpu_blocks_all;
13874
13875 if (data.quiet == 0) log_info ("");
13876
13877 /**
13878 * Inform user which algorithm is checked and at which workload setting
13879 */
13880
13881 if (benchmark == 1)
13882 {
13883 quiet = 0;
13884
13885 data.quiet = quiet;
13886
13887 char *hash_type = strhashtype (data.hash_mode); // not a bug
13888
13889 log_info ("Hashtype: %s", hash_type);
13890 log_info ("Workload: %u loops, %u accel", gpu_loops, gpu_accel);
13891 log_info ("");
13892 }
13893
13894 /**
13895 * keep track of the progress
13896 */
13897
13898 data.words_progress_done = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
13899 data.words_progress_rejected = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
13900 data.words_progress_restored = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
13901
13902 /**
13903 * open filehandles
13904 */
13905
13906 #if _WIN
13907 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
13908 {
13909 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
13910
13911 return (-1);
13912 }
13913
13914 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
13915 {
13916 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
13917
13918 return (-1);
13919 }
13920
13921 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
13922 {
13923 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
13924
13925 return (-1);
13926 }
13927 #endif
13928
13929 /**
13930 * dictionary pad
13931 */
13932
13933 segment_size *= (1024 * 1024);
13934
13935 data.segment_size = segment_size;
13936
13937 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
13938
13939 wl_data->buf = (char *) mymalloc (segment_size);
13940 wl_data->avail = segment_size;
13941 wl_data->incr = segment_size;
13942 wl_data->cnt = 0;
13943 wl_data->pos = 0;
13944
13945 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
13946
13947 data.wordlist_mode = wordlist_mode;
13948
13949 cs_t *css_buf = NULL;
13950 uint css_cnt = 0;
13951 uint dictcnt = 0;
13952 uint maskcnt = 1;
13953 char **masks = NULL;
13954 char **dictfiles = NULL;
13955
13956 uint mask_from_file = 0;
13957
13958 if (attack_mode == ATTACK_MODE_STRAIGHT)
13959 {
13960 if (wordlist_mode == WL_MODE_FILE)
13961 {
13962 int wls_left = myargc - (optind + 1);
13963
13964 for (int i = 0; i < wls_left; i++)
13965 {
13966 char *l0_filename = myargv[optind + 1 + i];
13967
13968 struct stat l0_stat;
13969
13970 if (stat (l0_filename, &l0_stat) == -1)
13971 {
13972 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
13973
13974 return (-1);
13975 }
13976
13977 uint is_dir = S_ISDIR (l0_stat.st_mode);
13978
13979 if (is_dir == 0)
13980 {
13981 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
13982
13983 dictcnt++;
13984
13985 dictfiles[dictcnt - 1] = l0_filename;
13986 }
13987 else
13988 {
13989 // do not allow --keyspace w/ a directory
13990
13991 if (keyspace == 1)
13992 {
13993 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
13994
13995 return (-1);
13996 }
13997
13998 char **dictionary_files = NULL;
13999
14000 dictionary_files = scan_directory (l0_filename);
14001
14002 if (dictionary_files != NULL)
14003 {
14004 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14005
14006 for (int d = 0; dictionary_files[d] != NULL; d++)
14007 {
14008 char *l1_filename = dictionary_files[d];
14009
14010 struct stat l1_stat;
14011
14012 if (stat (l1_filename, &l1_stat) == -1)
14013 {
14014 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14015
14016 return (-1);
14017 }
14018
14019 if (S_ISREG (l1_stat.st_mode))
14020 {
14021 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14022
14023 dictcnt++;
14024
14025 dictfiles[dictcnt - 1] = strdup (l1_filename);
14026 }
14027 }
14028 }
14029
14030 local_free (dictionary_files);
14031 }
14032 }
14033
14034 if (dictcnt < 1)
14035 {
14036 log_error ("ERROR: No usable dictionary file found.");
14037
14038 return (-1);
14039 }
14040 }
14041 else if (wordlist_mode == WL_MODE_STDIN)
14042 {
14043 dictcnt = 1;
14044 }
14045 }
14046 else if (attack_mode == ATTACK_MODE_COMBI)
14047 {
14048 // display
14049
14050 char *dictfile1 = myargv[optind + 1 + 0];
14051 char *dictfile2 = myargv[optind + 1 + 1];
14052
14053 // find the bigger dictionary and use as base
14054
14055 FILE *fp1;
14056 FILE *fp2;
14057
14058 struct stat tmp_stat;
14059
14060 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14061 {
14062 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14063
14064 return (-1);
14065 }
14066
14067 if (stat (dictfile1, &tmp_stat) == -1)
14068 {
14069 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14070
14071 fclose (fp1);
14072
14073 return (-1);
14074 }
14075
14076 if (S_ISDIR (tmp_stat.st_mode))
14077 {
14078 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14079
14080 fclose (fp1);
14081
14082 return (-1);
14083 }
14084
14085 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14086 {
14087 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14088
14089 fclose (fp1);
14090
14091 return (-1);
14092 }
14093
14094 if (stat (dictfile2, &tmp_stat) == -1)
14095 {
14096 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14097
14098 fclose (fp1);
14099 fclose (fp2);
14100
14101 return (-1);
14102 }
14103
14104 if (S_ISDIR (tmp_stat.st_mode))
14105 {
14106 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14107
14108 fclose (fp1);
14109 fclose (fp2);
14110
14111 return (-1);
14112 }
14113
14114 data.combs_cnt = 1;
14115
14116 data.quiet = 1;
14117
14118 const uint64_t words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14119
14120 data.quiet = quiet;
14121
14122 if (words1_cnt == 0)
14123 {
14124 log_error ("ERROR: %s: empty file", dictfile1);
14125
14126 fclose (fp1);
14127 fclose (fp2);
14128
14129 return (-1);
14130 }
14131
14132 data.combs_cnt = 1;
14133
14134 data.quiet = 1;
14135
14136 const uint64_t words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14137
14138 data.quiet = quiet;
14139
14140 if (words2_cnt == 0)
14141 {
14142 log_error ("ERROR: %s: empty file", dictfile2);
14143
14144 fclose (fp1);
14145 fclose (fp2);
14146
14147 return (-1);
14148 }
14149
14150 fclose (fp1);
14151 fclose (fp2);
14152
14153 data.dictfile = dictfile1;
14154 data.dictfile2 = dictfile2;
14155
14156 if (words1_cnt >= words2_cnt)
14157 {
14158 data.combs_cnt = words2_cnt;
14159 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14160
14161 dictfiles = &data.dictfile;
14162
14163 dictcnt = 1;
14164 }
14165 else
14166 {
14167 data.combs_cnt = words1_cnt;
14168 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14169
14170 dictfiles = &data.dictfile2;
14171
14172 dictcnt = 1;
14173
14174 // we also have to switch wordlist related rules!
14175
14176 char *tmpc = data.rule_buf_l;
14177
14178 data.rule_buf_l = data.rule_buf_r;
14179 data.rule_buf_r = tmpc;
14180
14181 int tmpi = data.rule_len_l;
14182
14183 data.rule_len_l = data.rule_len_r;
14184 data.rule_len_r = tmpi;
14185 }
14186 }
14187 else if (attack_mode == ATTACK_MODE_BF)
14188 {
14189 char *mask = NULL;
14190
14191 maskcnt = 0;
14192
14193 if (benchmark == 0)
14194 {
14195 mask = myargv[optind + 1];
14196
14197 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
14198
14199 if ((optind + 2) <= myargc)
14200 {
14201 struct stat file_stat;
14202
14203 if (stat (mask, &file_stat) == -1)
14204 {
14205 maskcnt = 1;
14206
14207 masks[maskcnt - 1] = mystrdup (mask);
14208 }
14209 else
14210 {
14211 int wls_left = myargc - (optind + 1);
14212
14213 uint masks_avail = INCR_MASKS;
14214
14215 for (int i = 0; i < wls_left; i++)
14216 {
14217 if (i != 0)
14218 {
14219 mask = myargv[optind + 1 + i];
14220
14221 if (stat (mask, &file_stat) == -1)
14222 {
14223 log_error ("ERROR: %s: %s", mask, strerror (errno));
14224
14225 return (-1);
14226 }
14227 }
14228
14229 uint is_file = S_ISREG (file_stat.st_mode);
14230
14231 if (is_file == 1)
14232 {
14233 FILE *mask_fp;
14234
14235 if ((mask_fp = fopen (mask, "r")) == NULL)
14236 {
14237 log_error ("ERROR: %s: %s", mask, strerror (errno));
14238
14239 return (-1);
14240 }
14241
14242 char line_buf[BUFSIZ];
14243
14244 while (!feof (mask_fp))
14245 {
14246 memset (line_buf, 0, BUFSIZ);
14247
14248 int line_len = fgetl (mask_fp, line_buf);
14249
14250 if (line_len == 0) continue;
14251
14252 if (line_buf[0] == '#') continue;
14253
14254 if (masks_avail == maskcnt)
14255 {
14256 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14257
14258 masks_avail += INCR_MASKS;
14259 }
14260
14261 masks[maskcnt] = mystrdup (line_buf);
14262
14263 maskcnt++;
14264 }
14265
14266 fclose (mask_fp);
14267 }
14268 else
14269 {
14270 log_error ("ERROR: %s: unsupported file-type", mask);
14271
14272 return (-1);
14273 }
14274 }
14275
14276 mask_from_file = 1;
14277 }
14278 }
14279 else
14280 {
14281 custom_charset_1 = (char *) "?l?d?u";
14282 custom_charset_2 = (char *) "?l?d";
14283 custom_charset_3 = (char *) "?l?d*!$@_";
14284
14285 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
14286 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
14287 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
14288
14289 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
14290
14291 wordlist_mode = WL_MODE_MASK;
14292
14293 data.wordlist_mode = wordlist_mode;
14294
14295 increment = 1;
14296
14297 maskcnt = 1;
14298 }
14299 }
14300 else
14301 {
14302 /**
14303 * generate full masks and charsets
14304 */
14305
14306 masks = (char **) mymalloc (sizeof (char *));
14307
14308 switch (hash_mode)
14309 {
14310 case 1731: pw_min = 5;
14311 pw_max = 5;
14312 mask = mystrdup ("?b?b?b?b?b");
14313 break;
14314 case 12500: pw_min = 5;
14315 pw_max = 5;
14316 mask = mystrdup ("?b?b?b?b?b");
14317 break;
14318 default: pw_min = 7;
14319 pw_max = 7;
14320 mask = mystrdup ("?b?b?b?b?b?b?b");
14321 break;
14322 }
14323
14324 maskcnt = 1;
14325
14326 masks[maskcnt - 1] = mystrdup (mask);
14327
14328 wordlist_mode = WL_MODE_MASK;
14329
14330 data.wordlist_mode = wordlist_mode;
14331
14332 increment = 1;
14333 }
14334
14335 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
14336
14337 if (increment)
14338 {
14339 if (increment_min > pw_min) pw_min = increment_min;
14340
14341 if (increment_max < pw_max) pw_max = increment_max;
14342 }
14343 }
14344 else if (attack_mode == ATTACK_MODE_HYBRID1)
14345 {
14346 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14347
14348 // display
14349
14350 char *mask = myargv[myargc - 1];
14351
14352 maskcnt = 0;
14353
14354 masks = (char **) mymalloc (1 * sizeof (char *));
14355
14356 // mod
14357
14358 struct stat file_stat;
14359
14360 if (stat (mask, &file_stat) == -1)
14361 {
14362 maskcnt = 1;
14363
14364 masks[maskcnt - 1] = mystrdup (mask);
14365 }
14366 else
14367 {
14368 uint is_file = S_ISREG (file_stat.st_mode);
14369
14370 if (is_file == 1)
14371 {
14372 FILE *mask_fp;
14373
14374 if ((mask_fp = fopen (mask, "r")) == NULL)
14375 {
14376 log_error ("ERROR: %s: %s", mask, strerror (errno));
14377
14378 return (-1);
14379 }
14380
14381 char line_buf[BUFSIZ];
14382
14383 uint masks_avail = 1;
14384
14385 while (!feof (mask_fp))
14386 {
14387 memset (line_buf, 0, BUFSIZ);
14388
14389 int line_len = fgetl (mask_fp, line_buf);
14390
14391 if (line_len == 0) continue;
14392
14393 if (line_buf[0] == '#') continue;
14394
14395 if (masks_avail == maskcnt)
14396 {
14397 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14398
14399 masks_avail += INCR_MASKS;
14400 }
14401
14402 masks[maskcnt] = mystrdup (line_buf);
14403
14404 maskcnt++;
14405 }
14406
14407 fclose (mask_fp);
14408
14409 mask_from_file = 1;
14410 }
14411 else
14412 {
14413 maskcnt = 1;
14414
14415 masks[maskcnt - 1] = mystrdup (mask);
14416 }
14417 }
14418
14419 // base
14420
14421 int wls_left = myargc - (optind + 2);
14422
14423 for (int i = 0; i < wls_left; i++)
14424 {
14425 char *filename = myargv[optind + 1 + i];
14426
14427 struct stat file_stat;
14428
14429 if (stat (filename, &file_stat) == -1)
14430 {
14431 log_error ("ERROR: %s: %s", filename, strerror (errno));
14432
14433 return (-1);
14434 }
14435
14436 uint is_dir = S_ISDIR (file_stat.st_mode);
14437
14438 if (is_dir == 0)
14439 {
14440 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14441
14442 dictcnt++;
14443
14444 dictfiles[dictcnt - 1] = filename;
14445 }
14446 else
14447 {
14448 // do not allow --keyspace w/ a directory
14449
14450 if (keyspace == 1)
14451 {
14452 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14453
14454 return (-1);
14455 }
14456
14457 char **dictionary_files = NULL;
14458
14459 dictionary_files = scan_directory (filename);
14460
14461 if (dictionary_files != NULL)
14462 {
14463 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14464
14465 for (int d = 0; dictionary_files[d] != NULL; d++)
14466 {
14467 char *l1_filename = dictionary_files[d];
14468
14469 struct stat l1_stat;
14470
14471 if (stat (l1_filename, &l1_stat) == -1)
14472 {
14473 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14474
14475 return (-1);
14476 }
14477
14478 if (S_ISREG (l1_stat.st_mode))
14479 {
14480 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14481
14482 dictcnt++;
14483
14484 dictfiles[dictcnt - 1] = strdup (l1_filename);
14485 }
14486 }
14487 }
14488
14489 local_free (dictionary_files);
14490 }
14491 }
14492
14493 if (dictcnt < 1)
14494 {
14495 log_error ("ERROR: No usable dictionary file found.");
14496
14497 return (-1);
14498 }
14499
14500 if (increment)
14501 {
14502 maskcnt = 0;
14503
14504 uint mask_min = increment_min; // we can't reject smaller masks here
14505 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
14506
14507 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
14508 {
14509 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
14510
14511 if (cur_mask == NULL) break;
14512
14513 masks[maskcnt] = cur_mask;
14514
14515 maskcnt++;
14516
14517 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
14518 }
14519 }
14520 }
14521 else if (attack_mode == ATTACK_MODE_HYBRID2)
14522 {
14523 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14524
14525 // display
14526
14527 char *mask = myargv[optind + 1 + 0];
14528
14529 maskcnt = 0;
14530
14531 masks = (char **) mymalloc (1 * sizeof (char *));
14532
14533 // mod
14534
14535 struct stat file_stat;
14536
14537 if (stat (mask, &file_stat) == -1)
14538 {
14539 maskcnt = 1;
14540
14541 masks[maskcnt - 1] = mystrdup (mask);
14542 }
14543 else
14544 {
14545 uint is_file = S_ISREG (file_stat.st_mode);
14546
14547 if (is_file == 1)
14548 {
14549 FILE *mask_fp;
14550
14551 if ((mask_fp = fopen (mask, "r")) == NULL)
14552 {
14553 log_error ("ERROR: %s: %s", mask, strerror (errno));
14554
14555 return (-1);
14556 }
14557
14558 char line_buf[BUFSIZ];
14559
14560 uint masks_avail = 1;
14561
14562 while (!feof (mask_fp))
14563 {
14564 memset (line_buf, 0, BUFSIZ);
14565
14566 int line_len = fgetl (mask_fp, line_buf);
14567
14568 if (line_len == 0) continue;
14569
14570 if (line_buf[0] == '#') continue;
14571
14572 if (masks_avail == maskcnt)
14573 {
14574 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14575
14576 masks_avail += INCR_MASKS;
14577 }
14578
14579 masks[maskcnt] = mystrdup (line_buf);
14580
14581 maskcnt++;
14582 }
14583
14584 fclose (mask_fp);
14585
14586 mask_from_file = 1;
14587 }
14588 else
14589 {
14590 maskcnt = 1;
14591
14592 masks[maskcnt - 1] = mystrdup (mask);
14593 }
14594 }
14595
14596 // base
14597
14598 int wls_left = myargc - (optind + 2);
14599
14600 for (int i = 0; i < wls_left; i++)
14601 {
14602 char *filename = myargv[optind + 2 + i];
14603
14604 struct stat file_stat;
14605
14606 if (stat (filename, &file_stat) == -1)
14607 {
14608 log_error ("ERROR: %s: %s", filename, strerror (errno));
14609
14610 return (-1);
14611 }
14612
14613 uint is_dir = S_ISDIR (file_stat.st_mode);
14614
14615 if (is_dir == 0)
14616 {
14617 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14618
14619 dictcnt++;
14620
14621 dictfiles[dictcnt - 1] = filename;
14622 }
14623 else
14624 {
14625 // do not allow --keyspace w/ a directory
14626
14627 if (keyspace == 1)
14628 {
14629 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14630
14631 return (-1);
14632 }
14633
14634 char **dictionary_files = NULL;
14635
14636 dictionary_files = scan_directory (filename);
14637
14638 if (dictionary_files != NULL)
14639 {
14640 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14641
14642 for (int d = 0; dictionary_files[d] != NULL; d++)
14643 {
14644 char *l1_filename = dictionary_files[d];
14645
14646 struct stat l1_stat;
14647
14648 if (stat (l1_filename, &l1_stat) == -1)
14649 {
14650 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14651
14652 return (-1);
14653 }
14654
14655 if (S_ISREG (l1_stat.st_mode))
14656 {
14657 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14658
14659 dictcnt++;
14660
14661 dictfiles[dictcnt - 1] = strdup (l1_filename);
14662 }
14663 }
14664 }
14665
14666 local_free (dictionary_files);
14667 }
14668 }
14669
14670 if (dictcnt < 1)
14671 {
14672 log_error ("ERROR: No usable dictionary file found.");
14673
14674 return (-1);
14675 }
14676
14677 if (increment)
14678 {
14679 maskcnt = 0;
14680
14681 uint mask_min = increment_min; // we can't reject smaller masks here
14682 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
14683
14684 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
14685 {
14686 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
14687
14688 if (cur_mask == NULL) break;
14689
14690 masks[maskcnt] = cur_mask;
14691
14692 maskcnt++;
14693
14694 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
14695 }
14696 }
14697 }
14698
14699 data.pw_min = pw_min;
14700 data.pw_max = pw_max;
14701
14702 /**
14703 * weak hash check
14704 */
14705
14706 if (weak_hash_threshold >= salts_cnt)
14707 {
14708 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
14709
14710 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
14711 {
14712 weak_hash_check (&data.devices_param[0], salt_pos, gpu_loops);
14713 }
14714 }
14715
14716 // Display hack, guarantee that there is at least one \r before real start
14717
14718 if (data.quiet == 0) log_info_nn ("");
14719
14720 /**
14721 * status and monitor threads
14722 */
14723
14724 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
14725
14726 hc_thread_t i_thread = 0;
14727
14728 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
14729 {
14730 hc_thread_create (i_thread, thread_keypress, &benchmark);
14731 }
14732
14733 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
14734
14735 uint ni_threads_cnt = 0;
14736
14737 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
14738
14739 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
14740
14741 ni_threads_cnt++;
14742
14743 /**
14744 * Outfile remove
14745 */
14746
14747 if (keyspace == 0)
14748 {
14749 if (outfile_check_timer != 0)
14750 {
14751 if (data.outfile_check_directory != NULL)
14752 {
14753 if ((hash_mode != 5200) &&
14754 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
14755 (hash_mode != 9000))
14756 {
14757 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
14758
14759 ni_threads_cnt++;
14760 }
14761 else
14762 {
14763 outfile_check_timer = 0;
14764 }
14765 }
14766 else
14767 {
14768 outfile_check_timer = 0;
14769 }
14770 }
14771 }
14772
14773 /**
14774 * Inform the user if we got some hashes remove because of the pot file remove feature
14775 */
14776
14777 if (data.quiet == 0)
14778 {
14779 if (potfile_remove_cracks > 0)
14780 {
14781 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
14782 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
14783 }
14784 }
14785
14786 data.outfile_check_timer = outfile_check_timer;
14787
14788 /**
14789 * main loop
14790 */
14791
14792 char **induction_dictionaries = NULL;
14793
14794 int induction_dictionaries_cnt = 0;
14795
14796 hcstat_table_t *root_table_buf = NULL;
14797 hcstat_table_t *markov_table_buf = NULL;
14798
14799 uint initial_restore_done = 0;
14800
14801 data.maskcnt = maskcnt;
14802
14803 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
14804 {
14805 if (data.devices_status == STATUS_CRACKED) break;
14806
14807 data.devices_status = STATUS_INIT;
14808
14809 if (maskpos > rd->maskpos)
14810 {
14811 rd->dictpos = 0;
14812 }
14813
14814 rd->maskpos = maskpos;
14815 data.maskpos = maskpos;
14816
14817 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
14818 {
14819 char *mask = masks[maskpos];
14820
14821 if (mask_from_file == 1)
14822 {
14823 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
14824
14825 char *str_ptr;
14826 uint str_pos;
14827
14828 uint mask_offset = 0;
14829
14830 uint separator_cnt;
14831
14832 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
14833 {
14834 str_ptr = strstr (mask + mask_offset, ",");
14835
14836 if (str_ptr == NULL) break;
14837
14838 str_pos = str_ptr - mask;
14839
14840 // escaped separator, i.e. "\,"
14841
14842 if (str_pos > 0)
14843 {
14844 if (mask[str_pos - 1] == '\\')
14845 {
14846 separator_cnt --;
14847
14848 mask_offset = str_pos + 1;
14849
14850 continue;
14851 }
14852 }
14853
14854 // reset the offset
14855
14856 mask_offset = 0;
14857
14858 mask[str_pos] = '\0';
14859
14860 switch (separator_cnt)
14861 {
14862 case 0:
14863 mp_reset_usr (mp_usr, 0);
14864
14865 custom_charset_1 = mask;
14866 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
14867 break;
14868
14869 case 1:
14870 mp_reset_usr (mp_usr, 1);
14871
14872 custom_charset_2 = mask;
14873 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
14874 break;
14875
14876 case 2:
14877 mp_reset_usr (mp_usr, 2);
14878
14879 custom_charset_3 = mask;
14880 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
14881 break;
14882
14883 case 3:
14884 mp_reset_usr (mp_usr, 3);
14885
14886 custom_charset_4 = mask;
14887 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
14888 break;
14889 }
14890
14891 mask = mask + str_pos + 1;
14892 }
14893 }
14894
14895 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
14896 {
14897 if (maskpos > 0)
14898 {
14899 local_free (css_buf);
14900 local_free (data.root_css_buf);
14901 local_free (data.markov_css_buf);
14902
14903 local_free (masks[maskpos - 1]);
14904 }
14905
14906 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
14907
14908 data.mask = mask;
14909 data.css_cnt = css_cnt;
14910 data.css_buf = css_buf;
14911
14912 uint uniq_tbls[SP_PW_MAX][CHARSIZ];
14913
14914 memset (uniq_tbls, 0, sizeof (uniq_tbls));
14915
14916 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
14917
14918 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
14919 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
14920
14921 sp_setup_tbl (install_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
14922
14923 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
14924
14925 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
14926 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
14927
14928 data.root_css_buf = root_css_buf;
14929 data.markov_css_buf = markov_css_buf;
14930
14931 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
14932
14933 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
14934
14935 local_free (root_table_buf);
14936 local_free (markov_table_buf);
14937
14938 // args
14939
14940 for (uint device_id = 0; device_id < devices_cnt; device_id++)
14941 {
14942 hc_device_param_t *device_param = &data.devices_param[device_id];
14943
14944 device_param->kernel_params_mp[0] = &device_param->d_combs;
14945 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
14946 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
14947
14948 device_param->kernel_params_mp_buf64[3] = 0;
14949 device_param->kernel_params_mp_buf32[4] = css_cnt;
14950 device_param->kernel_params_mp_buf32[5] = 0;
14951 device_param->kernel_params_mp_buf32[6] = 0;
14952 device_param->kernel_params_mp_buf32[7] = 0;
14953
14954 if (attack_mode == ATTACK_MODE_HYBRID1)
14955 {
14956 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
14957 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
14958 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
14959 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
14960 }
14961 else if (attack_mode == ATTACK_MODE_HYBRID2)
14962 {
14963 device_param->kernel_params_mp_buf32[5] = 0;
14964 device_param->kernel_params_mp_buf32[6] = 0;
14965 device_param->kernel_params_mp_buf32[7] = 0;
14966 }
14967
14968 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp[i]);
14969 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp[i]);
14970 for (uint i = 4; i < 8; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp[i]);
14971
14972 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);
14973 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);
14974 }
14975 }
14976 else if (attack_mode == ATTACK_MODE_BF)
14977 {
14978 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
14979
14980 if (increment)
14981 {
14982 for (uint i = 0; i < dictcnt; i++)
14983 {
14984 local_free (dictfiles[i]);
14985 }
14986
14987 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
14988 {
14989 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
14990
14991 if (l1_filename == NULL) break;
14992
14993 dictcnt++;
14994
14995 dictfiles[dictcnt - 1] = l1_filename;
14996 }
14997 }
14998 else
14999 {
15000 dictcnt++;
15001
15002 dictfiles[dictcnt - 1] = mask;
15003 }
15004
15005 if (dictcnt == 0)
15006 {
15007 log_error ("ERROR: Mask is too small");
15008
15009 return (-1);
15010 }
15011 }
15012 }
15013
15014 free (induction_dictionaries);
15015
15016 // induction_dictionaries_cnt = 0; // implied
15017
15018 if (attack_mode != ATTACK_MODE_BF)
15019 {
15020 if (keyspace == 0)
15021 {
15022 induction_dictionaries = scan_directory (induction_directory);
15023
15024 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15025 }
15026 }
15027
15028 if (induction_dictionaries_cnt)
15029 {
15030 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15031 }
15032
15033 /**
15034 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15035 */
15036 if (keyspace == 1)
15037 {
15038 if ((maskcnt > 1) || (dictcnt > 1))
15039 {
15040 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15041
15042 return (-1);
15043 }
15044 }
15045
15046 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15047 {
15048 char *subid = logfile_generate_subid ();
15049
15050 data.subid = subid;
15051
15052 logfile_sub_msg ("START");
15053
15054 data.devices_status = STATUS_INIT;
15055
15056 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (uint64_t));
15057 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (uint64_t));
15058 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (uint64_t));
15059
15060 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15061
15062 data.cpt_pos = 0;
15063
15064 data.cpt_start = time (NULL);
15065
15066 data.cpt_total = 0;
15067
15068 if (data.restore == 0)
15069 {
15070 rd->words_cur = skip;
15071
15072 skip = 0;
15073
15074 data.skip = 0;
15075 }
15076
15077 data.ms_paused = 0;
15078
15079 data.words_cur = rd->words_cur;
15080
15081 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15082 {
15083 hc_device_param_t *device_param = &data.devices_param[device_id];
15084
15085 device_param->speed_pos = 0;
15086
15087 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (uint64_t));
15088 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15089 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15090
15091 device_param->gpu_power = device_param->gpu_power_user;
15092 device_param->gpu_blocks = device_param->gpu_blocks_user;
15093
15094 device_param->outerloop_pos = 0;
15095 device_param->outerloop_left = 0;
15096 device_param->innerloop_pos = 0;
15097 device_param->innerloop_left = 0;
15098
15099 // some more resets:
15100
15101 memset (device_param->pw_caches, 0, 64 * sizeof (pw_cache_t));
15102
15103 memset (device_param->pws_buf, 0, device_param->size_pws);
15104
15105 device_param->pw_cnt = 0;
15106 device_param->pws_cnt = 0;
15107
15108 device_param->words_off = 0;
15109 device_param->words_done = 0;
15110 }
15111
15112 data.gpu_blocks_div = 0;
15113
15114 // figure out some workload
15115
15116 if (attack_mode == ATTACK_MODE_STRAIGHT)
15117 {
15118 if (data.wordlist_mode == WL_MODE_FILE)
15119 {
15120 char *dictfile = NULL;
15121
15122 if (induction_dictionaries_cnt)
15123 {
15124 dictfile = induction_dictionaries[0];
15125 }
15126 else
15127 {
15128 dictfile = dictfiles[dictpos];
15129 }
15130
15131 data.dictfile = dictfile;
15132
15133 logfile_sub_string (dictfile);
15134
15135 for (uint i = 0; i < rp_files_cnt; i++)
15136 {
15137 logfile_sub_var_string ("rulefile", rp_files[i]);
15138 }
15139
15140 FILE *fd2 = fopen (dictfile, "rb");
15141
15142 if (fd2 == NULL)
15143 {
15144 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15145
15146 return (-1);
15147 }
15148
15149 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15150
15151 fclose (fd2);
15152
15153 if (data.words_cnt == 0)
15154 {
15155 if (data.devices_status == STATUS_CRACKED) break;
15156 if (data.devices_status == STATUS_ABORTED) break;
15157
15158 dictpos++;
15159
15160 continue;
15161 }
15162 }
15163 }
15164 else if (attack_mode == ATTACK_MODE_COMBI)
15165 {
15166 char *dictfile = data.dictfile;
15167 char *dictfile2 = data.dictfile2;
15168
15169 logfile_sub_string (dictfile);
15170 logfile_sub_string (dictfile2);
15171
15172 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
15173 {
15174 FILE *fd2 = fopen (dictfile, "rb");
15175
15176 if (fd2 == NULL)
15177 {
15178 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15179
15180 return (-1);
15181 }
15182
15183 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15184
15185 fclose (fd2);
15186 }
15187 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
15188 {
15189 FILE *fd2 = fopen (dictfile2, "rb");
15190
15191 if (fd2 == NULL)
15192 {
15193 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15194
15195 return (-1);
15196 }
15197
15198 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
15199
15200 fclose (fd2);
15201 }
15202
15203 if (data.words_cnt == 0)
15204 {
15205 if (data.devices_status == STATUS_CRACKED) break;
15206 if (data.devices_status == STATUS_ABORTED) break;
15207
15208 dictpos++;
15209
15210 continue;
15211 }
15212 }
15213 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15214 {
15215 char *dictfile = NULL;
15216
15217 if (induction_dictionaries_cnt)
15218 {
15219 dictfile = induction_dictionaries[0];
15220 }
15221 else
15222 {
15223 dictfile = dictfiles[dictpos];
15224 }
15225
15226 data.dictfile = dictfile;
15227
15228 char *mask = data.mask;
15229
15230 logfile_sub_string (dictfile);
15231 logfile_sub_string (mask);
15232
15233 FILE *fd2 = fopen (dictfile, "rb");
15234
15235 if (fd2 == NULL)
15236 {
15237 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15238
15239 return (-1);
15240 }
15241
15242 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15243
15244 fclose (fd2);
15245
15246 if (data.words_cnt == 0)
15247 {
15248 if (data.devices_status == STATUS_CRACKED) break;
15249 if (data.devices_status == STATUS_ABORTED) break;
15250
15251 dictpos++;
15252
15253 continue;
15254 }
15255 }
15256 else if (attack_mode == ATTACK_MODE_BF)
15257 {
15258 local_free (css_buf);
15259 local_free (data.root_css_buf);
15260 local_free (data.markov_css_buf);
15261
15262 char *mask = dictfiles[dictpos];
15263
15264 logfile_sub_string (mask);
15265
15266 // base
15267
15268 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15269
15270 if (opts_type & OPTS_TYPE_PT_UNICODE)
15271 {
15272 uint css_cnt_unicode = css_cnt * 2;
15273
15274 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
15275
15276 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
15277 {
15278 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
15279
15280 css_buf_unicode[j + 1].cs_buf[0] = 0;
15281 css_buf_unicode[j + 1].cs_len = 1;
15282 }
15283
15284 free (css_buf);
15285
15286 css_buf = css_buf_unicode;
15287 css_cnt = css_cnt_unicode;
15288 }
15289
15290 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
15291
15292 uint mask_min = pw_min;
15293 uint mask_max = pw_max;
15294
15295 if (opts_type & OPTS_TYPE_PT_UNICODE)
15296 {
15297 mask_min *= 2;
15298 mask_max *= 2;
15299 }
15300
15301 if ((css_cnt < mask_min) || (css_cnt > mask_max))
15302 {
15303 if (css_cnt < mask_min)
15304 {
15305 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
15306 }
15307
15308 if (css_cnt > mask_max)
15309 {
15310 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
15311 }
15312
15313 // skip to next mask
15314
15315 dictpos++;
15316
15317 rd->dictpos = dictpos;
15318
15319 logfile_sub_msg ("STOP");
15320
15321 continue;
15322 }
15323
15324 uint save_css_cnt = css_cnt;
15325
15326 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15327 {
15328 if (opti_type & OPTI_TYPE_APPENDED_SALT)
15329 {
15330 uint salt_len = (uint) data.salts_buf[0].salt_len;
15331 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
15332
15333 uint css_cnt_salt = css_cnt + salt_len;
15334
15335 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
15336
15337 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
15338
15339 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
15340 {
15341 css_buf_salt[j].cs_buf[0] = salt_buf[i];
15342 css_buf_salt[j].cs_len = 1;
15343 }
15344
15345 free (css_buf);
15346
15347 css_buf = css_buf_salt;
15348 css_cnt = css_cnt_salt;
15349 }
15350 }
15351
15352 data.mask = mask;
15353 data.css_cnt = css_cnt;
15354 data.css_buf = css_buf;
15355
15356 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
15357
15358 uint uniq_tbls[SP_PW_MAX][CHARSIZ];
15359
15360 memset (uniq_tbls, 0, sizeof (uniq_tbls));
15361
15362 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15363
15364 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15365 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15366
15367 sp_setup_tbl (install_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15368
15369 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15370
15371 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15372 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15373
15374 data.root_css_buf = root_css_buf;
15375 data.markov_css_buf = markov_css_buf;
15376
15377 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15378
15379 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15380
15381 local_free (root_table_buf);
15382 local_free (markov_table_buf);
15383
15384 // copy + args
15385
15386 uint css_cnt_l = css_cnt;
15387 uint css_cnt_r;
15388
15389 if (attack_exec == ATTACK_EXEC_ON_GPU)
15390 {
15391 if (save_css_cnt < 6)
15392 {
15393 css_cnt_r = 1;
15394 }
15395 else if (save_css_cnt == 6)
15396 {
15397 css_cnt_r = 2;
15398 }
15399 else
15400 {
15401 if (opts_type & OPTS_TYPE_PT_UNICODE)
15402 {
15403 if (save_css_cnt == 8 || save_css_cnt == 10)
15404 {
15405 css_cnt_r = 2;
15406 }
15407 else
15408 {
15409 css_cnt_r = 4;
15410 }
15411 }
15412 else
15413 {
15414 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
15415 {
15416 css_cnt_r = 3;
15417 }
15418 else
15419 {
15420 css_cnt_r = 4;
15421 }
15422 }
15423 }
15424 }
15425 else
15426 {
15427 css_cnt_r = 1;
15428
15429 /* unfinished code?
15430 int sum = css_buf[css_cnt_r - 1].cs_len;
15431
15432 for (uint i = 1; i < 4 && i < css_cnt; i++)
15433 {
15434 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
15435
15436 css_cnt_r++;
15437
15438 sum *= css_buf[css_cnt_r - 1].cs_len;
15439 }
15440 */
15441 }
15442
15443 css_cnt_l -= css_cnt_r;
15444
15445 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
15446
15447 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15448 {
15449 hc_device_param_t *device_param = &data.devices_param[device_id];
15450
15451 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
15452 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
15453 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
15454
15455 device_param->kernel_params_mp_l_buf64[3] = 0;
15456 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
15457 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
15458 device_param->kernel_params_mp_l_buf32[6] = 0;
15459 device_param->kernel_params_mp_l_buf32[7] = 0;
15460 device_param->kernel_params_mp_l_buf32[8] = 0;
15461
15462 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
15463 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
15464 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
15465 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
15466
15467 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
15468 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
15469 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
15470
15471 device_param->kernel_params_mp_r_buf64[3] = 0;
15472 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
15473 device_param->kernel_params_mp_r_buf32[5] = 0;
15474 device_param->kernel_params_mp_r_buf32[6] = 0;
15475 device_param->kernel_params_mp_r_buf32[7] = 0;
15476
15477 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]);
15478 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]);
15479 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]);
15480
15481 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]);
15482 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]);
15483 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]);
15484
15485 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);
15486 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);
15487 }
15488 }
15489
15490 uint64_t words_base = data.words_cnt;
15491
15492 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
15493 {
15494 if (data.gpu_rules_cnt)
15495 {
15496 words_base /= data.gpu_rules_cnt;
15497 }
15498 }
15499 else if (data.attack_kern == ATTACK_KERN_COMBI)
15500 {
15501 if (data.combs_cnt)
15502 {
15503 words_base /= data.combs_cnt;
15504 }
15505 }
15506 else if (data.attack_kern == ATTACK_KERN_BF)
15507 {
15508 if (data.bfs_cnt)
15509 {
15510 words_base /= data.bfs_cnt;
15511 }
15512 }
15513
15514 data.words_base = words_base;
15515
15516 if (keyspace == 1)
15517 {
15518 log_info ("%llu", (unsigned long long int) words_base);
15519
15520 return (0);
15521 }
15522
15523 if (data.words_cur > data.words_base)
15524 {
15525 log_error ("ERROR: restore value greater keyspace");
15526
15527 return (-1);
15528 }
15529
15530 if (data.words_cur)
15531 {
15532 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
15533 {
15534 for (uint i = 0; i < data.salts_cnt; i++)
15535 {
15536 data.words_progress_restored[i] = data.words_cur * data.gpu_rules_cnt;
15537 }
15538 }
15539 else if (data.attack_kern == ATTACK_KERN_COMBI)
15540 {
15541 for (uint i = 0; i < data.salts_cnt; i++)
15542 {
15543 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
15544 }
15545 }
15546 else if (data.attack_kern == ATTACK_KERN_BF)
15547 {
15548 for (uint i = 0; i < data.salts_cnt; i++)
15549 {
15550 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
15551 }
15552 }
15553 }
15554
15555 /*
15556 * Inform user about possible slow speeds
15557 */
15558
15559 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
15560 {
15561 if (data.words_base < gpu_blocks_all)
15562 {
15563 if (quiet == 0)
15564 {
15565 log_info ("");
15566 log_info ("ATTENTION!");
15567 log_info (" The wordlist or mask you are using is too small.");
15568 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your GPU(s).");
15569 log_info (" The cracking speed will drop.");
15570 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
15571 log_info ("");
15572 }
15573 }
15574 }
15575
15576 /*
15577 * Update loopback file
15578 */
15579
15580 if (loopback == 1)
15581 {
15582 time_t now;
15583
15584 time (&now);
15585
15586 uint random_num = get_random_num (0, 9999);
15587
15588 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
15589
15590 data.loopback_file = loopback_file;
15591 }
15592
15593 /*
15594 * Update dictionary statistic
15595 */
15596
15597 if (keyspace == 0)
15598 {
15599 dictstat_fp = fopen (dictstat, "wb");
15600
15601 if (dictstat_fp)
15602 {
15603 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
15604
15605 fclose (dictstat_fp);
15606 }
15607 }
15608
15609 data.devices_status = STATUS_RUNNING;
15610
15611 if (initial_restore_done == 0)
15612 {
15613 if (data.restore_disable == 0) cycle_restore ();
15614
15615 initial_restore_done = 1;
15616 }
15617
15618 hc_timer_set (&data.timer_running);
15619
15620 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
15621 {
15622 if ((quiet == 0) && (status == 0) && (benchmark == 0))
15623 {
15624 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
15625 if (quiet == 0) fflush (stdout);
15626 }
15627 }
15628 else if (wordlist_mode == WL_MODE_STDIN)
15629 {
15630 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
15631 if (data.quiet == 0) log_info ("");
15632 }
15633
15634 time_t runtime_start;
15635
15636 time (&runtime_start);
15637
15638 data.runtime_start = runtime_start;
15639
15640 /**
15641 * create cracker threads
15642 */
15643
15644 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (devices_cnt, sizeof (hc_thread_t));
15645
15646 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15647 {
15648 hc_device_param_t *device_param = &devices_param[device_id];
15649
15650 device_param->device_id = device_id;
15651
15652 if (wordlist_mode == WL_MODE_STDIN)
15653 {
15654 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
15655 }
15656 else
15657 {
15658 hc_thread_create (c_threads[device_id], thread_calc, device_param);
15659 }
15660 }
15661
15662 // wait for crack threads to exit
15663
15664 hc_thread_wait (devices_cnt, c_threads);
15665
15666 local_free (c_threads);
15667
15668 data.restore = 0;
15669
15670 // finalize task
15671
15672 logfile_sub_var_uint ("status-after-work", data.devices_status);
15673
15674 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
15675
15676 if (data.devices_status == STATUS_CRACKED) break;
15677 if (data.devices_status == STATUS_ABORTED) break;
15678
15679 if (data.devices_status == STATUS_BYPASS)
15680 {
15681 data.devices_status = STATUS_RUNNING;
15682 }
15683
15684 if (induction_dictionaries_cnt)
15685 {
15686 unlink (induction_dictionaries[0]);
15687 }
15688
15689 free (induction_dictionaries);
15690
15691 if (attack_mode != ATTACK_MODE_BF)
15692 {
15693 induction_dictionaries = scan_directory (induction_directory);
15694
15695 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15696 }
15697
15698 if (benchmark == 0)
15699 {
15700 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
15701 {
15702 if (quiet == 0) clear_prompt ();
15703
15704 if (quiet == 0) log_info ("");
15705
15706 if (status == 1)
15707 {
15708 status_display ();
15709 }
15710 else
15711 {
15712 if (quiet == 0) status_display ();
15713 }
15714
15715 if (quiet == 0) log_info ("");
15716 }
15717 }
15718
15719 if (attack_mode == ATTACK_MODE_BF)
15720 {
15721 dictpos++;
15722
15723 rd->dictpos = dictpos;
15724 }
15725 else
15726 {
15727 if (induction_dictionaries_cnt)
15728 {
15729 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15730 }
15731 else
15732 {
15733 dictpos++;
15734
15735 rd->dictpos = dictpos;
15736 }
15737 }
15738
15739 time_t runtime_stop;
15740
15741 time (&runtime_stop);
15742
15743 data.runtime_stop = runtime_stop;
15744
15745 logfile_sub_uint (runtime_start);
15746 logfile_sub_uint (runtime_stop);
15747
15748 logfile_sub_msg ("STOP");
15749
15750 global_free (subid);
15751 }
15752
15753 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
15754
15755 if (data.devices_status == STATUS_CRACKED) break;
15756 if (data.devices_status == STATUS_ABORTED) break;
15757 if (data.devices_status == STATUS_QUIT) break;
15758
15759 if (data.devices_status == STATUS_BYPASS)
15760 {
15761 data.devices_status = STATUS_RUNNING;
15762 }
15763 }
15764
15765 // 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
15766
15767 if (attack_mode == ATTACK_MODE_STRAIGHT)
15768 {
15769 if (data.wordlist_mode == WL_MODE_FILE)
15770 {
15771 if (data.dictfile == NULL)
15772 {
15773 if (dictfiles != NULL)
15774 {
15775 data.dictfile = dictfiles[0];
15776
15777 hc_timer_set (&data.timer_running);
15778 }
15779 }
15780 }
15781 }
15782 // NOTE: combi is okay because it is already set beforehand
15783 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
15784 {
15785 if (data.dictfile == NULL)
15786 {
15787 if (dictfiles != NULL)
15788 {
15789 hc_timer_set (&data.timer_running);
15790
15791 data.dictfile = dictfiles[0];
15792 }
15793 }
15794 }
15795 else if (attack_mode == ATTACK_MODE_BF)
15796 {
15797 if (data.mask == NULL)
15798 {
15799 hc_timer_set (&data.timer_running);
15800
15801 data.mask = masks[0];
15802 }
15803 }
15804
15805 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
15806 {
15807 data.devices_status = STATUS_EXHAUSTED;
15808 }
15809
15810 // if cracked / aborted remove last induction dictionary
15811
15812 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
15813 {
15814 struct stat induct_stat;
15815
15816 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
15817 {
15818 unlink (induction_dictionaries[file_pos]);
15819 }
15820 }
15821
15822 // wait for non-interactive threads
15823
15824 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
15825 {
15826 hc_thread_wait (1, &ni_threads[thread_idx]);
15827 }
15828
15829 local_free (ni_threads);
15830
15831 // wait for interactive threads
15832
15833 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15834 {
15835 hc_thread_wait (1, &i_thread);
15836 }
15837
15838 // we dont need restore file anymore
15839 if (data.restore_disable == 0)
15840 {
15841 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
15842 {
15843 unlink (eff_restore_file);
15844 unlink (new_restore_file);
15845 }
15846 else
15847 {
15848 cycle_restore ();
15849 }
15850 }
15851
15852 // finally save left hashes
15853
15854 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
15855 {
15856 save_hash ();
15857 }
15858
15859 /**
15860 * Clean up
15861 */
15862
15863 if (benchmark == 1)
15864 {
15865 status_benchmark ();
15866
15867 log_info ("");
15868 }
15869 else
15870 {
15871 if (quiet == 0) clear_prompt ();
15872
15873 if (quiet == 0) log_info ("");
15874
15875 if (status == 1)
15876 {
15877 status_display ();
15878 }
15879 else
15880 {
15881 if (quiet == 0) status_display ();
15882 }
15883
15884 if (quiet == 0) log_info ("");
15885 }
15886
15887 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15888 {
15889 hc_device_param_t *device_param = &data.devices_param[device_id];
15890
15891 local_free (device_param->result);
15892
15893 local_free (device_param->pw_caches);
15894
15895 local_free (device_param->combs_buf);
15896
15897 local_free (device_param->hooks_buf);
15898
15899 local_free (device_param->device_name);
15900
15901 local_free (device_param->device_version);
15902
15903 local_free (device_param->driver_version);
15904
15905 if (device_param->pws_buf) myfree (device_param->pws_buf);
15906 if (device_param->d_pws_buf) hc_clReleaseMemObject (device_param->d_pws_buf);
15907 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (device_param->d_pws_amp_buf);
15908 if (device_param->d_rules) hc_clReleaseMemObject (device_param->d_rules);
15909 if (device_param->d_rules_c) hc_clReleaseMemObject (device_param->d_rules_c);
15910 if (device_param->d_combs) hc_clReleaseMemObject (device_param->d_combs);
15911 if (device_param->d_combs_c) hc_clReleaseMemObject (device_param->d_combs_c);
15912 if (device_param->d_bfs) hc_clReleaseMemObject (device_param->d_bfs);
15913 if (device_param->d_bfs_c) hc_clReleaseMemObject (device_param->d_bfs_c);
15914 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (device_param->d_bitmap_s1_a);
15915 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (device_param->d_bitmap_s1_b);
15916 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (device_param->d_bitmap_s1_c);
15917 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (device_param->d_bitmap_s1_d);
15918 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (device_param->d_bitmap_s2_a);
15919 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (device_param->d_bitmap_s2_b);
15920 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (device_param->d_bitmap_s2_c);
15921 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (device_param->d_bitmap_s2_d);
15922 if (device_param->d_plain_bufs) hc_clReleaseMemObject (device_param->d_plain_bufs);
15923 if (device_param->d_digests_buf) hc_clReleaseMemObject (device_param->d_digests_buf);
15924 if (device_param->d_digests_shown) hc_clReleaseMemObject (device_param->d_digests_shown);
15925 if (device_param->d_salt_bufs) hc_clReleaseMemObject (device_param->d_salt_bufs);
15926 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (device_param->d_esalt_bufs);
15927 if (device_param->d_tmps) hc_clReleaseMemObject (device_param->d_tmps);
15928 if (device_param->d_hooks) hc_clReleaseMemObject (device_param->d_hooks);
15929 if (device_param->d_result) hc_clReleaseMemObject (device_param->d_result);
15930 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (device_param->d_scryptV_buf);
15931 if (device_param->d_root_css_buf) hc_clReleaseMemObject (device_param->d_root_css_buf);
15932 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (device_param->d_markov_css_buf);
15933
15934 if (device_param->kernel1) hc_clReleaseKernel (device_param->kernel1);
15935 if (device_param->kernel12) hc_clReleaseKernel (device_param->kernel12);
15936 if (device_param->kernel2) hc_clReleaseKernel (device_param->kernel2);
15937 if (device_param->kernel23) hc_clReleaseKernel (device_param->kernel23);
15938 if (device_param->kernel3) hc_clReleaseKernel (device_param->kernel3);
15939 if (device_param->kernel_mp) hc_clReleaseKernel (device_param->kernel_mp);
15940 if (device_param->kernel_mp_l) hc_clReleaseKernel (device_param->kernel_mp_l);
15941 if (device_param->kernel_mp_r) hc_clReleaseKernel (device_param->kernel_mp_r);
15942
15943 if (device_param->program) hc_clReleaseProgram (device_param->program);
15944 if (device_param->program_mp) hc_clReleaseProgram (device_param->program_mp);
15945 if (device_param->command_queue) hc_clReleaseCommandQueue (device_param->command_queue);
15946 if (device_param->context) hc_clReleaseContext (device_param->context);
15947 }
15948
15949 // reset default fan speed
15950
15951 /*
15952 if (gpu_temp_disable == 0)
15953 {
15954 if (gpu_temp_retain != 0)
15955 {
15956 hc_thread_mutex_lock (mux_adl);
15957
15958 for (uint i = 0; i < data.devices_cnt; i++)
15959 {
15960 if (data.hm_device[i].fan_supported == 1)
15961 {
15962 int fanspeed = temp_retain_fanspeed_value[i];
15963
15964 if (fanspeed == -1) continue;
15965
15966 int rc = hm_set_fanspeed_with_device_id (i, fanspeed);
15967
15968 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", i);
15969 }
15970 }
15971
15972 hc_thread_mutex_unlock (mux_adl);
15973 }
15974 }
15975
15976 // reset power tuning
15977
15978 if (powertune_enable == 1)
15979 {
15980 hc_thread_mutex_lock (mux_adl);
15981
15982 for (uint i = 0; i < data.devices_cnt; i++)
15983 {
15984 if (data.hm_device[i].od_version == 6)
15985 {
15986 // check powertune capabilities first, if not available then skip device
15987
15988 int powertune_supported = 0;
15989
15990 if ((hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll, data.hm_device[i].adapter_index, &powertune_supported)) != ADL_OK)
15991 {
15992 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
15993
15994 return (-1);
15995 }
15996
15997 if (powertune_supported != 0)
15998 {
15999 // powercontrol settings
16000
16001 if ((hc_ADL_Overdrive_PowerControl_Set (data.hm_dll, data.hm_device[i].adapter_index, od_power_control_status[i])) != ADL_OK)
16002 {
16003 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16004
16005 return (-1);
16006 }
16007
16008 // clocks
16009
16010 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16011
16012 performance_state->iNumberOfPerformanceLevels = 2;
16013
16014 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[i].state.aLevels[0].iEngineClock;
16015 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[i].state.aLevels[1].iEngineClock;
16016 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[i].state.aLevels[0].iMemoryClock;
16017 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[i].state.aLevels[1].iMemoryClock;
16018
16019 if ((hc_ADL_Overdrive_State_Set (data.hm_dll, data.hm_device[i].adapter_index, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
16020 {
16021 log_info ("ERROR: Failed to restore ADL performance state");
16022
16023 return (-1);
16024 }
16025
16026 local_free (performance_state);
16027 }
16028 }
16029 }
16030
16031 hc_thread_mutex_unlock (mux_adl);
16032 }
16033
16034 if (gpu_temp_disable == 0)
16035 {
16036 if (vendor_id == VENDOR_ID_NV)
16037 {
16038 #ifdef LINUX
16039 hc_NVML_nvmlShutdown ();
16040 #endif
16041
16042 #ifdef WIN
16043 NvAPI_Unload ();
16044 #endif
16045 }
16046
16047 if (vendor_id == VENDOR_ID_AMD)
16048 {
16049 hc_ADL_Main_Control_Destroy (data.hm_dll);
16050
16051 hm_close (data.hm_dll);
16052 }
16053 }
16054 */
16055
16056 // free memory
16057
16058 local_free (masks);
16059
16060 local_free (dictstat_base);
16061
16062 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16063 {
16064 pot_t *pot_ptr = &pot[pot_pos];
16065
16066 hash_t *hash = &pot_ptr->hash;
16067
16068 local_free (hash->digest);
16069
16070 if (isSalted)
16071 {
16072 local_free (hash->salt);
16073 }
16074 }
16075
16076 local_free (pot);
16077
16078 local_free (all_gpu_rules_cnt);
16079 local_free (all_gpu_rules_buf);
16080
16081 local_free (wl_data->buf);
16082 local_free (wl_data);
16083
16084 local_free (bitmap_s1_a);
16085 local_free (bitmap_s1_b);
16086 local_free (bitmap_s1_c);
16087 local_free (bitmap_s1_d);
16088 local_free (bitmap_s2_a);
16089 local_free (bitmap_s2_b);
16090 local_free (bitmap_s2_c);
16091 local_free (bitmap_s2_d);
16092
16093 local_free (temp_retain_fanspeed_value);
16094 local_free (od_clock_mem_status);
16095 local_free (od_power_control_status);
16096
16097 global_free (devices_param);
16098
16099 global_free (gpu_rules_buf);
16100
16101 global_free (root_css_buf);
16102 global_free (markov_css_buf);
16103
16104 global_free (digests_buf);
16105 global_free (digests_shown);
16106 global_free (digests_shown_tmp);
16107
16108 global_free (salts_buf);
16109 global_free (salts_shown);
16110
16111 global_free (esalts_buf);
16112
16113 global_free (words_progress_done);
16114 global_free (words_progress_rejected);
16115 global_free (words_progress_restored);
16116
16117 if (pot_fp) fclose (pot_fp);
16118
16119 if (data.devices_status == STATUS_QUIT) break;
16120 }
16121
16122 // destroy others mutex
16123
16124 hc_thread_mutex_delete (mux_dispatcher);
16125 hc_thread_mutex_delete (mux_counter);
16126 hc_thread_mutex_delete (mux_display);
16127 hc_thread_mutex_delete (mux_adl);
16128
16129 // free memory
16130
16131 local_free (eff_restore_file);
16132 local_free (new_restore_file);
16133
16134 local_free (rd);
16135
16136 // loopback
16137
16138 local_free (loopback_file);
16139
16140 if (loopback == 1) unlink (loopback_file);
16141
16142 // induction directory
16143
16144 if (induction_dir == NULL)
16145 {
16146 if (attack_mode != ATTACK_MODE_BF)
16147 {
16148 if (rmdir (induction_directory) == -1)
16149 {
16150 if (errno == ENOENT)
16151 {
16152 // good, we can ignore
16153 }
16154 else if (errno == ENOTEMPTY)
16155 {
16156 // good, we can ignore
16157 }
16158 else
16159 {
16160 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
16161
16162 return (-1);
16163 }
16164 }
16165
16166 local_free (induction_directory);
16167 }
16168 }
16169
16170 // outfile-check directory
16171
16172 if (outfile_check_dir == NULL)
16173 {
16174 if (rmdir (outfile_check_directory) == -1)
16175 {
16176 if (errno == ENOENT)
16177 {
16178 // good, we can ignore
16179 }
16180 else if (errno == ENOTEMPTY)
16181 {
16182 // good, we can ignore
16183 }
16184 else
16185 {
16186 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
16187
16188 return (-1);
16189 }
16190 }
16191
16192 local_free (outfile_check_directory);
16193 }
16194
16195 time_t proc_stop;
16196
16197 time (&proc_stop);
16198
16199 logfile_top_uint (proc_start);
16200 logfile_top_uint (proc_stop);
16201
16202 logfile_top_msg ("STOP");
16203
16204 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
16205 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
16206
16207 if (data.devices_status == STATUS_ABORTED) return 2;
16208 if (data.devices_status == STATUS_QUIT) return 2;
16209 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
16210 if (data.devices_status == STATUS_EXHAUSTED) return 1;
16211 if (data.devices_status == STATUS_CRACKED) return 0;
16212
16213 return -1;
16214 }
Hashcat additions to support pwdhash