projects / hashcat.git / blob
? search:


88a751ecd06dbdebf65692b30ce6958ae9d768a3
[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 #define USAGE 0
22 #define VERSION 0
23 #define QUIET 0
24 #define MARKOV_THRESHOLD 0
25 #define MARKOV_DISABLE 0
26 #define MARKOV_CLASSIC 0
27 #define BENCHMARK 0
28 #define BENCHMARK_MODE 1
29 #define RESTORE 0
30 #define RESTORE_TIMER 60
31 #define RESTORE_DISABLE 0
32 #define STATUS 0
33 #define STATUS_TIMER 10
34 #define STATUS_AUTOMAT 0
35 #define LOOPBACK 0
36 #define WEAK_HASH_THRESHOLD 100
37 #define SHOW 0
38 #define LEFT 0
39 #define USERNAME 0
40 #define REMOVE 0
41 #define REMOVE_TIMER 60
42 #define SKIP 0
43 #define LIMIT 0
44 #define KEYSPACE 0
45 #define POTFILE_DISABLE 0
46 #define DEBUG_MODE 0
47 #define RP_GEN 0
48 #define RP_GEN_FUNC_MIN 1
49 #define RP_GEN_FUNC_MAX 4
50 #define RP_GEN_SEED 0
51 #define RULE_BUF_L ":"
52 #define RULE_BUF_R ":"
53 #define FORCE 0
54 #define RUNTIME 0
55 #define HEX_CHARSET 0
56 #define HEX_SALT 0
57 #define HEX_WORDLIST 0
58 #define OUTFILE_FORMAT 3
59 #define OUTFILE_AUTOHEX 1
60 #define OUTFILE_CHECK_TIMER 5
61 #define ATTACK_MODE 0
62 #define HASH_MODE 0
63 #define SEGMENT_SIZE 32
64 #define INCREMENT 0
65 #define INCREMENT_MIN 1
66 #define INCREMENT_MAX PW_MAX
67 #define SEPARATOR ':'
68 #define BITMAP_MIN 16
69 #define BITMAP_MAX 24
70 #define GPU_TEMP_DISABLE 0
71 #define GPU_TEMP_ABORT 90
72 #define GPU_TEMP_RETAIN 80
73 #define WORKLOAD_PROFILE 2
74 #define GPU_ACCEL 0
75 #define GPU_LOOPS 0
76 #define GPU_RULES 1024
77 #define GPU_COMBS 1024
78 #define GPU_BFS 1024
79 #define GPU_THREADS 64
80 #define POWERTUNE_ENABLE 0
81 #define LOGFILE_DISABLE 0
82 #define SCRYPT_TMTO 0
83
84 #define WL_MODE_STDIN 1
85 #define WL_MODE_FILE 2
86 #define WL_MODE_MASK 3
87
88 #define HL_MODE_FILE 4
89 #define HL_MODE_ARG 5
90
91 #define HLFMT_HASHCAT 0
92 #define HLFMT_PWDUMP 1
93 #define HLFMT_PASSWD 2
94 #define HLFMT_SHADOW 3
95 #define HLFMT_DCC 4
96 #define HLFMT_DCC2 5
97 #define HLFMT_NETNTLM1 7
98 #define HLFMT_NETNTLM2 8
99 #define HLFMT_NSLDAP 9
100 #define HLFMT_NSLDAPS 10
101 #define HLFMTS_CNT 11
102
103 #define ATTACK_MODE_STRAIGHT 0
104 #define ATTACK_MODE_COMBI 1
105 #define ATTACK_MODE_TOGGLE 2
106 #define ATTACK_MODE_BF 3
107 #define ATTACK_MODE_PERM 4
108 #define ATTACK_MODE_TABLE 5
109 #define ATTACK_MODE_HYBRID1 6
110 #define ATTACK_MODE_HYBRID2 7
111 #define ATTACK_MODE_NONE 100
112
113 #define ATTACK_KERN_STRAIGHT 0
114 #define ATTACK_KERN_COMBI 1
115 #define ATTACK_KERN_BF 3
116 #define ATTACK_KERN_NONE 100
117
118 #define ATTACK_EXEC_ON_CPU 10
119 #define ATTACK_EXEC_ON_GPU 11
120
121 #define COMBINATOR_MODE_BASE_LEFT 10001
122 #define COMBINATOR_MODE_BASE_RIGHT 10002
123
124 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
125 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
126
127 #define MAX_CUT_TRIES 4
128
129 #define MAX_DICTSTAT 10000
130
131 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 128
132
133 #define global_free(attr) \
134 { \
135 myfree ((void *) data.attr); \
136 \
137 data.attr = NULL; \
138 }
139
140 #define local_free(attr) \
141 { \
142 myfree ((void *) attr); \
143 \
144 attr = NULL; \
145 }
146
147 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
148 {
149 900,
150 0,
151 5100,
152 100,
153 1400,
154 10800,
155 1700,
156 5000,
157 10100,
158 6000,
159 6100,
160 6900,
161 11700,
162 11800,
163 400,
164 8900,
165 11900,
166 12000,
167 10900,
168 12100,
169 23,
170 2500,
171 5300,
172 5400,
173 5500,
174 5600,
175 7300,
176 7500,
177 8300,
178 11100,
179 11200,
180 11400,
181 121,
182 2611,
183 2711,
184 2811,
185 8400,
186 11,
187 2612,
188 7900,
189 21,
190 11000,
191 124,
192 10000,
193 3711,
194 7600,
195 12,
196 131,
197 132,
198 1731,
199 200,
200 300,
201 3100,
202 112,
203 12300,
204 8000,
205 141,
206 1441,
207 1600,
208 12600,
209 1421,
210 101,
211 111,
212 1711,
213 3000,
214 1000,
215 1100,
216 2100,
217 12800,
218 1500,
219 12400,
220 500,
221 3200,
222 7400,
223 1800,
224 122,
225 1722,
226 7100,
227 6300,
228 6700,
229 6400,
230 6500,
231 2400,
232 2410,
233 5700,
234 9200,
235 9300,
236 22,
237 501,
238 5800,
239 8100,
240 8500,
241 7200,
242 9900,
243 7700,
244 7800,
245 10300,
246 8600,
247 8700,
248 9100,
249 133,
250 11600,
251 12500,
252 6211,
253 6221,
254 6231,
255 6241,
256 8800,
257 12200,
258 9700,
259 9710,
260 9800,
261 9810,
262 9400,
263 9500,
264 9600,
265 10400,
266 10410,
267 10500,
268 10600,
269 10700,
270 9000,
271 5200,
272 6800,
273 6600,
274 8200,
275 11300,
276 12700
277 };
278
279 /**
280 * types
281 */
282
283 static void (*get_next_word_func) (char *, uint32_t, uint32_t *, uint32_t *);
284
285 /**
286 * globals
287 */
288
289 static unsigned int full01 = 0x01010101;
290 static unsigned int full80 = 0x80808080;
291
292 int SUPPRESS_OUTPUT = 0;
293
294 hc_thread_mutex_t mux_adl;
295 hc_thread_mutex_t mux_counter;
296 hc_thread_mutex_t mux_dispatcher;
297 hc_thread_mutex_t mux_display;
298
299 hc_global_data_t data;
300
301 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
302
303 const char *USAGE_MINI[] =
304 {
305 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
306 "",
307 "Try --help for more help.",
308 NULL
309 };
310
311 const char *USAGE_BIG[] =
312 {
313 "%s, advanced password recovery",
314 "",
315 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
316 "",
317 "=======",
318 "Options",
319 "=======",
320 "",
321 "* General:",
322 "",
323 " -m, --hash-type=NUM Hash-type, see references below",
324 " -a, --attack-mode=NUM Attack-mode, see references below",
325 " -V, --version Print version",
326 " -h, --help Print help",
327 " --quiet Suppress output",
328 "",
329 "* Benchmark:",
330 "",
331 " -b, --benchmark Run benchmark",
332 " --benchmark-mode=NUM Benchmark-mode, see references below",
333 "",
334 "* Misc:",
335 "",
336 " --hex-charset Assume charset is given in hex",
337 " --hex-salt Assume salt is given in hex",
338 " --hex-wordlist Assume words in wordlist is given in hex",
339 " --force Ignore warnings",
340 " --status Enable automatic update of the status-screen",
341 " --status-timer=NUM Seconds between status-screen update",
342 " --status-automat Display the status view in a machine readable format",
343 " --loopback Add new plains to induct directory",
344 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
345 "",
346 "* Markov:",
347 "",
348 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
349 " --markov-disable Disables markov-chains, emulates classic brute-force",
350 " --markov-classic Enables classic markov-chains, no per-position enhancement",
351 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
352 "",
353 "* Session:",
354 "",
355 " --runtime=NUM Abort session after NUM seconds of runtime",
356 " --session=STR Define specific session name",
357 " --restore Restore session from --session",
358 " --restore-disable Do not write restore file",
359 "",
360 "* Files:",
361 "",
362 " -o, --outfile=FILE Define outfile for recovered hash",
363 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
364 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
365 " --outfile-check-timer=NUM Seconds between outfile checks",
366 " -p, --separator=CHAR Separator char for hashlists and outfile",
367 " --show Show cracked passwords only",
368 " --left Show un-cracked passwords only",
369 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
370 " --remove Enable remove of hash once it is cracked",
371 " --remove-timer=NUM Update input hash file each NUM seconds",
372 " --potfile-disable Do not write potfile",
373 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
374 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
375 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
376 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
377 " --logfile-disable Disable the logfile",
378 " --truecrypt-keyfiles=FILE Keyfiles used, seperate with comma",
379 "",
380 "* Resources:",
381 "",
382 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
383 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
384 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
385 " --cpu-affinity=STR Locks to CPU devices, seperate with comma",
386 " -d, --gpu-devices=STR Devices to use, separate with comma",
387 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
388 " -n, --gpu-accel=NUM Workload tuning: 1, 8, 40, 80, 160",
389 " -u, --gpu-loops=NUM Workload fine-tuning: 8 - 1024",
390 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
391 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
392 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
393 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
394 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
395 "",
396 "* Distributed:",
397 "",
398 " -s, --skip=NUM Skip number of words",
399 " -l, --limit=NUM Limit number of words",
400 " --keyspace Show keyspace base:mod values and quit",
401 "",
402 "* Rules:",
403 "",
404 " -j, --rule-left=RULE Single rule applied to each word from left dict",
405 " -k, --rule-right=RULE Single rule applied to each word from right dict",
406 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
407 " -g, --generate-rules=NUM Generate NUM random rules",
408 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
409 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
410 " --generate-rules-seed=NUM Force RNG seed to NUM",
411 "",
412 "* Custom charsets:",
413 "",
414 " -1, --custom-charset1=CS User-defined charsets",
415 " -2, --custom-charset2=CS Example:",
416 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
417 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
418 "",
419 "* Increment:",
420 "",
421 " -i, --increment Enable increment mode",
422 " --increment-min=NUM Start incrementing at NUM",
423 " --increment-max=NUM Stop incrementing at NUM",
424 "",
425 "==========",
426 "References",
427 "==========",
428 "",
429 "* Workload Profile:",
430 "",
431 " 1 = Reduced performance profile (low latency desktop)",
432 " 2 = Default performance profile",
433 " 3 = Tuned performance profile (high latency desktop)",
434 "",
435 "* Benchmark Settings:",
436 "",
437 " 0 = Manual Tuning",
438 " 1 = Performance Tuning, default",
439 "",
440 "* Outfile Formats:",
441 "",
442 " 1 = hash[:salt]",
443 " 2 = plain",
444 " 3 = hash[:salt]:plain",
445 " 4 = hex_plain",
446 " 5 = hash[:salt]:hex_plain",
447 " 6 = plain:hex_plain",
448 " 7 = hash[:salt]:plain:hex_plain",
449 " 8 = crackpos",
450 " 9 = hash[:salt]:crackpos",
451 " 10 = plain:crackpos",
452 " 11 = hash[:salt]:plain:crackpos",
453 " 12 = hex_plain:crackpos",
454 " 13 = hash[:salt]:hex_plain:crackpos",
455 " 14 = plain:hex_plain:crackpos",
456 " 15 = hash[:salt]:plain:hex_plain:crackpos",
457 "",
458 "* Debug mode output formats (for hybrid mode only, by using rules):",
459 "",
460 " 1 = save finding rule",
461 " 2 = save original word",
462 " 3 = save original word and finding rule",
463 " 4 = save original word, finding rule and modified plain",
464 "",
465 "* Built-in charsets:",
466 "",
467 " ?l = abcdefghijklmnopqrstuvwxyz",
468 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
469 " ?d = 0123456789",
470 " ?s = !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~",
471 " ?a = ?l?u?d?s",
472 " ?b = 0x00 - 0xff",
473 "",
474 "* Attack modes:",
475 "",
476 " 0 = Straight",
477 " 1 = Combination",
478 " 3 = Brute-force",
479 " 6 = Hybrid dict + mask",
480 " 7 = Hybrid mask + dict",
481 "",
482 "* Hash types:",
483 "",
484 "[[ Roll-your-own: Raw Hashes ]]",
485 "",
486 " 900 = MD4",
487 " 0 = MD5",
488 " 5100 = Half MD5",
489 " 100 = SHA1",
490 " 10800 = SHA-384",
491 " 1400 = SHA-256",
492 " 1700 = SHA-512",
493 " 5000 = SHA-3(Keccak)",
494 " 10100 = SipHash",
495 " 6000 = RipeMD160",
496 " 6100 = Whirlpool",
497 " 6900 = GOST R 34.11-94",
498 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
499 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
500 "",
501 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
502 "",
503 " 10 = md5($pass.$salt)",
504 " 20 = md5($salt.$pass)",
505 " 30 = md5(unicode($pass).$salt)",
506 " 40 = md5($salt.unicode($pass))",
507 " 3800 = md5($salt.$pass.$salt)",
508 " 3710 = md5($salt.md5($pass))",
509 " 2600 = md5(md5($pass)",
510 " 4300 = md5(strtoupper(md5($pass)))",
511 " 4400 = md5(sha1($pass))",
512 " 110 = sha1($pass.$salt)",
513 " 120 = sha1($salt.$pass)",
514 " 130 = sha1(unicode($pass).$salt)",
515 " 140 = sha1($salt.unicode($pass))",
516 " 4500 = sha1(sha1($pass)",
517 " 4700 = sha1(md5($pass))",
518 " 4900 = sha1($salt.$pass.$salt)",
519 " 1410 = sha256($pass.$salt)",
520 " 1420 = sha256($salt.$pass)",
521 " 1430 = sha256(unicode($pass).$salt)",
522 " 1440 = sha256($salt.unicode($pass))",
523 " 1710 = sha512($pass.$salt)",
524 " 1720 = sha512($salt.$pass)",
525 " 1730 = sha512(unicode($pass).$salt)",
526 " 1740 = sha512($salt.unicode($pass))",
527 "",
528 "[[ Roll-your-own: Authenticated Hashes ]]",
529 "",
530 " 50 = HMAC-MD5 (key = $pass)",
531 " 60 = HMAC-MD5 (key = $salt)",
532 " 150 = HMAC-SHA1 (key = $pass)",
533 " 160 = HMAC-SHA1 (key = $salt)",
534 " 1450 = HMAC-SHA256 (key = $pass)",
535 " 1460 = HMAC-SHA256 (key = $salt)",
536 " 1750 = HMAC-SHA512 (key = $pass)",
537 " 1760 = HMAC-SHA512 (key = $salt)",
538 "",
539 "[[ Generic KDF ]]",
540 "",
541 " 400 = phpass",
542 " 8900 = scrypt",
543 " 11900 = PBKDF2-HMAC-MD5",
544 " 12000 = PBKDF2-HMAC-SHA1",
545 " 10900 = PBKDF2-HMAC-SHA256",
546 " 12100 = PBKDF2-HMAC-SHA512",
547 "",
548 "[[ Network protocols, Challenge-Response ]]",
549 "",
550 " 23 = Skype",
551 " 2500 = WPA/WPA2",
552 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
553 " 5300 = IKE-PSK MD5",
554 " 5400 = IKE-PSK SHA1",
555 " 5500 = NetNTLMv1",
556 " 5500 = NetNTLMv1 + ESS",
557 " 5600 = NetNTLMv2",
558 " 7300 = IPMI2 RAKP HMAC-SHA1",
559 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
560 " 8300 = DNSSEC (NSEC3)",
561 " 10200 = Cram MD5",
562 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
563 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
564 " 11400 = SIP digest authentication (MD5)",
565 "",
566 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
567 "",
568 " 121 = SMF (Simple Machines Forum)",
569 " 400 = phpBB3",
570 " 2611 = vBulletin < v3.8.5",
571 " 2711 = vBulletin > v3.8.5",
572 " 2811 = MyBB",
573 " 2811 = IPB (Invison Power Board)",
574 " 8400 = WBB3 (Woltlab Burning Board)",
575 " 11 = Joomla < 2.5.18",
576 " 400 = Joomla > 2.5.18",
577 " 400 = Wordpress",
578 " 2612 = PHPS",
579 " 7900 = Drupal7",
580 " 21 = osCommerce",
581 " 21 = xt:Commerce",
582 " 11000 = PrestaShop",
583 " 124 = Django (SHA-1)",
584 " 10000 = Django (PBKDF2-SHA256)",
585 " 3711 = Mediawiki B type",
586 " 7600 = Redmine",
587 "",
588 "[[ Database Server ]]",
589 "",
590 " 12 = PostgreSQL",
591 " 131 = MSSQL(2000)",
592 " 132 = MSSQL(2005)",
593 " 1731 = MSSQL(2012)",
594 " 1731 = MSSQL(2014)",
595 " 200 = MySQL323",
596 " 300 = MySQL4.1/MySQL5",
597 " 3100 = Oracle H: Type (Oracle 7+)",
598 " 112 = Oracle S: Type (Oracle 11+)",
599 " 12300 = Oracle T: Type (Oracle 12+)",
600 " 8000 = Sybase ASE",
601 "",
602 "[[ HTTP, SMTP, LDAP Server]]",
603 "",
604 " 141 = EPiServer 6.x < v4",
605 " 1441 = EPiServer 6.x > v4",
606 " 1600 = Apache $apr1$",
607 " 12600 = ColdFusion 10+",
608 " 1421 = hMailServer",
609 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
610 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
611 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
612 "",
613 "[[ Checksums ]]",
614 "",
615 " 11500 = CRC32",
616 "",
617 "[[ Operating-Systems ]]",
618 "",
619 " 3000 = LM",
620 " 1000 = NTLM",
621 " 1100 = Domain Cached Credentials (DCC), MS Cache",
622 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
623 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
624 " 1500 = descrypt, DES(Unix), Traditional DES",
625 " 12400 = BSDiCrypt, Extended DES",
626 " 500 = md5crypt $1$, MD5(Unix)",
627 " 3200 = bcrypt $2*$, Blowfish(Unix)",
628 " 7400 = sha256crypt $5$, SHA256(Unix)",
629 " 1800 = sha512crypt $6$, SHA512(Unix)",
630 " 122 = OSX v10.4",
631 " 122 = OSX v10.5",
632 " 122 = OSX v10.6",
633 " 1722 = OSX v10.7",
634 " 7100 = OSX v10.8",
635 " 7100 = OSX v10.9",
636 " 7100 = OSX v10.10",
637 " 6300 = AIX {smd5}",
638 " 6700 = AIX {ssha1}",
639 " 6400 = AIX {ssha256}",
640 " 6500 = AIX {ssha512}",
641 " 2400 = Cisco-PIX",
642 " 2410 = Cisco-ASA",
643 " 500 = Cisco-IOS $1$",
644 " 5700 = Cisco-IOS $4$",
645 " 9200 = Cisco-IOS $8$",
646 " 9300 = Cisco-IOS $9$",
647 " 22 = Juniper Netscreen/SSG (ScreenOS)",
648 " 501 = Juniper IVE",
649 " 5800 = Android PIN",
650 " 8100 = Citrix Netscaler",
651 " 8500 = RACF",
652 " 7200 = GRUB 2",
653 " 9900 = Radmin2",
654 "",
655 "[[ Enterprise Application Software (EAS) ]]",
656 "",
657 " 7700 = SAP CODVN B (BCODE)",
658 " 7800 = SAP CODVN F/G (PASSCODE)",
659 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
660 " 8600 = Lotus Notes/Domino 5",
661 " 8700 = Lotus Notes/Domino 6",
662 " 9100 = Lotus Notes/Domino 8",
663 " 133 = PeopleSoft",
664 "",
665 "[[ Archives ]]",
666 "",
667 " 11600 = 7-Zip",
668 " 12500 = RAR3-hp",
669 "",
670 "[[ Full-Disk encryptions (FDE) ]]",
671 "",
672 " 62XY = TrueCrypt 5.0+",
673 " X = 1 = PBKDF2-HMAC-RipeMD160",
674 " X = 2 = PBKDF2-HMAC-SHA512",
675 " X = 3 = PBKDF2-HMAC-Whirlpool",
676 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
677 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
678 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
679 " Y = 3 = XTS 1536 bit (Ciphers: All)",
680 " 8800 = Android FDE < v4.3",
681 " 12200 = eCryptfs",
682 "",
683 "[[ Documents ]]",
684 "",
685 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
686 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
687 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
688 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
689 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
690 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
691 " 9400 = MS Office 2007",
692 " 9500 = MS Office 2010",
693 " 9600 = MS Office 2013",
694 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
695 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
696 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
697 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
698 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
699 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
700 "",
701 "[[ Password Managers ]]",
702 "",
703 " 9000 = Password Safe v2",
704 " 5200 = Password Safe v3",
705 " 6800 = Lastpass",
706 " 6600 = 1Password, agilekeychain",
707 " 8200 = 1Password, cloudkeychain",
708 " 11300 = Bitcoin/Litecoin wallet.dat",
709 " 12700 = Blockchain, My Wallet",
710 "",
711 NULL
712 };
713
714 /**
715 * oclHashcat specific functions
716 */
717
718 void status_display_automat ()
719 {
720 FILE *out = stdout;
721
722 fprintf (out, "STATUS\t%u\t", data.devices_status);
723
724 /**
725 * speed new
726 */
727
728 fprintf (out, "SPEED\t");
729
730 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
731 {
732 hc_device_param_t *device_param = &data.devices_param[device_id];
733
734 uint64_t speed_cnt = 0;
735 float speed_ms = 0;
736
737 for (int i = 0; i < SPEED_CACHE; i++)
738 {
739 float rec_ms;
740
741 hc_timer_get (device_param->speed_rec[i], rec_ms);
742
743 if (rec_ms > SPEED_MAXAGE) continue;
744
745 speed_cnt += device_param->speed_cnt[i];
746 speed_ms += device_param->speed_ms[i];
747 }
748
749 speed_cnt /= SPEED_CACHE;
750 speed_ms /= SPEED_CACHE;
751
752 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
753 }
754
755 /**
756 * words_cur
757 */
758
759 uint64_t words_cur = get_lowest_words_done ();
760
761 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
762
763 /**
764 * counter
765 */
766
767 uint salts_left = data.salts_cnt - data.salts_done;
768
769 if (salts_left == 0) salts_left = 1;
770
771 uint64_t progress_total = data.words_cnt * salts_left;
772
773 uint64_t all_done = 0;
774 uint64_t all_rejected = 0;
775 uint64_t all_restored = 0;
776
777 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
778 {
779 if (salts_left > 1)
780 {
781 // otherwise the final cracked status shows 0/XXX progress
782
783 if (data.salts_shown[salt_pos] == 1) continue;
784 }
785
786 all_done += data.words_progress_done[salt_pos];
787 all_rejected += data.words_progress_rejected[salt_pos];
788 all_restored += data.words_progress_restored[salt_pos];
789 }
790
791 uint64_t progress_cur = all_restored + all_done + all_rejected;
792 uint64_t progress_end = progress_total;
793
794 uint64_t progress_skip = 0;
795
796 if (data.skip)
797 {
798 progress_skip = MIN (data.skip, data.words_base) * salts_left;
799
800 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.gpu_rules_cnt;
801 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
802 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
803 }
804
805 if (data.limit)
806 {
807 progress_end = MIN (data.limit, data.words_base) * salts_left;
808
809 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.gpu_rules_cnt;
810 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
811 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
812 }
813
814 uint64_t progress_cur_relative_skip = progress_cur - progress_skip;
815 uint64_t progress_end_relative_skip = progress_end - progress_skip;
816
817 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
818
819 /**
820 * cracks
821 */
822
823 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
824 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
825
826 /**
827 * temperature
828 */
829
830 if (data.gpu_temp_disable == 0)
831 {
832 fprintf (out, "TEMP\t");
833
834 hc_thread_mutex_lock (mux_adl);
835
836 for (uint i = 0; i < data.devices_cnt; i++)
837 {
838 int temp = hm_get_temperature_with_device_id (i);
839
840 fprintf (out, "%d\t", temp);
841 }
842
843 hc_thread_mutex_unlock (mux_adl);
844 }
845
846 #ifdef _WIN
847 fputc ('\r', out);
848 fputc ('\n', out);
849 #endif
850
851 #ifdef _POSIX
852 fputc ('\n', out);
853 #endif
854
855 fflush (out);
856 }
857
858 void status_display ()
859 {
860 if (data.devices_status == STATUS_INIT) return;
861 if (data.devices_status == STATUS_STARTING) return;
862 if (data.devices_status == STATUS_BYPASS) return;
863
864 if (data.status_automat == 1)
865 {
866 status_display_automat ();
867
868 return;
869 }
870
871 char tmp_buf[1000];
872
873 uint tmp_len = 0;
874
875 log_info ("Session.Name...: %s", data.session);
876
877 char *status_type = strstatus (data.devices_status);
878
879 uint hash_mode = data.hash_mode;
880
881 char *hash_type = strhashtype (hash_mode); // not a bug
882
883 log_info ("Status.........: %s", status_type);
884
885 /**
886 * show rules
887 */
888
889 if (data.rp_files_cnt)
890 {
891 uint i;
892
893 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
894 {
895 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
896 }
897
898 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
899
900 log_info ("Rules.Type.....: %s", tmp_buf);
901
902 tmp_len = 0;
903 }
904
905 if (data.rp_gen)
906 {
907 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
908
909 if (data.rp_gen_seed)
910 {
911 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
912 }
913 }
914
915 /**
916 * show input
917 */
918
919 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
920 {
921 if (data.wordlist_mode == WL_MODE_FILE)
922 {
923 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
924 }
925 else if (data.wordlist_mode == WL_MODE_STDIN)
926 {
927 log_info ("Input.Mode.....: Pipe");
928 }
929 }
930 else if (data.attack_mode == ATTACK_MODE_COMBI)
931 {
932 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
933 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
934 }
935 else if (data.attack_mode == ATTACK_MODE_BF)
936 {
937 char *mask = data.mask;
938
939 if (mask != NULL)
940 {
941 uint mask_len = data.css_cnt;
942
943 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
944
945 if (mask_len > 0)
946 {
947 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
948 {
949 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
950 {
951 mask_len -= data.salts_buf[0].salt_len;
952 }
953 }
954
955 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
956
957 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
958 }
959
960 if (data.maskcnt > 1)
961 {
962 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
963
964 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
965 }
966
967 log_info ("Input.Mode.....: %s", tmp_buf);
968 }
969
970 tmp_len = 0;
971 }
972 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
973 {
974 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
975 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
976 }
977 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
978 {
979 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
980 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
981 }
982
983 if (data.digests_cnt == 1)
984 {
985 if (data.hash_mode == 2500)
986 {
987 wpa_t *wpa = (wpa_t *) data.esalts_buf;
988
989 uint pke[25];
990
991 char *pke_ptr = (char *) pke;
992
993 for (uint i = 0; i < 25; i++)
994 {
995 pke[i] = byte_swap_32 (wpa->pke[i]);
996 }
997
998 char mac1[6];
999 char mac2[6];
1000
1001 memcpy (mac1, pke_ptr + 23, 6);
1002 memcpy (mac2, pke_ptr + 29, 6);
1003
1004 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1005 (char *) data.salts_buf[0].salt_buf,
1006 mac1[0] & 0xff,
1007 mac1[1] & 0xff,
1008 mac1[2] & 0xff,
1009 mac1[3] & 0xff,
1010 mac1[4] & 0xff,
1011 mac1[5] & 0xff,
1012 mac2[0] & 0xff,
1013 mac2[1] & 0xff,
1014 mac2[2] & 0xff,
1015 mac2[3] & 0xff,
1016 mac2[4] & 0xff,
1017 mac2[5] & 0xff);
1018 }
1019 else if (data.hash_mode == 5200)
1020 {
1021 log_info ("Hash.Target....: File (%s)", data.hashfile);
1022 }
1023 else if (data.hash_mode == 9000)
1024 {
1025 log_info ("Hash.Target....: File (%s)", data.hashfile);
1026 }
1027 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1028 {
1029 log_info ("Hash.Target....: File (%s)", data.hashfile);
1030 }
1031 else
1032 {
1033 char out_buf[4096];
1034
1035 ascii_digest (out_buf, 0, 0);
1036
1037 // limit length
1038 if (strlen (out_buf) > 40)
1039 {
1040 out_buf[41] = '.';
1041 out_buf[42] = '.';
1042 out_buf[43] = '.';
1043 out_buf[44] = 0;
1044 }
1045
1046 log_info ("Hash.Target....: %s", out_buf);
1047 }
1048 }
1049 else
1050 {
1051 if (data.hash_mode == 3000)
1052 {
1053 char out_buf1[4096];
1054 char out_buf2[4096];
1055
1056 ascii_digest (out_buf1, 0, 0);
1057 ascii_digest (out_buf2, 0, 1);
1058
1059 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1060 }
1061 else
1062 {
1063 log_info ("Hash.Target....: File (%s)", data.hashfile);
1064 }
1065 }
1066
1067 log_info ("Hash.Type......: %s", hash_type);
1068
1069 /**
1070 * speed new
1071 */
1072
1073 uint64_t speed_cnt[DEVICES_MAX];
1074 float speed_ms[DEVICES_MAX];
1075
1076 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1077 {
1078 hc_device_param_t *device_param = &data.devices_param[device_id];
1079
1080 // we need to clear values (set to 0) because in case the gpu does
1081 // not get new candidates it idles around but speed display would
1082 // show it as working.
1083 // if we instantly set it to 0 after reading it happens that the
1084 // speed can be shown as zero if the users refreshs to fast.
1085 // therefore, we add a timestamp when a stat was recorded and if its
1086 // to old we will not use it
1087
1088 speed_cnt[device_id] = 0;
1089 speed_ms[device_id] = 0;
1090
1091 for (int i = 0; i < SPEED_CACHE; i++)
1092 {
1093 float rec_ms;
1094
1095 hc_timer_get (device_param->speed_rec[i], rec_ms);
1096
1097 if (rec_ms > SPEED_MAXAGE) continue;
1098
1099 speed_cnt[device_id] += device_param->speed_cnt[i];
1100 speed_ms[device_id] += device_param->speed_ms[i];
1101 }
1102
1103 speed_cnt[device_id] /= SPEED_CACHE;
1104 speed_ms[device_id] /= SPEED_CACHE;
1105 }
1106
1107 float hashes_all_ms = 0;
1108
1109 float hashes_dev_ms[DEVICES_MAX];
1110
1111 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1112 {
1113 hashes_dev_ms[device_id] = 0;
1114
1115 if (speed_ms[device_id])
1116 {
1117 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1118
1119 hashes_all_ms += hashes_dev_ms[device_id];
1120 }
1121 }
1122
1123 /**
1124 * timers
1125 */
1126
1127 float ms_running = 0;
1128
1129 hc_timer_get (data.timer_running, ms_running);
1130
1131 float ms_paused = data.ms_paused;
1132
1133 if (data.devices_status == STATUS_PAUSED)
1134 {
1135 float ms_paused_tmp = 0;
1136
1137 hc_timer_get (data.timer_paused, ms_paused_tmp);
1138
1139 ms_paused += ms_paused_tmp;
1140 }
1141
1142 #ifdef WIN
1143
1144 __time64_t sec_run = ms_running / 1000;
1145
1146 #else
1147
1148 time_t sec_run = ms_running / 1000;
1149
1150 #endif
1151
1152 if (sec_run)
1153 {
1154 char display_run[32];
1155
1156 struct tm tm_run;
1157
1158 struct tm *tmp;
1159
1160 #ifdef WIN
1161
1162 tmp = _gmtime64 (&sec_run);
1163
1164 #else
1165
1166 tmp = gmtime (&sec_run);
1167
1168 #endif
1169
1170 if (tmp != NULL)
1171 {
1172 memcpy (&tm_run, tmp, sizeof (struct tm));
1173
1174 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1175
1176 char *start = ctime (&data.proc_start);
1177
1178 size_t start_len = strlen (start);
1179
1180 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1181 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1182
1183 log_info ("Time.Started...: %s (%s)", start, display_run);
1184 }
1185 }
1186 else
1187 {
1188 log_info ("Time.Started...: 0 secs");
1189 }
1190
1191 /**
1192 * counters
1193 */
1194
1195 uint salts_left = data.salts_cnt - data.salts_done;
1196
1197 if (salts_left == 0) salts_left = 1;
1198
1199 uint64_t progress_total = data.words_cnt * salts_left;
1200
1201 uint64_t all_done = 0;
1202 uint64_t all_rejected = 0;
1203 uint64_t all_restored = 0;
1204
1205 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1206 {
1207 if (salts_left > 1)
1208 {
1209 // otherwise the final cracked status shows 0/XXX progress
1210
1211 if (data.salts_shown[salt_pos] == 1) continue;
1212 }
1213
1214 all_done += data.words_progress_done[salt_pos];
1215 all_rejected += data.words_progress_rejected[salt_pos];
1216 all_restored += data.words_progress_restored[salt_pos];
1217 }
1218
1219 uint64_t progress_cur = all_restored + all_done + all_rejected;
1220 uint64_t progress_end = progress_total;
1221
1222 uint64_t progress_skip = 0;
1223
1224 if (data.skip)
1225 {
1226 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1227
1228 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.gpu_rules_cnt;
1229 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1230 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1231 }
1232
1233 if (data.limit)
1234 {
1235 progress_end = MIN (data.limit, data.words_base) * salts_left;
1236
1237 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.gpu_rules_cnt;
1238 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1239 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1240 }
1241
1242 uint64_t progress_cur_relative_skip = progress_cur - progress_skip;
1243 uint64_t progress_end_relative_skip = progress_end - progress_skip;
1244
1245 float speed_ms_real = ms_running - ms_paused;
1246 uint64_t speed_plains_real = all_done;
1247
1248 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1249 {
1250 if (data.devices_status != STATUS_CRACKED)
1251 {
1252 uint64_t words_per_ms = 0;
1253
1254 if (speed_plains_real && speed_ms_real)
1255 {
1256 words_per_ms = speed_plains_real / speed_ms_real;
1257 }
1258
1259 #ifdef WIN
1260 __time64_t sec_etc = 0;
1261 #else
1262 time_t sec_etc = 0;
1263 #endif
1264
1265 if (words_per_ms)
1266 {
1267 uint64_t progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1268
1269 uint64_t ms_left = progress_left_relative_skip / words_per_ms;
1270
1271 sec_etc = ms_left / 1000;
1272 }
1273
1274 if (sec_etc == 0)
1275 {
1276 log_info ("Time.Estimated.: 0 secs");
1277 }
1278 else if ((uint64_t) sec_etc > ETC_MAX)
1279 {
1280 log_info ("Time.Estimated.: > 10 Years");
1281 }
1282 else
1283 {
1284 char display_etc[32];
1285
1286 struct tm tm_etc;
1287
1288 struct tm *tmp;
1289
1290 #ifdef WIN
1291
1292 tmp = _gmtime64 (&sec_etc);
1293
1294 #else
1295
1296 tmp = gmtime (&sec_etc);
1297
1298 #endif
1299
1300 if (tmp != NULL)
1301 {
1302 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1303
1304 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1305
1306 time_t now;
1307
1308 time (&now);
1309
1310 now += sec_etc;
1311
1312 char *etc = ctime (&now);
1313
1314 size_t etc_len = strlen (etc);
1315
1316 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1317 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1318
1319 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1320 }
1321 }
1322 }
1323 }
1324
1325 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1326 {
1327 char display_dev_cur[16];
1328
1329 memset (display_dev_cur, 0, sizeof (display_dev_cur));
1330
1331 strncpy (display_dev_cur, "0.00", 4);
1332
1333 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1334
1335 log_info ("Speed.GPU.#%d...: %9sH/s", device_id + 1, display_dev_cur);
1336 }
1337
1338 char display_all_cur[16];
1339
1340 memset (display_all_cur, 0, sizeof (display_all_cur));
1341
1342 strncpy (display_all_cur, "0.00", 4);
1343
1344 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1345
1346 if (data.devices_cnt > 1) log_info ("Speed.GPU.#*...: %9sH/s", display_all_cur);
1347
1348 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1349 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1350
1351 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);
1352
1353 // crack-per-time
1354
1355 if (data.digests_cnt > 100)
1356 {
1357 time_t now = time (NULL);
1358
1359 int cpt_cur_min = 0;
1360 int cpt_cur_hour = 0;
1361 int cpt_cur_day = 0;
1362
1363 for (int i = 0; i < CPT_BUF; i++)
1364 {
1365 const uint cracked = data.cpt_buf[i].cracked;
1366 const time_t timestamp = data.cpt_buf[i].timestamp;
1367
1368 if ((timestamp + 60) > now)
1369 {
1370 cpt_cur_min += cracked;
1371 }
1372
1373 if ((timestamp + 3600) > now)
1374 {
1375 cpt_cur_hour += cracked;
1376 }
1377
1378 if ((timestamp + 86400) > now)
1379 {
1380 cpt_cur_day += cracked;
1381 }
1382 }
1383
1384 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1385 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1386 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1387
1388 if ((data.cpt_start + 86400) < now)
1389 {
1390 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1391 cpt_cur_min,
1392 cpt_cur_hour,
1393 cpt_cur_day,
1394 cpt_avg_min,
1395 cpt_avg_hour,
1396 cpt_avg_day);
1397 }
1398 else if ((data.cpt_start + 3600) < now)
1399 {
1400 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1401 cpt_cur_min,
1402 cpt_cur_hour,
1403 cpt_avg_min,
1404 cpt_avg_hour,
1405 cpt_avg_day);
1406 }
1407 else if ((data.cpt_start + 60) < now)
1408 {
1409 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1410 cpt_cur_min,
1411 cpt_avg_min,
1412 cpt_avg_hour,
1413 cpt_avg_day);
1414 }
1415 else
1416 {
1417 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1418 cpt_avg_min,
1419 cpt_avg_hour,
1420 cpt_avg_day);
1421 }
1422 }
1423
1424 // Restore point
1425
1426 uint64_t restore_point = get_lowest_words_done ();
1427
1428 uint64_t restore_total = data.words_base;
1429
1430 float percent_restore = 0;
1431
1432 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1433
1434 if (progress_end_relative_skip)
1435 {
1436 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1437 {
1438 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1439 float percent_rejected = 0.0;
1440
1441 if (progress_cur)
1442 {
1443 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1444 }
1445
1446 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);
1447 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1448
1449 if (data.restore_disable == 0)
1450 {
1451 if (percent_finished != 1)
1452 {
1453 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1454 }
1455 }
1456 }
1457 }
1458 else
1459 {
1460 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1461 {
1462 log_info ("Progress.......: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1463 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1464
1465 if (data.restore_disable == 0)
1466 {
1467 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1468 }
1469 }
1470 else
1471 {
1472 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1473 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1474
1475 // --restore not allowed if stdin is used -- really? why?
1476
1477 //if (data.restore_disable == 0)
1478 //{
1479 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1480 //}
1481 }
1482 }
1483
1484 if (data.gpu_temp_disable == 0)
1485 {
1486 hc_thread_mutex_lock (mux_adl);
1487
1488 for (uint i = 0; i < data.devices_cnt; i++)
1489 {
1490 if (data.hm_device[i].fan_supported == 1)
1491 {
1492 const int temperature = hm_get_temperature_with_device_id (i);
1493 const int utilization = hm_get_utilization_with_device_id (i);
1494 const int fanspeed = hm_get_fanspeed_with_device_id (i);
1495
1496 if (data.vendor_id == VENDOR_ID_AMD)
1497 {
1498 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, %2d%% Fan", i + 1, utilization, temperature, fanspeed);
1499 }
1500
1501 if (data.vendor_id == VENDOR_ID_NV)
1502 {
1503 #ifdef LINUX
1504 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, %2d%% Fan", i + 1, utilization, temperature, fanspeed);
1505 #else
1506 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, %2drpm Fan", i + 1, utilization, temperature, fanspeed);
1507 #endif
1508 }
1509 }
1510 else
1511 {
1512 const int temperature = hm_get_temperature_with_device_id (i);
1513 const int utilization = hm_get_utilization_with_device_id (i);
1514
1515 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, N/A Fan", i + 1, utilization, temperature);
1516 }
1517 }
1518
1519 hc_thread_mutex_unlock (mux_adl);
1520 }
1521 }
1522
1523 static void status_benchmark ()
1524 {
1525 if (data.devices_status == STATUS_INIT) return;
1526 if (data.devices_status == STATUS_STARTING) return;
1527
1528 if (data.words_cnt == 0) return;
1529
1530 uint64_t speed_cnt[DEVICES_MAX];
1531 float speed_ms[DEVICES_MAX];
1532
1533 uint device_id;
1534
1535 for (device_id = 0; device_id < data.devices_cnt; device_id++)
1536 {
1537 hc_device_param_t *device_param = &data.devices_param[device_id];
1538
1539 speed_cnt[device_id] = 0;
1540 speed_ms[device_id] = 0;
1541
1542 for (int i = 0; i < SPEED_CACHE; i++)
1543 {
1544 speed_cnt[device_id] += device_param->speed_cnt[i];
1545 speed_ms[device_id] += device_param->speed_ms[i];
1546 }
1547
1548 speed_cnt[device_id] /= SPEED_CACHE;
1549 speed_ms[device_id] /= SPEED_CACHE;
1550 }
1551
1552 float hashes_all_ms = 0;
1553
1554 float hashes_dev_ms[DEVICES_MAX];
1555
1556 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1557 {
1558 hashes_dev_ms[device_id] = 0;
1559
1560 if (speed_ms[device_id])
1561 {
1562 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1563
1564 hashes_all_ms += hashes_dev_ms[device_id];
1565 }
1566 }
1567
1568 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1569 {
1570 char display_dev_cur[16];
1571
1572 memset (display_dev_cur, 0, sizeof (display_dev_cur));
1573
1574 strncpy (display_dev_cur, "0.00", 4);
1575
1576 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1577
1578 log_info ("Speed.GPU.#%d.: %9sH/s", device_id + 1, display_dev_cur);
1579 }
1580
1581 char display_all_cur[16];
1582
1583 memset (display_all_cur, 0, sizeof (display_all_cur));
1584
1585 strncpy (display_all_cur, "0.00", 4);
1586
1587 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1588
1589 if (data.devices_cnt > 1) log_info ("Speed.GPU.#*.: %9sH/s", display_all_cur);
1590 }
1591
1592 /**
1593 * oclHashcat -only- functions
1594 */
1595
1596 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *install_dir, char *source_file)
1597 {
1598 if (attack_exec == ATTACK_EXEC_ON_GPU)
1599 {
1600 if (attack_kern == ATTACK_KERN_STRAIGHT)
1601 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", install_dir, (int) kern_type);
1602 else if (attack_kern == ATTACK_KERN_COMBI)
1603 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", install_dir, (int) kern_type);
1604 else if (attack_kern == ATTACK_KERN_BF)
1605 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", install_dir, (int) kern_type);
1606 }
1607 else
1608 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", install_dir, (int) kern_type);
1609 }
1610
1611 static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *install_dir, char *device_name, char *device_version, char *driver_version, int vendor_id, char *cached_file)
1612 {
1613 if (attack_exec == ATTACK_EXEC_ON_GPU)
1614 {
1615 if (attack_kern == ATTACK_KERN_STRAIGHT)
1616 snprintf (cached_file, 255, "%s/kernels/%d/m%05d_a0.%s_%s_%s_%d.kernel", install_dir, vendor_id, (int) kern_type, device_name, device_version, driver_version, COMPTIME);
1617 else if (attack_kern == ATTACK_KERN_COMBI)
1618 snprintf (cached_file, 255, "%s/kernels/%d/m%05d_a1.%s_%s_%s_%d.kernel", install_dir, vendor_id, (int) kern_type, device_name, device_version, driver_version, COMPTIME);
1619 else if (attack_kern == ATTACK_KERN_BF)
1620 snprintf (cached_file, 255, "%s/kernels/%d/m%05d_a3.%s_%s_%s_%d.kernel", install_dir, vendor_id, (int) kern_type, device_name, device_version, driver_version, COMPTIME);
1621 }
1622 else
1623 {
1624 snprintf (cached_file, 255, "%s/kernels/%d/m%05d.%s_%s_%s_%d.kernel", install_dir, vendor_id, (int) kern_type, device_name, device_version, driver_version, COMPTIME);
1625 }
1626 }
1627
1628 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *install_dir, char *source_file)
1629 {
1630 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1631 {
1632 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", install_dir);
1633 }
1634 else
1635 {
1636 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", install_dir);
1637 }
1638 }
1639
1640 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *install_dir, char *device_name, char *device_version, char *driver_version, int vendor_id, char *cached_file)
1641 {
1642 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1643 {
1644 snprintf (cached_file, 255, "%s/kernels/%d/markov_be.%s_%s_%s_%d.kernel", install_dir, vendor_id, device_name, device_version, driver_version, COMPTIME);
1645 }
1646 else
1647 {
1648 snprintf (cached_file, 255, "%s/kernels/%d/markov_le.%s_%s_%s_%d.kernel", install_dir, vendor_id, device_name, device_version, driver_version, COMPTIME);
1649 }
1650 }
1651
1652 static void generate_source_kernel_amp_filename (const uint attack_kern, char *install_dir, char *source_file)
1653 {
1654 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", install_dir, attack_kern);
1655 }
1656
1657 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *install_dir, char *device_name, char *device_version, char *driver_version, int vendor_id, char *cached_file)
1658 {
1659 snprintf (cached_file, 255, "%s/kernels/%d/amp_a%d.%s_%s_%s_%d.kernel", install_dir, vendor_id, attack_kern, device_name, device_version, driver_version, COMPTIME);
1660 }
1661
1662 static uint convert_from_hex (char *line_buf, const uint line_len)
1663 {
1664 if (line_len & 1) return (line_len); // not in hex
1665
1666 if (data.hex_wordlist == 1)
1667 {
1668 uint i;
1669 uint j;
1670
1671 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1672 {
1673 line_buf[i] = hex_to_char (&line_buf[j]);
1674 }
1675
1676 memset (line_buf + i, 0, line_len - i);
1677
1678 return (i);
1679 }
1680 else if (line_len >= 6) // $HEX[] = 6
1681 {
1682 if (line_buf[0] != '$') return (line_len);
1683 if (line_buf[1] != 'H') return (line_len);
1684 if (line_buf[2] != 'E') return (line_len);
1685 if (line_buf[3] != 'X') return (line_len);
1686 if (line_buf[4] != '[') return (line_len);
1687 if (line_buf[line_len - 1] != ']') return (line_len);
1688
1689 uint i;
1690 uint j;
1691
1692 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1693 {
1694 line_buf[i] = hex_to_char (&line_buf[j]);
1695 }
1696
1697 memset (line_buf + i, 0, line_len - i);
1698
1699 return (i);
1700 }
1701
1702 return (line_len);
1703 }
1704
1705 static uint count_lines (FILE *fd)
1706 {
1707 uint cnt = 0;
1708
1709 char *buf = (char *) mymalloc (BUFSIZ);
1710
1711 size_t nread_tmp = 0;
1712
1713 char *ptr = buf;
1714
1715 while (!feof (fd))
1716 {
1717 size_t nread = fread (buf, sizeof (char), BUFSIZ, fd);
1718 nread_tmp = nread;
1719
1720 if (nread < 1) continue;
1721
1722 ptr = buf;
1723
1724 do
1725 {
1726 if (*ptr++ == '\n') cnt++;
1727
1728 } while (nread--);
1729 }
1730
1731 // special case (if last line did not contain a newline char ... at the very end of the file)
1732
1733 if (nread_tmp > 3)
1734 {
1735 ptr -= 2;
1736
1737 if (*ptr != '\n')
1738 {
1739 ptr--;
1740
1741 if (*ptr != '\n') // needed ? different on windows systems?
1742 {
1743 cnt++;
1744 }
1745 }
1746 }
1747
1748 myfree (buf);
1749
1750 return cnt;
1751 }
1752
1753 static void clear_prompt ()
1754 {
1755 fputc ('\r', stdout);
1756
1757 for (size_t i = 0; i < strlen (PROMPT); i++)
1758 {
1759 fputc (' ', stdout);
1760 }
1761
1762 fputc ('\r', stdout);
1763
1764 fflush (stdout);
1765 }
1766
1767 static void gidd_to_pw_t (hc_device_param_t *device_param, const uint64_t gidd, pw_t *pw)
1768 {
1769 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1770 }
1771
1772 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1773 {
1774 char *outfile = data.outfile;
1775 uint quiet = data.quiet;
1776 FILE *pot_fp = data.pot_fp;
1777 uint loopback = data.loopback;
1778 uint debug_mode = data.debug_mode;
1779 char *debug_file = data.debug_file;
1780
1781 char debug_rule_buf[BLOCK_SIZE];
1782 int debug_rule_len = 0; // -1 error
1783 uint debug_plain_len = 0;
1784
1785 unsigned char debug_plain_ptr[BLOCK_SIZE];
1786
1787 // hash
1788
1789 char out_buf[4096]; memset (out_buf, 0, sizeof (out_buf));
1790
1791 ascii_digest (out_buf, salt_pos, digest_pos);
1792
1793 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1794
1795 // plain
1796
1797 plain_t plain;
1798
1799 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, idx * sizeof (plain_t), sizeof (plain_t), &plain, 0, NULL, NULL);
1800
1801 uint gidvid = plain.gidvid;
1802 uint il_pos = plain.il_pos;
1803
1804 uint64_t crackpos = device_param->words_off;
1805
1806 uint plain_buf[16];
1807
1808 unsigned char *plain_ptr = (unsigned char *) plain_buf;
1809 unsigned int plain_len = 0;
1810
1811 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1812 {
1813 uint64_t gidd = gidvid;
1814 uint64_t gidm = 0;
1815
1816 pw_t pw;
1817
1818 gidd_to_pw_t (device_param, gidd, &pw);
1819
1820 for (int i = 0, j = gidm; i < 16; i++, j++)
1821 {
1822 plain_buf[i] = pw.hi1[0][j];
1823 }
1824
1825 plain_len = pw.pw_len;
1826
1827 const uint off = device_param->innerloop_pos + il_pos;
1828
1829 if (debug_mode > 0)
1830 {
1831 debug_rule_len = 0;
1832
1833 // save rule
1834 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1835 {
1836 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1837
1838 debug_rule_len = gpu_rule_to_cpu_rule (debug_rule_buf, &data.gpu_rules_buf[off]);
1839 }
1840
1841 // save plain
1842 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1843 {
1844 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1845
1846 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1847
1848 debug_plain_len = plain_len;
1849 }
1850 }
1851
1852 plain_len = apply_rules (data.gpu_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1853
1854 crackpos += gidvid;
1855 crackpos *= data.gpu_rules_cnt;
1856 crackpos += device_param->innerloop_pos + il_pos;
1857
1858 if (plain_len > data.pw_max) plain_len = data.pw_max;
1859 }
1860 else if (data.attack_mode == ATTACK_MODE_COMBI)
1861 {
1862 uint64_t gidd = gidvid;
1863 uint64_t gidm = 0;
1864
1865 pw_t pw;
1866
1867 gidd_to_pw_t (device_param, gidd, &pw);
1868
1869 for (int i = 0, j = gidm; i < 16; i++, j++)
1870 {
1871 plain_buf[i] = pw.hi1[0][j];
1872 }
1873
1874 plain_len = pw.pw_len;
1875
1876 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1877 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1878
1879 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1880 {
1881 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1882 }
1883 else
1884 {
1885 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1886
1887 memcpy (plain_ptr, comb_buf, comb_len);
1888 }
1889
1890 plain_len += comb_len;
1891
1892 crackpos += gidvid;
1893 crackpos *= data.combs_cnt;
1894 crackpos += device_param->innerloop_pos + il_pos;
1895
1896 if (data.pw_max != PW_DICTMAX1)
1897 {
1898 if (plain_len > data.pw_max) plain_len = data.pw_max;
1899 }
1900 }
1901 else if (data.attack_mode == ATTACK_MODE_BF)
1902 {
1903 uint64_t l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1904 uint64_t r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1905
1906 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1907 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1908
1909 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1910 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1911
1912 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1913 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1914
1915 plain_len = data.css_cnt;
1916
1917 crackpos += gidvid;
1918 crackpos *= data.bfs_cnt;
1919 crackpos += device_param->innerloop_pos + il_pos;
1920 }
1921 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1922 {
1923 uint64_t gidd = gidvid;
1924 uint64_t gidm = 0;
1925
1926 pw_t pw;
1927
1928 gidd_to_pw_t (device_param, gidd, &pw);
1929
1930 for (int i = 0, j = gidm; i < 16; i++, j++)
1931 {
1932 plain_buf[i] = pw.hi1[0][j];
1933 }
1934
1935 plain_len = pw.pw_len;
1936
1937 uint64_t off = device_param->kernel_params_mp_buf64[3] + il_pos;
1938
1939 uint start = 0;
1940 uint stop = device_param->kernel_params_mp_buf32[4];
1941
1942 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
1943
1944 plain_len += start + stop;
1945
1946 crackpos += gidvid;
1947 crackpos *= data.combs_cnt;
1948 crackpos += device_param->innerloop_pos + il_pos;
1949
1950 if (data.pw_max != PW_DICTMAX1)
1951 {
1952 if (plain_len > data.pw_max) plain_len = data.pw_max;
1953 }
1954 }
1955 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1956 {
1957 uint64_t gidd = gidvid;
1958 uint64_t gidm = 0;
1959
1960 pw_t pw;
1961
1962 gidd_to_pw_t (device_param, gidd, &pw);
1963
1964 for (int i = 0, j = gidm; i < 16; i++, j++)
1965 {
1966 plain_buf[i] = pw.hi1[0][j];
1967 }
1968
1969 plain_len = pw.pw_len;
1970
1971 uint64_t off = device_param->kernel_params_mp_buf64[3] + il_pos;
1972
1973 uint start = 0;
1974 uint stop = device_param->kernel_params_mp_buf32[4];
1975
1976 memmove (plain_ptr + stop, plain_ptr, plain_len);
1977
1978 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
1979
1980 plain_len += start + stop;
1981
1982 crackpos += gidvid;
1983 crackpos *= data.combs_cnt;
1984 crackpos += device_param->innerloop_pos + il_pos;
1985
1986 if (data.pw_max != PW_DICTMAX1)
1987 {
1988 if (plain_len > data.pw_max) plain_len = data.pw_max;
1989 }
1990 }
1991
1992 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
1993 {
1994 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1995 {
1996 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1997 {
1998 plain_len = plain_len - data.salts_buf[0].salt_len;
1999 }
2000 }
2001
2002 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2003 {
2004 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2005 {
2006 plain_ptr[j] = plain_ptr[i];
2007 }
2008
2009 plain_len = plain_len / 2;
2010 }
2011 }
2012
2013 // if enabled, update also the potfile
2014
2015 if (pot_fp)
2016 {
2017 fprintf (pot_fp, "%s:", out_buf);
2018
2019 format_plain (pot_fp, plain_ptr, plain_len, 1);
2020
2021 fputc ('\n', pot_fp);
2022
2023 fflush (pot_fp);
2024 }
2025
2026 // outfile
2027
2028 FILE *out_fp = NULL;
2029
2030 if (outfile != NULL)
2031 {
2032 if ((out_fp = fopen (outfile, "ab")) == NULL)
2033 {
2034 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2035
2036 out_fp = stdout;
2037 }
2038 }
2039 else
2040 {
2041 out_fp = stdout;
2042
2043 if (quiet == 0) clear_prompt ();
2044 }
2045
2046 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2047
2048 if (outfile != NULL)
2049 {
2050 if (out_fp != stdout)
2051 {
2052 fclose (out_fp);
2053 }
2054 }
2055 else
2056 {
2057 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2058 {
2059 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2060 {
2061 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2062 if (quiet == 0) fflush (stdout);
2063 }
2064 }
2065 }
2066
2067 // loopback
2068
2069 if (loopback)
2070 {
2071 char *loopback_file = data.loopback_file;
2072
2073 FILE *fb_fp = NULL;
2074
2075 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2076 {
2077 format_plain (fb_fp, plain_ptr, plain_len, 1);
2078
2079 fputc ('\n', fb_fp);
2080
2081 fclose (fb_fp);
2082 }
2083 }
2084
2085 // (rule) debug mode
2086
2087 // the next check implies that:
2088 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2089 // - debug_mode > 0
2090
2091 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2092 {
2093 if (debug_rule_len < 0) debug_rule_len = 0;
2094
2095 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2096
2097 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2098
2099 if ((quiet == 0) && (debug_file == NULL))
2100 {
2101 fprintf (stdout, "%s", PROMPT);
2102 fflush (stdout);
2103 }
2104 }
2105 }
2106
2107 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2108 {
2109 salt_t *salt_buf = &data.salts_buf[salt_pos];
2110
2111 int found = 0;
2112
2113 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2114
2115 for (uint i = 0; i < GPU_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2116
2117 if (found == 1)
2118 {
2119 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2120
2121 log_info_nn ("");
2122
2123 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);
2124
2125 uint cpt_cracked = 0;
2126
2127 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2128 {
2129 uint idx = salt_buf->digests_offset + digest_pos;
2130
2131 if (data.digests_shown_tmp[idx] == 0) continue;
2132
2133 if (data.digests_shown[idx] == 1) continue;
2134
2135 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2136 {
2137 data.digests_shown[idx] = 1;
2138
2139 data.digests_done++;
2140
2141 cpt_cracked++;
2142
2143 salt_buf->digests_done++;
2144
2145 if (salt_buf->digests_done == salt_buf->digests_cnt)
2146 {
2147 data.salts_shown[salt_pos] = 1;
2148
2149 data.salts_done++;
2150 }
2151 }
2152
2153 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2154
2155 check_hash (device_param, salt_pos, digest_pos);
2156 }
2157
2158 if (cpt_cracked > 0)
2159 {
2160 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2161 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2162
2163 data.cpt_pos++;
2164
2165 data.cpt_total += cpt_cracked;
2166
2167 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2168 }
2169
2170 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2171 {
2172 // we need to reset cracked state on the gpu
2173 // otherwise host thinks again and again the hash was cracked
2174 // and returns invalid password each time
2175
2176 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2177
2178 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);
2179 }
2180
2181 memset (device_param->result, 0, device_param->size_results);
2182
2183 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2184 }
2185 }
2186
2187 static void save_hash ()
2188 {
2189 char *hashfile = data.hashfile;
2190
2191 char new_hashfile[256];
2192 char old_hashfile[256];
2193
2194 memset (new_hashfile, 0, sizeof (new_hashfile));
2195 memset (old_hashfile, 0, sizeof (old_hashfile));
2196
2197 snprintf (new_hashfile, 255, "%s.new", hashfile);
2198 snprintf (old_hashfile, 255, "%s.old", hashfile);
2199
2200 unlink (new_hashfile);
2201
2202 char separator = data.separator;
2203
2204 FILE *fp = fopen (new_hashfile, "wb");
2205
2206 if (fp == NULL)
2207 {
2208 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2209
2210 exit (-1);
2211 }
2212
2213 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2214 {
2215 if (data.salts_shown[salt_pos] == 1) continue;
2216
2217 salt_t *salt_buf = &data.salts_buf[salt_pos];
2218
2219 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2220 {
2221 uint idx = salt_buf->digests_offset + digest_pos;
2222
2223 if (data.digests_shown[idx] == 1) continue;
2224
2225 if (data.hash_mode != 2500)
2226 {
2227 char out_buf[4096];
2228
2229 memset (out_buf, 0, sizeof (out_buf));
2230
2231 if (data.username == 1)
2232 {
2233 user_t *user = data.hash_info[idx]->user;
2234
2235 uint i;
2236
2237 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2238
2239 fputc (separator, fp);
2240 }
2241
2242 ascii_digest (out_buf, salt_pos, digest_pos);
2243
2244 fputs (out_buf, fp);
2245
2246 log_out (fp, "");
2247 }
2248 else
2249 {
2250 hccap_t hccap;
2251
2252 to_hccap_t (&hccap, salt_pos, digest_pos);
2253
2254 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2255 }
2256 }
2257 }
2258
2259 fflush (fp);
2260
2261 fclose (fp);
2262
2263 unlink (old_hashfile);
2264
2265 if (rename (hashfile, old_hashfile) != 0)
2266 {
2267 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2268
2269 exit (-1);
2270 }
2271
2272 unlink (hashfile);
2273
2274 if (rename (new_hashfile, hashfile) != 0)
2275 {
2276 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2277
2278 exit (-1);
2279 }
2280
2281 unlink (old_hashfile);
2282 }
2283
2284 static float find_gpu_blocks_div (const uint64_t total_left, const uint gpu_blocks_all)
2285 {
2286 // function called only in case gpu_blocks_all > words_left)
2287
2288 float gpu_blocks_div = (float) (total_left) / gpu_blocks_all;
2289
2290 gpu_blocks_div += gpu_blocks_div / 100;
2291
2292 uint32_t gpu_blocks_new = (uint32_t) (gpu_blocks_all * gpu_blocks_div);
2293
2294 while (gpu_blocks_new < total_left)
2295 {
2296 gpu_blocks_div += gpu_blocks_div / 100;
2297
2298 gpu_blocks_new = (uint32_t) (gpu_blocks_all * gpu_blocks_div);
2299 }
2300
2301 if (data.quiet == 0)
2302 {
2303 clear_prompt ();
2304
2305 log_info ("");
2306
2307 log_info ("INFO: approaching final keyspace, workload adjusted");
2308
2309 log_info ("");
2310
2311 fprintf (stdout, "%s", PROMPT);
2312
2313 fflush (stdout);
2314 }
2315
2316 if ((gpu_blocks_all * gpu_blocks_div) < 8) return 1;
2317
2318 return gpu_blocks_div;
2319 }
2320
2321 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num)
2322 {
2323 uint num_elements = num;
2324
2325 device_param->kernel_params_buf32[30] = data.combs_mode;
2326 device_param->kernel_params_buf32[31] = num;
2327
2328 uint gpu_threads = device_param->gpu_threads;
2329
2330 while (num_elements % gpu_threads) num_elements++;
2331
2332 cl_kernel kernel = NULL;
2333
2334 switch (kern_run)
2335 {
2336 case KERN_RUN_1: kernel = device_param->kernel1; break;
2337 case KERN_RUN_12: kernel = device_param->kernel12; break;
2338 case KERN_RUN_2: kernel = device_param->kernel2; break;
2339 case KERN_RUN_23: kernel = device_param->kernel23; break;
2340 case KERN_RUN_3: kernel = device_param->kernel3; break;
2341 }
2342
2343 hc_clSetKernelArg (kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2344 hc_clSetKernelArg (kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2345 hc_clSetKernelArg (kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2346 hc_clSetKernelArg (kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2347 hc_clSetKernelArg (kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2348 hc_clSetKernelArg (kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2349 hc_clSetKernelArg (kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2350 hc_clSetKernelArg (kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2351 hc_clSetKernelArg (kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2352 hc_clSetKernelArg (kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2353 hc_clSetKernelArg (kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2354
2355 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2356 {
2357 const size_t global_work_size[3] = { num_elements, 32, 1 };
2358 const size_t local_work_size[3] = { gpu_threads / 32, 32, 1 };
2359
2360 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2361 }
2362 else
2363 {
2364 const size_t global_work_size[3] = { num_elements, 1, 1 };
2365 const size_t local_work_size[3] = { gpu_threads, 1, 1 };
2366
2367 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2368 }
2369
2370 hc_clFlush (device_param->command_queue);
2371
2372 hc_clFinish (device_param->command_queue);
2373 }
2374
2375 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2376 {
2377 uint num_elements = num;
2378
2379 switch (kern_run)
2380 {
2381 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2382 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2383 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2384 }
2385
2386 // causes problems with special threads like in bcrypt
2387 // const uint gpu_threads = device_param->gpu_threads;
2388
2389 const uint gpu_threads = GPU_THREADS;
2390
2391 while (num_elements % gpu_threads) num_elements++;
2392
2393 cl_kernel kernel = NULL;
2394
2395 switch (kern_run)
2396 {
2397 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2398 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2399 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2400 }
2401
2402 switch (kern_run)
2403 {
2404 case KERN_RUN_MP: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2405 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2406 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2407 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2408 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2409 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2410 break;
2411 case KERN_RUN_MP_R: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2412 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2413 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2414 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2415 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2416 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2417 break;
2418 case KERN_RUN_MP_L: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2419 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2420 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2421 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2422 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2423 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2424 hc_clSetKernelArg (kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2425 break;
2426 }
2427
2428 const size_t global_work_size[3] = { num_elements, 1, 1 };
2429 const size_t local_work_size[3] = { gpu_threads, 1, 1 };
2430
2431 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2432
2433 hc_clFlush (device_param->command_queue);
2434
2435 hc_clFinish (device_param->command_queue);
2436 }
2437
2438 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2439 {
2440 uint num_elements = num;
2441
2442 uint gpu_threads = device_param->gpu_threads;
2443
2444 while (num_elements % gpu_threads) num_elements++;
2445
2446 cl_kernel kernel = device_param->kernel_tb;
2447
2448 const size_t global_work_size[3] = { num_elements, 1, 1 };
2449 const size_t local_work_size[3] = { gpu_threads, 1, 1 };
2450
2451 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2452
2453 hc_clFlush (device_param->command_queue);
2454
2455 hc_clFinish (device_param->command_queue);
2456 }
2457
2458 static void run_kernel_tm (hc_device_param_t *device_param)
2459 {
2460 const uint num_elements = 1024; // fixed
2461
2462 const uint gpu_threads = 32;
2463
2464 cl_kernel kernel = device_param->kernel_tm;
2465
2466 const size_t global_work_size[3] = { num_elements, 1, 1 };
2467 const size_t local_work_size[3] = { gpu_threads, 1, 1 };
2468
2469 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2470
2471 hc_clFlush (device_param->command_queue);
2472
2473 hc_clFinish (device_param->command_queue);
2474 }
2475
2476 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2477 {
2478 uint num_elements = num;
2479
2480 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2481 device_param->kernel_params_amp_buf32[6] = num_elements;
2482
2483 // causes problems with special threads like in bcrypt
2484 // const uint gpu_threads = device_param->gpu_threads;
2485
2486 const uint gpu_threads = GPU_THREADS;
2487
2488 while (num_elements % gpu_threads) num_elements++;
2489
2490 cl_kernel kernel = device_param->kernel_amp;
2491
2492 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2493 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2494
2495 const size_t global_work_size[3] = { num_elements, 1, 1 };
2496 const size_t local_work_size[3] = { gpu_threads, 1, 1 };
2497
2498 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2499
2500 hc_clFlush (device_param->command_queue);
2501
2502 hc_clFinish (device_param->command_queue);
2503 }
2504
2505 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2506 {
2507 if (data.vendor_id == VENDOR_ID_AMD)
2508 {
2509 const cl_uchar zero = 0;
2510
2511 hc_clEnqueueFillBuffer (device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2512 }
2513
2514 if (data.vendor_id == VENDOR_ID_NV)
2515 {
2516 // NOTE: clEnqueueFillBuffer () always fails with -59
2517 // IOW, it's not supported by Nvidia ForceWare <= 352.21,
2518 // How's that possible, OpenCL 1.2 support is advertised??
2519 // We need to workaround...
2520
2521 #define FILLSZ 0x100000
2522
2523 char *tmp = (char *) mymalloc (FILLSZ);
2524
2525 memset (tmp, 0, FILLSZ);
2526
2527 for (uint i = 0; i < size; i += FILLSZ)
2528 {
2529 const int left = size - i;
2530
2531 const int fillsz = MIN (FILLSZ, left);
2532
2533 hc_clEnqueueWriteBuffer (device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2534 }
2535
2536 myfree (tmp);
2537 }
2538 }
2539
2540 static int run_rule_engine (const int rule_len, const char *rule_buf)
2541 {
2542 if (rule_len == 0)
2543 {
2544 return 0;
2545 }
2546 else if (rule_len == 1)
2547 {
2548 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2549 }
2550
2551 return 1;
2552 }
2553
2554 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2555 {
2556 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2557 {
2558 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);
2559 }
2560 else if (data.attack_kern == ATTACK_KERN_COMBI)
2561 {
2562 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);
2563 }
2564 else if (data.attack_kern == ATTACK_KERN_BF)
2565 {
2566 const uint64_t off = device_param->words_off;
2567
2568 device_param->kernel_params_mp_l_buf64[3] = off;
2569
2570 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2571 }
2572 }
2573
2574 static void run_cracker (hc_device_param_t *device_param, const uint pw_cnt, const uint pws_cnt)
2575 {
2576 const uint gpu_loops = data.gpu_loops;
2577
2578 // init speed timer
2579
2580 uint speed_pos = device_param->speed_pos;
2581
2582 #ifdef _POSIX
2583 if (device_param->timer_speed.tv_sec == 0)
2584 {
2585 hc_timer_set (&device_param->timer_speed);
2586 }
2587 #endif
2588
2589 #ifdef _WIN
2590 if (device_param->timer_speed.QuadPart == 0)
2591 {
2592 hc_timer_set (&device_param->timer_speed);
2593 }
2594 #endif
2595
2596 // find higest password length, this is for optimization stuff
2597
2598 uint highest_pw_len = 0;
2599
2600 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2601 {
2602 }
2603 else if (data.attack_kern == ATTACK_KERN_COMBI)
2604 {
2605 }
2606 else if (data.attack_kern == ATTACK_KERN_BF)
2607 {
2608 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
2609 + device_param->kernel_params_mp_l_buf32[5];
2610 }
2611
2612 // bitslice optimization stuff
2613
2614 if (data.attack_mode == ATTACK_MODE_BF)
2615 {
2616 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2617 {
2618 run_kernel_tb (device_param, pws_cnt);
2619 }
2620 }
2621
2622 // iteration type
2623
2624 uint innerloop_step = 0;
2625 uint innerloop_cnt = 0;
2626
2627 if (data.attack_exec == ATTACK_EXEC_ON_GPU) innerloop_step = gpu_loops;
2628 else innerloop_step = 1;
2629
2630 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.gpu_rules_cnt;
2631 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
2632 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
2633
2634 // loop start: most outer loop = salt iteration, then innerloops (if multi)
2635
2636 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2637 {
2638 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2639
2640 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2641
2642 if (data.devices_status == STATUS_CRACKED) break;
2643 if (data.devices_status == STATUS_ABORTED) break;
2644 if (data.devices_status == STATUS_QUIT) break;
2645 if (data.devices_status == STATUS_BYPASS) break;
2646
2647 if (data.salts_shown[salt_pos] == 1) continue;
2648
2649 salt_t *salt_buf = &data.salts_buf[salt_pos];
2650
2651 device_param->kernel_params_buf32[24] = salt_pos;
2652 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
2653 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
2654
2655 FILE *combs_fp = device_param->combs_fp;
2656
2657 if (data.attack_mode == ATTACK_MODE_COMBI)
2658 {
2659 rewind (combs_fp);
2660 }
2661
2662 // innerloops
2663
2664 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
2665 {
2666 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2667
2668 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2669
2670 if (data.devices_status == STATUS_CRACKED) break;
2671 if (data.devices_status == STATUS_ABORTED) break;
2672 if (data.devices_status == STATUS_QUIT) break;
2673 if (data.devices_status == STATUS_BYPASS) break;
2674
2675 uint innerloop_left = innerloop_cnt - innerloop_pos;
2676
2677 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
2678
2679 device_param->innerloop_pos = innerloop_pos;
2680 device_param->innerloop_left = innerloop_left;
2681
2682 device_param->kernel_params_buf32[27] = innerloop_left;
2683
2684 if (innerloop_left == 0) continue;
2685
2686 // initialize amplifiers
2687
2688 if (data.attack_mode == ATTACK_MODE_COMBI)
2689 {
2690 char line_buf[BUFSIZ];
2691
2692 uint i = 0;
2693
2694 while (i < innerloop_left)
2695 {
2696 if (feof (combs_fp)) break;
2697
2698 int line_len = fgetl (combs_fp, line_buf);
2699
2700 if (line_len >= PW_MAX1) continue;
2701
2702 line_len = convert_from_hex (line_buf, line_len);
2703
2704 char *line_buf_new = line_buf;
2705
2706 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
2707 {
2708 char rule_buf_out[BLOCK_SIZE];
2709
2710 memset (rule_buf_out, 0, sizeof (rule_buf_out));
2711
2712 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
2713
2714 if (rule_len_out < 0)
2715 {
2716 data.words_progress_rejected[salt_pos] += pw_cnt;
2717
2718 continue;
2719 }
2720
2721 line_len = rule_len_out;
2722
2723 line_buf_new = rule_buf_out;
2724 }
2725
2726 line_len = MIN (line_len, PW_DICTMAX);
2727
2728 char *ptr = (char *) device_param->combs_buf[i].i;
2729
2730 memcpy (ptr, line_buf_new, line_len);
2731
2732 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
2733
2734 if (data.opts_type & OPTS_TYPE_PT_UPPER)
2735 {
2736 uppercase (ptr, line_len);
2737 }
2738
2739 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2740 {
2741 if (data.opts_type & OPTS_TYPE_PT_ADD80)
2742 {
2743 ptr[line_len] = 0x80;
2744 }
2745
2746 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2747 {
2748 ptr[line_len] = 0x01;
2749 }
2750 }
2751
2752 device_param->combs_buf[i].pw_len = line_len;
2753
2754 i++;
2755 }
2756
2757 for (uint j = i; j < innerloop_left; j++)
2758 {
2759 device_param->combs_buf[j].i[0] = 0;
2760 device_param->combs_buf[j].i[1] = 0;
2761 device_param->combs_buf[j].i[2] = 0;
2762 device_param->combs_buf[j].i[3] = 0;
2763 device_param->combs_buf[j].i[4] = 0;
2764 device_param->combs_buf[j].i[5] = 0;
2765 device_param->combs_buf[j].i[6] = 0;
2766 device_param->combs_buf[j].i[7] = 0;
2767
2768 device_param->combs_buf[j].pw_len = 0;
2769 }
2770
2771 innerloop_left = i;
2772 }
2773 else if (data.attack_mode == ATTACK_MODE_BF)
2774 {
2775 uint64_t off = innerloop_pos;
2776
2777 device_param->kernel_params_mp_r_buf64[3] = off;
2778
2779 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
2780 }
2781 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2782 {
2783 uint64_t off = innerloop_pos;
2784
2785 device_param->kernel_params_mp_buf64[3] = off;
2786
2787 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2788 }
2789 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2790 {
2791 uint64_t off = innerloop_pos;
2792
2793 device_param->kernel_params_mp_buf64[3] = off;
2794
2795 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2796 }
2797
2798 // copy amplifiers
2799
2800 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2801 {
2802 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);
2803 }
2804 else if (data.attack_mode == ATTACK_MODE_COMBI)
2805 {
2806 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);
2807 }
2808 else if (data.attack_mode == ATTACK_MODE_BF)
2809 {
2810 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);
2811 }
2812 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2813 {
2814 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);
2815 }
2816 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2817 {
2818 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);
2819 }
2820
2821 if (data.attack_exec == ATTACK_EXEC_ON_GPU)
2822 {
2823 if (data.attack_mode == ATTACK_MODE_BF)
2824 {
2825 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2826 {
2827 const uint size_tm = 32 * sizeof (bs_word_t);
2828
2829 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2830
2831 run_kernel_tm (device_param);
2832
2833 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2834 }
2835 }
2836
2837 if (highest_pw_len < 16)
2838 {
2839 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2840 }
2841 else if (highest_pw_len < 32)
2842 {
2843 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2844 }
2845 else
2846 {
2847 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2848 }
2849 }
2850 else
2851 {
2852 run_kernel_amp (device_param, pws_cnt);
2853
2854 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2855
2856 if (data.opts_type & OPTS_TYPE_HOOK12)
2857 {
2858 run_kernel (KERN_RUN_12, device_param, pws_cnt);
2859 }
2860
2861 uint iter = salt_buf->salt_iter;
2862
2863 for (uint loop_pos = 0; loop_pos < iter; loop_pos += gpu_loops)
2864 {
2865 uint loop_left = iter - loop_pos;
2866
2867 loop_left = MIN (loop_left, gpu_loops);
2868
2869 device_param->kernel_params_buf32[25] = loop_pos;
2870 device_param->kernel_params_buf32[26] = loop_left;
2871
2872 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2873
2874 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2875
2876 if (data.devices_status == STATUS_CRACKED) break;
2877 if (data.devices_status == STATUS_ABORTED) break;
2878 if (data.devices_status == STATUS_QUIT) break;
2879 }
2880
2881 if (data.opts_type & OPTS_TYPE_HOOK23)
2882 {
2883 run_kernel (KERN_RUN_23, device_param, pws_cnt);
2884
2885 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2886
2887 // do something with data
2888
2889 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2890 }
2891
2892 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2893 }
2894
2895 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2896
2897 if (data.devices_status == STATUS_CRACKED) break;
2898 if (data.devices_status == STATUS_ABORTED) break;
2899 if (data.devices_status == STATUS_QUIT) break;
2900
2901 /**
2902 * result
2903 */
2904
2905 hc_thread_mutex_lock (mux_display);
2906
2907 check_cracked (device_param, salt_pos);
2908
2909 hc_thread_mutex_unlock (mux_display);
2910
2911 /**
2912 * progress
2913 */
2914
2915 uint64_t perf_sum_all = (uint64_t) pw_cnt * (uint64_t) innerloop_left;
2916
2917 hc_thread_mutex_lock (mux_counter);
2918
2919 data.words_progress_done[salt_pos] += perf_sum_all;
2920
2921 hc_thread_mutex_unlock (mux_counter);
2922
2923 /**
2924 * speed
2925 */
2926
2927 float speed_ms;
2928
2929 hc_timer_get (device_param->timer_speed, speed_ms);
2930
2931 hc_timer_set (&device_param->timer_speed);
2932
2933 hc_thread_mutex_lock (mux_display);
2934
2935 device_param->speed_cnt[speed_pos] = perf_sum_all;
2936
2937 device_param->speed_ms[speed_pos] = speed_ms;
2938
2939 device_param->speed_rec[speed_pos] = device_param->timer_speed;
2940
2941 hc_thread_mutex_unlock (mux_display);
2942
2943 speed_pos++;
2944
2945 if (speed_pos == SPEED_CACHE)
2946 {
2947 speed_pos = 0;
2948 }
2949 }
2950 }
2951
2952 device_param->speed_pos = speed_pos;
2953 }
2954
2955 static void load_segment (wl_data_t *wl_data, FILE *fd)
2956 {
2957 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
2958
2959 wl_data->pos = 0;
2960
2961 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
2962
2963 wl_data->buf[wl_data->cnt] = 0;
2964
2965 if (wl_data->cnt == 0) return;
2966
2967 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
2968
2969 while (!feof (fd))
2970 {
2971 if (wl_data->cnt == wl_data->avail)
2972 {
2973 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
2974
2975 wl_data->avail += wl_data->incr;
2976 }
2977
2978 const int c = fgetc (fd);
2979
2980 if (c == EOF) break;
2981
2982 wl_data->buf[wl_data->cnt] = (char) c;
2983
2984 wl_data->cnt++;
2985
2986 if (c == '\n') break;
2987 }
2988
2989 // ensure stream ends with a newline
2990
2991 if (wl_data->buf[wl_data->cnt - 1] != '\n')
2992 {
2993 wl_data->cnt++;
2994
2995 wl_data->buf[wl_data->cnt - 1] = '\n';
2996 }
2997
2998 return;
2999 }
3000
3001 static void get_next_word_lm (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
3002 {
3003 char *ptr = buf;
3004
3005 for (uint32_t i = 0; i < sz; i++, ptr++)
3006 {
3007 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3008
3009 if (i == 7)
3010 {
3011 *off = i;
3012 *len = i;
3013
3014 return;
3015 }
3016
3017 if (*ptr != '\n') continue;
3018
3019 *off = i + 1;
3020
3021 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3022
3023 *len = i;
3024
3025 return;
3026 }
3027
3028 *off = sz;
3029 *len = sz;
3030 }
3031
3032 static void get_next_word_uc (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
3033 {
3034 char *ptr = buf;
3035
3036 for (uint32_t i = 0; i < sz; i++, ptr++)
3037 {
3038 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3039
3040 if (*ptr != '\n') continue;
3041
3042 *off = i + 1;
3043
3044 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3045
3046 *len = i;
3047
3048 return;
3049 }
3050
3051 *off = sz;
3052 *len = sz;
3053 }
3054
3055 static void get_next_word_std (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
3056 {
3057 char *ptr = buf;
3058
3059 for (uint32_t i = 0; i < sz; i++, ptr++)
3060 {
3061 if (*ptr != '\n') continue;
3062
3063 *off = i + 1;
3064
3065 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3066
3067 *len = i;
3068
3069 return;
3070 }
3071
3072 *off = sz;
3073 *len = sz;
3074 }
3075
3076 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3077 {
3078 while (wl_data->pos < wl_data->cnt)
3079 {
3080 uint off;
3081 uint len;
3082
3083 char *ptr = wl_data->buf + wl_data->pos;
3084
3085 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3086
3087 wl_data->pos += off;
3088
3089 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3090 {
3091 char rule_buf_out[BLOCK_SIZE];
3092
3093 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3094
3095 int rule_len_out = -1;
3096
3097 if (len < BLOCK_SIZE)
3098 {
3099 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3100 }
3101
3102 if (rule_len_out < 0)
3103 {
3104 continue;
3105 }
3106
3107 if (rule_len_out > PW_MAX)
3108 {
3109 continue;
3110 }
3111 }
3112 else
3113 {
3114 if (len > PW_MAX)
3115 {
3116 continue;
3117 }
3118 }
3119
3120 *out_buf = ptr;
3121 *out_len = len;
3122
3123 return;
3124 }
3125
3126 if (feof (fd))
3127 {
3128 fprintf (stderr, "bug!!\n");
3129
3130 return;
3131 }
3132
3133 load_segment (wl_data, fd);
3134
3135 get_next_word (wl_data, fd, out_buf, out_len);
3136 }
3137
3138 #ifdef _POSIX
3139 static uint64_t count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3140 #endif
3141
3142 #ifdef _WIN
3143 static uint64_t count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3144 #endif
3145 {
3146 hc_signal (NULL);
3147
3148 dictstat_t d;
3149
3150 d.cnt = 0;
3151
3152 #ifdef _POSIX
3153 fstat (fileno (fd), &d.stat);
3154 #endif
3155
3156 #ifdef _WIN
3157 _fstat64 (fileno (fd), &d.stat);
3158 #endif
3159
3160 d.stat.st_mode = 0;
3161 d.stat.st_nlink = 0;
3162 d.stat.st_uid = 0;
3163 d.stat.st_gid = 0;
3164 d.stat.st_rdev = 0;
3165 d.stat.st_atime = 0;
3166
3167 #ifdef _POSIX
3168 d.stat.st_blksize = 0;
3169 d.stat.st_blocks = 0;
3170 #endif
3171
3172 if (d.stat.st_size == 0) return 0;
3173
3174 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3175
3176 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3177 {
3178 if (d_cache)
3179 {
3180 uint64_t cnt = d_cache->cnt;
3181
3182 uint64_t keyspace = cnt;
3183
3184 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3185 {
3186 keyspace *= data.gpu_rules_cnt;
3187 }
3188 else if (data.attack_kern == ATTACK_KERN_COMBI)
3189 {
3190 keyspace *= data.combs_cnt;
3191 }
3192
3193 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);
3194 if (data.quiet == 0) log_info ("");
3195
3196 hc_signal (sigHandler_default);
3197
3198 return (keyspace);
3199 }
3200 }
3201
3202 time_t now = 0;
3203 time_t prev = 0;
3204
3205 uint64_t comp = 0;
3206 uint64_t cnt = 0;
3207 uint64_t cnt2 = 0;
3208
3209 while (!feof (fd))
3210 {
3211 load_segment (wl_data, fd);
3212
3213 comp += wl_data->cnt;
3214
3215 uint32_t i = 0;
3216
3217 while (i < wl_data->cnt)
3218 {
3219 uint32_t len;
3220 uint32_t off;
3221
3222 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3223
3224 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3225 {
3226 char rule_buf_out[BLOCK_SIZE];
3227
3228 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3229
3230 int rule_len_out = -1;
3231
3232 if (len < BLOCK_SIZE)
3233 {
3234 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3235 }
3236
3237 if (rule_len_out < 0)
3238 {
3239 len = PW_MAX1;
3240 }
3241 else
3242 {
3243 len = rule_len_out;
3244 }
3245 }
3246
3247 if (len < PW_MAX1)
3248 {
3249 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3250 {
3251 cnt += data.gpu_rules_cnt;
3252 }
3253 else if (data.attack_kern == ATTACK_KERN_COMBI)
3254 {
3255 cnt += data.combs_cnt;
3256 }
3257
3258 d.cnt++;
3259 }
3260
3261 i += off;
3262
3263 cnt2++;
3264 }
3265
3266 time (&now);
3267
3268 if ((now - prev) == 0) continue;
3269
3270 float percent = (float) comp / (float) d.stat.st_size;
3271
3272 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);
3273
3274 time (&prev);
3275 }
3276
3277 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);
3278 if (data.quiet == 0) log_info ("");
3279
3280 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3281
3282 hc_signal (sigHandler_default);
3283
3284 return (cnt);
3285 }
3286
3287 static void pw_transpose_to_hi1 (const pw_t *p1, pw_t *p2)
3288 {
3289 memcpy (p2->hi1, p1->hi1, 64 * sizeof (uint));
3290 }
3291
3292 static uint pw_add_to_hc1 (hc_device_param_t *device_param, const uint8_t *pw_buf, const uint pw_len)
3293 {
3294 if (data.devices_status == STATUS_BYPASS) return 0;
3295
3296 pw_cache_t *pw_cache = device_param->pw_caches + pw_len;
3297
3298 uint cache_cnt = pw_cache->cnt;
3299
3300 uint8_t *pw_hc1 = pw_cache->pw_buf.hc1[cache_cnt];
3301
3302 memcpy (pw_hc1, pw_buf, pw_len);
3303
3304 memset (pw_hc1 + pw_len, 0, 256 - pw_len);
3305
3306 uint pws_cnt = device_param->pws_cnt;
3307
3308 cache_cnt++;
3309
3310 pw_t *pw = device_param->pws_buf + pws_cnt;
3311
3312 device_param->pw_transpose (&pw_cache->pw_buf, pw);
3313
3314 pw->pw_len = pw_len;
3315
3316 pws_cnt++;
3317
3318 device_param->pws_cnt = pws_cnt;
3319 device_param->pw_cnt = pws_cnt * 1;
3320
3321 cache_cnt = 0;
3322
3323 pw_cache->cnt = cache_cnt;
3324
3325 return pws_cnt;
3326 }
3327
3328 static void *thread_monitor (void *p)
3329 {
3330 uint runtime_check = 0;
3331 uint remove_check = 0;
3332 uint status_check = 0;
3333 uint hwmon_check = 0;
3334 uint restore_check = 0;
3335
3336 uint restore_left = data.restore_timer;
3337 uint remove_left = data.remove_timer;
3338 uint status_left = data.status_timer;
3339
3340 // these variables are mainly used for fan control (AMD only)
3341
3342 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3343
3344 // temperature controller "loopback" values
3345
3346 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3347 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3348
3349 int temp_threshold = 1; // degrees celcius
3350
3351 int fan_speed_min = 15; // in percentage
3352 int fan_speed_max = 100;
3353
3354 time_t last_temp_check_time;
3355
3356 uint sleep_time = 1;
3357
3358 if (data.runtime)
3359 {
3360 runtime_check = 1;
3361 }
3362
3363 if (data.restore_timer)
3364 {
3365 restore_check = 1;
3366 }
3367
3368 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3369 {
3370 remove_check = 1;
3371 }
3372
3373 if (data.status == 1)
3374 {
3375 status_check = 1;
3376 }
3377
3378 if (data.gpu_temp_disable == 0)
3379 {
3380 time (&last_temp_check_time);
3381
3382 hwmon_check = 1;
3383 }
3384
3385 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (hwmon_check == 0) && (restore_check == 0))
3386 {
3387 return (p);
3388 }
3389
3390 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3391 {
3392 hc_sleep (sleep_time);
3393
3394 if (data.devices_status != STATUS_RUNNING) continue;
3395
3396 if (hwmon_check == 1)
3397 {
3398 hc_thread_mutex_lock (mux_adl);
3399
3400 time_t temp_check_time;
3401
3402 time (&temp_check_time);
3403
3404 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3405
3406 if (Ta == 0) Ta = 1;
3407
3408 for (uint i = 0; i < data.devices_cnt; i++)
3409 {
3410 const int temperature = hm_get_temperature_with_device_id (i);
3411
3412 if (temperature > (int) data.gpu_temp_abort)
3413 {
3414 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", i + 1);
3415
3416 if (data.devices_status != STATUS_QUIT) myabort ();
3417
3418 break;
3419 }
3420
3421 const int gpu_temp_retain = data.gpu_temp_retain;
3422
3423 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3424 {
3425 if (data.hm_device[i].fan_supported == 1)
3426 {
3427 int temp_cur = temperature;
3428
3429 int temp_diff_new = gpu_temp_retain - temp_cur;
3430
3431 temp_diff_sum[i] = temp_diff_sum[i] + temp_diff_new;
3432
3433 // calculate Ta value (time difference in seconds between the last check and this check)
3434
3435 last_temp_check_time = temp_check_time;
3436
3437 float Kp = 1.8;
3438 float Ki = 0.005;
3439 float Kd = 6;
3440
3441 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3442
3443 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);
3444
3445 if (abs (fan_diff_required) >= temp_threshold)
3446 {
3447 const int fan_speed_cur = hm_get_fanspeed_with_device_id (i);
3448
3449 int fan_speed_level = fan_speed_cur;
3450
3451 if (fan_speed_chgd[i] == 0) fan_speed_level = temp_cur;
3452
3453 int fan_speed_new = fan_speed_level - fan_diff_required;
3454
3455 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3456 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3457
3458 if (fan_speed_new != fan_speed_cur)
3459 {
3460 int freely_change_fan_speed = (fan_speed_chgd[i] == 1);
3461 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3462
3463 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3464 {
3465 hm_set_fanspeed_with_device_id_amd (i, fan_speed_new);
3466
3467 fan_speed_chgd[i] = 1;
3468 }
3469
3470 temp_diff_old[i] = temp_diff_new;
3471 }
3472 }
3473 }
3474 }
3475 }
3476
3477 hc_thread_mutex_unlock (mux_adl);
3478 }
3479
3480 if (restore_check == 1)
3481 {
3482 restore_left--;
3483
3484 if (restore_left == 0)
3485 {
3486 if (data.restore_disable == 0) cycle_restore ();
3487
3488 restore_left = data.restore_timer;
3489 }
3490 }
3491
3492 if ((runtime_check == 1) && (data.runtime_start > 0))
3493 {
3494 time_t runtime_cur;
3495
3496 time (&runtime_cur);
3497
3498 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3499
3500 if (runtime_left <= 0)
3501 {
3502 if (data.benchmark == 0)
3503 {
3504 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3505 }
3506
3507 if (data.devices_status != STATUS_QUIT) myabort ();
3508 }
3509 }
3510
3511 if (remove_check == 1)
3512 {
3513 remove_left--;
3514
3515 if (remove_left == 0)
3516 {
3517 if (data.digests_saved != data.digests_done)
3518 {
3519 data.digests_saved = data.digests_done;
3520
3521 save_hash ();
3522 }
3523
3524 remove_left = data.remove_timer;
3525 }
3526 }
3527
3528 if (status_check == 1)
3529 {
3530 status_left--;
3531
3532 if (status_left == 0)
3533 {
3534 hc_thread_mutex_lock (mux_display);
3535
3536 if (data.quiet == 0) clear_prompt ();
3537
3538 if (data.quiet == 0) log_info ("");
3539
3540 status_display ();
3541
3542 if (data.quiet == 0) log_info ("");
3543
3544 hc_thread_mutex_unlock (mux_display);
3545
3546 status_left = data.status_timer;
3547 }
3548 }
3549 }
3550
3551 myfree (fan_speed_chgd);
3552
3553 myfree (temp_diff_old);
3554 myfree (temp_diff_sum);
3555
3556 p = NULL;
3557
3558 return (p);
3559 }
3560
3561 static void *thread_outfile_remove (void *p)
3562 {
3563 // some hash-dependent constants
3564 char *outfile_dir = data.outfile_check_directory;
3565 uint dgst_size = data.dgst_size;
3566 uint isSalted = data.isSalted;
3567 uint esalt_size = data.esalt_size;
3568 uint hash_mode = data.hash_mode;
3569
3570 uint outfile_check_timer = data.outfile_check_timer;
3571
3572 char separator = data.separator;
3573
3574 // some hash-dependent functions
3575 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3576 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3577
3578 // buffers
3579 hash_t hash_buf;
3580
3581 memset (&hash_buf, 0, sizeof (hash_buf));
3582
3583 hash_buf.digest = mymalloc (dgst_size);
3584
3585 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3586
3587 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3588
3589 uint digest_buf[64];
3590
3591 outfile_data_t *out_info = NULL;
3592
3593 char **out_files = NULL;
3594
3595 time_t folder_mtime = 0;
3596
3597 int out_cnt = 0;
3598
3599 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3600
3601 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3602 {
3603 hc_sleep (1);
3604
3605 if (data.devices_status != STATUS_RUNNING) continue;
3606
3607 check_left--;
3608
3609 if (check_left == 0)
3610 {
3611 struct stat outfile_check_stat;
3612
3613 if (stat (outfile_dir, &outfile_check_stat) == 0)
3614 {
3615 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3616
3617 if (is_dir == 1)
3618 {
3619 if (outfile_check_stat.st_mtime > folder_mtime)
3620 {
3621 char **out_files_new = scan_directory (outfile_dir);
3622
3623 int out_cnt_new = count_dictionaries (out_files_new);
3624
3625 outfile_data_t *out_info_new = NULL;
3626
3627 if (out_cnt_new > 0)
3628 {
3629 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3630
3631 for (int i = 0; i < out_cnt_new; i++)
3632 {
3633 out_info_new[i].file_name = out_files_new[i];
3634
3635 // check if there are files that we have seen/checked before (and not changed)
3636
3637 for (int j = 0; j < out_cnt; j++)
3638 {
3639 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
3640 {
3641 struct stat outfile_stat;
3642
3643 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
3644 {
3645 if (outfile_stat.st_ctime == out_info[j].ctime)
3646 {
3647 out_info_new[i].ctime = out_info[j].ctime;
3648 out_info_new[i].seek = out_info[j].seek;
3649 }
3650 }
3651 }
3652 }
3653 }
3654 }
3655
3656 local_free (out_info);
3657 local_free (out_files);
3658
3659 out_files = out_files_new;
3660 out_cnt = out_cnt_new;
3661 out_info = out_info_new;
3662
3663 folder_mtime = outfile_check_stat.st_mtime;
3664 }
3665
3666 for (int j = 0; j < out_cnt; j++)
3667 {
3668 FILE *fp = fopen (out_info[j].file_name, "rb");
3669
3670 if (fp != NULL)
3671 {
3672 //hc_thread_mutex_lock (mux_display);
3673
3674 #ifdef _POSIX
3675 struct stat outfile_stat;
3676
3677 fstat (fileno (fp), &outfile_stat);
3678 #endif
3679
3680 #ifdef _WIN
3681 struct stat64 outfile_stat;
3682
3683 _fstat64 (fileno (fp), &outfile_stat);
3684 #endif
3685
3686 if (outfile_stat.st_ctime > out_info[j].ctime)
3687 {
3688 out_info[j].ctime = outfile_stat.st_ctime;
3689 out_info[j].seek = 0;
3690 }
3691
3692 fseek (fp, out_info[j].seek, SEEK_SET);
3693
3694 while (!feof (fp))
3695 {
3696 char line_buf[BUFSIZ];
3697
3698 memset (line_buf, 0, BUFSIZ);
3699
3700 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
3701
3702 if (ptr == NULL) break;
3703
3704 int line_len = strlen (line_buf);
3705
3706 if (line_len <= 0) continue;
3707
3708 int iter = MAX_CUT_TRIES;
3709
3710 for (uint i = line_len - 1; i && iter; i--, line_len--)
3711 {
3712 if (line_buf[i] != separator) continue;
3713
3714 int parser_status = PARSER_OK;
3715
3716 if ((hash_mode != 2500) && (hash_mode != 6800))
3717 {
3718 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
3719 }
3720
3721 uint found = 0;
3722
3723 if (parser_status == PARSER_OK)
3724 {
3725 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
3726 {
3727 if (data.salts_shown[salt_pos] == 1) continue;
3728
3729 salt_t *salt_buf = &data.salts_buf[salt_pos];
3730
3731 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
3732 {
3733 uint idx = salt_buf->digests_offset + digest_pos;
3734
3735 if (data.digests_shown[idx] == 1) continue;
3736
3737 uint cracked = 0;
3738
3739 if (hash_mode == 6800)
3740 {
3741 if (i == salt_buf->salt_len)
3742 {
3743 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3744 }
3745 }
3746 else if (hash_mode == 2500)
3747 {
3748 // BSSID : MAC1 : MAC2 (:plain)
3749 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
3750 {
3751 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3752
3753 if (!cracked) continue;
3754
3755 // now compare MAC1 and MAC2 too, since we have this additional info
3756 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
3757 char *mac2_pos = mac1_pos + 12 + 1;
3758
3759 wpa_t *wpas = (wpa_t *) data.esalts_buf;
3760 wpa_t *wpa = &wpas[salt_pos];
3761
3762 uint pke[25];
3763
3764 char *pke_ptr = (char *) pke;
3765
3766 for (uint i = 0; i < 25; i++)
3767 {
3768 pke[i] = byte_swap_32 (wpa->pke[i]);
3769 }
3770
3771 unsigned char mac1[6];
3772 unsigned char mac2[6];
3773
3774 memcpy (mac1, pke_ptr + 23, 6);
3775 memcpy (mac2, pke_ptr + 29, 6);
3776
3777 // compare hex string(s) vs binary MAC address(es)
3778
3779 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3780 {
3781 if (mac1[i] != (unsigned char) hex_to_char (&mac1_pos[j]))
3782 {
3783 cracked = 0;
3784 break;
3785 }
3786 }
3787
3788 // early skip ;)
3789 if (!cracked) continue;
3790
3791 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3792 {
3793 if (mac2[i] != (unsigned char) hex_to_char (&mac2_pos[j]))
3794 {
3795 cracked = 0;
3796 break;
3797 }
3798 }
3799 }
3800 }
3801 else
3802 {
3803 char *digests_buf_ptr = (char *) data.digests_buf;
3804
3805 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
3806
3807 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
3808 }
3809
3810 if (cracked == 1)
3811 {
3812 found = 1;
3813
3814 data.digests_shown[idx] = 1;
3815
3816 data.digests_done++;
3817
3818 salt_buf->digests_done++;
3819
3820 if (salt_buf->digests_done == salt_buf->digests_cnt)
3821 {
3822 data.salts_shown[salt_pos] = 1;
3823
3824 data.salts_done++;
3825
3826 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
3827 }
3828 }
3829 }
3830
3831 if (data.devices_status == STATUS_CRACKED) break;
3832 }
3833 }
3834
3835 if (found) break;
3836
3837 if (data.devices_status == STATUS_CRACKED) break;
3838
3839 iter--;
3840 }
3841
3842 if (data.devices_status == STATUS_CRACKED) break;
3843 }
3844
3845 out_info[j].seek = ftell (fp);
3846
3847 //hc_thread_mutex_unlock (mux_display);
3848
3849 fclose (fp);
3850 }
3851 }
3852 }
3853 }
3854
3855 check_left = outfile_check_timer;
3856 }
3857 }
3858
3859 if (esalt_size) local_free (hash_buf.esalt);
3860
3861 if (isSalted) local_free (hash_buf.salt);
3862
3863 local_free (hash_buf.digest);
3864
3865 local_free (out_info);
3866
3867 local_free (out_files);
3868
3869 p = NULL;
3870
3871 return (p);
3872 }
3873
3874 static uint get_work (hc_device_param_t *device_param, const uint64_t max)
3875 {
3876 hc_thread_mutex_lock (mux_dispatcher);
3877
3878 const uint64_t words_cur = data.words_cur;
3879 const uint64_t words_base = (data.limit == 0) ? data.words_base : data.limit;
3880
3881 device_param->words_off = words_cur;
3882
3883 const uint64_t words_left = words_base - words_cur;
3884
3885 if (data.gpu_blocks_all > words_left)
3886 {
3887 if (data.gpu_blocks_div == 0)
3888 {
3889 data.gpu_blocks_div = find_gpu_blocks_div (words_left, data.gpu_blocks_all);
3890 }
3891 }
3892
3893 if (data.gpu_blocks_div)
3894 {
3895 if (device_param->gpu_blocks == device_param->gpu_blocks_user)
3896 {
3897 const uint32_t gpu_blocks_new = (float) device_param->gpu_blocks * data.gpu_blocks_div;
3898 const uint32_t gpu_power_new = gpu_blocks_new;
3899
3900 if (gpu_blocks_new < device_param->gpu_blocks)
3901 {
3902 device_param->gpu_blocks = gpu_blocks_new;
3903 device_param->gpu_power = gpu_power_new;
3904 }
3905 }
3906 }
3907
3908 const uint gpu_blocks = device_param->gpu_blocks;
3909
3910 uint work = MIN (words_left, gpu_blocks);
3911
3912 work = MIN (work, max);
3913
3914 data.words_cur += work;
3915
3916 hc_thread_mutex_unlock (mux_dispatcher);
3917
3918 return work;
3919 }
3920
3921 static void *thread_calc_stdin (void *p)
3922 {
3923 hc_device_param_t *device_param = (hc_device_param_t *) p;
3924
3925 const uint attack_kern = data.attack_kern;
3926
3927 const uint gpu_blocks = device_param->gpu_blocks;
3928
3929 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3930 {
3931 hc_thread_mutex_lock (mux_dispatcher);
3932
3933 if (feof (stdin) != 0)
3934 {
3935 hc_thread_mutex_unlock (mux_dispatcher);
3936
3937 break;
3938 }
3939
3940 uint words_cur = 0;
3941
3942 while (words_cur < gpu_blocks)
3943 {
3944 char buf[BUFSIZ];
3945
3946 char *line_buf = fgets (buf, sizeof (buf), stdin);
3947
3948 if (line_buf == NULL) break;
3949
3950 uint line_len = in_superchop (line_buf);
3951
3952 line_len = convert_from_hex (line_buf, line_len);
3953
3954 // post-process rule engine
3955
3956 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3957 {
3958 char rule_buf_out[BLOCK_SIZE];
3959
3960 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3961
3962 int rule_len_out = -1;
3963
3964 if (line_len < BLOCK_SIZE)
3965 {
3966 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
3967 }
3968
3969 if (rule_len_out < 0) continue;
3970
3971 line_buf = rule_buf_out;
3972 line_len = rule_len_out;
3973 }
3974
3975 if (line_len > PW_MAX)
3976 {
3977 continue;
3978 }
3979
3980 if (attack_kern == ATTACK_KERN_STRAIGHT)
3981 {
3982 if ((line_len < data.pw_min) || (line_len > data.pw_max))
3983 {
3984 hc_thread_mutex_lock (mux_counter);
3985
3986 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3987 {
3988 data.words_progress_rejected[salt_pos] += data.gpu_rules_cnt;
3989 }
3990
3991 hc_thread_mutex_unlock (mux_counter);
3992
3993 continue;
3994 }
3995 }
3996 else if (attack_kern == ATTACK_KERN_COMBI)
3997 {
3998 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
3999 // since we still need to combine the plains
4000
4001 if (line_len > data.pw_max)
4002 {
4003 hc_thread_mutex_lock (mux_counter);
4004
4005 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4006 {
4007 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4008 }
4009
4010 hc_thread_mutex_unlock (mux_counter);
4011
4012 continue;
4013 }
4014 }
4015
4016 device_param->pw_add (device_param, (uint8_t *) line_buf, line_len);
4017
4018 words_cur++;
4019
4020 if (data.devices_status == STATUS_CRACKED) break;
4021 if (data.devices_status == STATUS_ABORTED) break;
4022 if (data.devices_status == STATUS_QUIT) break;
4023 if (data.devices_status == STATUS_BYPASS) break;
4024 }
4025
4026 hc_thread_mutex_unlock (mux_dispatcher);
4027
4028 if (data.devices_status == STATUS_CRACKED) break;
4029 if (data.devices_status == STATUS_ABORTED) break;
4030 if (data.devices_status == STATUS_QUIT) break;
4031 if (data.devices_status == STATUS_BYPASS) break;
4032
4033 // we need 2 flushing because we have two independant caches and it can occur
4034 // that one buffer is already at threshold plus for that length also exists
4035 // more data in the 2nd buffer so it would overflow
4036
4037 // flush session 1
4038
4039 {
4040 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4041 {
4042 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4043
4044 const uint pw_cache_cnt = pw_cache->cnt;
4045
4046 if (pw_cache_cnt == 0) continue;
4047
4048 pw_cache->cnt = 0;
4049
4050 uint pws_cnt = device_param->pws_cnt;
4051
4052 pw_t *pw = device_param->pws_buf + pws_cnt;
4053
4054 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4055
4056 pw->pw_len = pw_len;
4057
4058 uint pw_cnt = device_param->pw_cnt;
4059
4060 pw_cnt += pw_cache_cnt;
4061
4062 device_param->pw_cnt = pw_cnt;
4063
4064 pws_cnt++;
4065
4066 device_param->pws_cnt = pws_cnt;
4067
4068 if (pws_cnt == device_param->gpu_power_user) break;
4069 }
4070
4071 const uint pw_cnt = device_param->pw_cnt;
4072 const uint pws_cnt = device_param->pws_cnt;
4073
4074 if (pws_cnt)
4075 {
4076 run_copy (device_param, pws_cnt);
4077
4078 run_cracker (device_param, pw_cnt, pws_cnt);
4079
4080 device_param->pw_cnt = 0;
4081 device_param->pws_cnt = 0;
4082 }
4083 }
4084
4085 // flush session 2
4086
4087 {
4088 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4089 {
4090 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4091
4092 const uint pw_cache_cnt = pw_cache->cnt;
4093
4094 if (pw_cache_cnt == 0) continue;
4095
4096 pw_cache->cnt = 0;
4097
4098 uint pws_cnt = device_param->pws_cnt;
4099
4100 pw_t *pw = device_param->pws_buf + pws_cnt;
4101
4102 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4103
4104 pw->pw_len = pw_len;
4105
4106 uint pw_cnt = device_param->pw_cnt;
4107
4108 pw_cnt += pw_cache_cnt;
4109
4110 device_param->pw_cnt = pw_cnt;
4111
4112 pws_cnt++;
4113
4114 device_param->pws_cnt = pws_cnt;
4115 }
4116
4117 const uint pw_cnt = device_param->pw_cnt;
4118 const uint pws_cnt = device_param->pws_cnt;
4119
4120 if (pws_cnt)
4121 {
4122 run_copy (device_param, pws_cnt);
4123
4124 run_cracker (device_param, pw_cnt, pws_cnt);
4125
4126 device_param->pw_cnt = 0;
4127 device_param->pws_cnt = 0;
4128 }
4129 }
4130 }
4131
4132 return NULL;
4133 }
4134
4135 static void *thread_calc (void *p)
4136 {
4137 hc_device_param_t *device_param = (hc_device_param_t *) p;
4138
4139 const uint attack_mode = data.attack_mode;
4140 const uint attack_kern = data.attack_kern;
4141
4142 if (attack_mode == ATTACK_MODE_BF)
4143 {
4144 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4145 {
4146 const uint work = get_work (device_param, -1);
4147
4148 if (work == 0) break;
4149
4150 const uint64_t words_off = device_param->words_off;
4151 const uint64_t words_fin = words_off + work;
4152
4153 const uint pw_cnt = work;
4154 const uint pws_cnt = work;
4155
4156 device_param->pw_cnt = pw_cnt;
4157 device_param->pws_cnt = pws_cnt;
4158
4159 if (pws_cnt)
4160 {
4161 run_copy (device_param, pws_cnt);
4162
4163 run_cracker (device_param, pw_cnt, pws_cnt);
4164
4165 device_param->pw_cnt = 0;
4166 device_param->pws_cnt = 0;
4167 }
4168
4169 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4170
4171 if (data.devices_status == STATUS_CRACKED) break;
4172 if (data.devices_status == STATUS_ABORTED) break;
4173 if (data.devices_status == STATUS_QUIT) break;
4174 if (data.devices_status == STATUS_BYPASS) break;
4175
4176 device_param->words_done = words_fin;
4177 }
4178 }
4179 else
4180 {
4181 const uint segment_size = data.segment_size;
4182
4183 char *dictfile = data.dictfile;
4184
4185 if (attack_mode == ATTACK_MODE_COMBI)
4186 {
4187 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4188 {
4189 dictfile = data.dictfile2;
4190 }
4191 }
4192
4193 FILE *fd = fopen (dictfile, "rb");
4194
4195 if (fd == NULL)
4196 {
4197 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4198
4199 return NULL;
4200 }
4201
4202 if (attack_mode == ATTACK_MODE_COMBI)
4203 {
4204 const uint combs_mode = data.combs_mode;
4205
4206 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4207 {
4208 const char *dictfilec = data.dictfile2;
4209
4210 FILE *combs_fp = fopen (dictfilec, "rb");
4211
4212 if (combs_fp == NULL)
4213 {
4214 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4215
4216 fclose (fd);
4217
4218 return NULL;
4219 }
4220
4221 device_param->combs_fp = combs_fp;
4222 }
4223 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4224 {
4225 const char *dictfilec = data.dictfile;
4226
4227 FILE *combs_fp = fopen (dictfilec, "rb");
4228
4229 if (combs_fp == NULL)
4230 {
4231 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4232
4233 fclose (fd);
4234
4235 return NULL;
4236 }
4237
4238 device_param->combs_fp = combs_fp;
4239 }
4240 }
4241
4242 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4243
4244 wl_data->buf = (char *) mymalloc (segment_size);
4245 wl_data->avail = segment_size;
4246 wl_data->incr = segment_size;
4247 wl_data->cnt = 0;
4248 wl_data->pos = 0;
4249
4250 uint64_t words_cur = 0;
4251
4252 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4253 {
4254 uint64_t words_off = 0;
4255 uint64_t words_fin = 0;
4256
4257 uint64_t max = -1;
4258
4259 while (max)
4260 {
4261 const uint work = get_work (device_param, max);
4262
4263 if (work == 0) break;
4264
4265 words_off = device_param->words_off;
4266 words_fin = words_off + work;
4267
4268 char *line_buf;
4269 uint line_len;
4270
4271 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4272
4273 max = 0;
4274
4275 for ( ; words_cur < words_fin; words_cur++)
4276 {
4277 get_next_word (wl_data, fd, &line_buf, &line_len);
4278
4279 line_len = convert_from_hex (line_buf, line_len);
4280
4281 // post-process rule engine
4282
4283 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4284 {
4285 char rule_buf_out[BLOCK_SIZE];
4286
4287 memset (rule_buf_out, 0, sizeof (rule_buf_out));
4288
4289 int rule_len_out = -1;
4290
4291 if (line_len < BLOCK_SIZE)
4292 {
4293 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4294 }
4295
4296 if (rule_len_out < 0) continue;
4297
4298 line_buf = rule_buf_out;
4299 line_len = rule_len_out;
4300 }
4301
4302 if (attack_kern == ATTACK_KERN_STRAIGHT)
4303 {
4304 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4305 {
4306 max++;
4307
4308 hc_thread_mutex_lock (mux_counter);
4309
4310 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4311 {
4312 data.words_progress_rejected[salt_pos] += data.gpu_rules_cnt;
4313 }
4314
4315 hc_thread_mutex_unlock (mux_counter);
4316
4317 continue;
4318 }
4319 }
4320 else if (attack_kern == ATTACK_KERN_COMBI)
4321 {
4322 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4323 // since we still need to combine the plains
4324
4325 if (line_len > data.pw_max)
4326 {
4327 max++;
4328
4329 hc_thread_mutex_lock (mux_counter);
4330
4331 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4332 {
4333 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4334 }
4335
4336 hc_thread_mutex_unlock (mux_counter);
4337
4338 continue;
4339 }
4340 }
4341
4342 device_param->pw_add (device_param, (uint8_t *) line_buf, line_len);
4343
4344 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4345
4346 if (data.devices_status == STATUS_CRACKED) break;
4347 if (data.devices_status == STATUS_ABORTED) break;
4348 if (data.devices_status == STATUS_QUIT) break;
4349 if (data.devices_status == STATUS_BYPASS) break;
4350 }
4351
4352 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4353
4354 if (data.devices_status == STATUS_CRACKED) break;
4355 if (data.devices_status == STATUS_ABORTED) break;
4356 if (data.devices_status == STATUS_QUIT) break;
4357 if (data.devices_status == STATUS_BYPASS) break;
4358 }
4359
4360 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4361
4362 if (data.devices_status == STATUS_CRACKED) break;
4363 if (data.devices_status == STATUS_ABORTED) break;
4364 if (data.devices_status == STATUS_QUIT) break;
4365 if (data.devices_status == STATUS_BYPASS) break;
4366
4367 // we need 2 flushing because we have two independant caches and it can occur
4368 // that one buffer is already at threshold plus for that length also exists
4369 // more data in the 2nd buffer so it would overflow
4370
4371 //
4372 // flush session 1
4373 //
4374
4375 {
4376 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4377 {
4378 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4379
4380 const uint pw_cache_cnt = pw_cache->cnt;
4381
4382 if (pw_cache_cnt == 0) continue;
4383
4384 pw_cache->cnt = 0;
4385
4386 uint pws_cnt = device_param->pws_cnt;
4387
4388 pw_t *pw = device_param->pws_buf + pws_cnt;
4389
4390 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4391
4392 pw->pw_len = pw_len;
4393
4394 uint pw_cnt = device_param->pw_cnt;
4395
4396 pw_cnt += pw_cache_cnt;
4397
4398 device_param->pw_cnt = pw_cnt;
4399
4400 pws_cnt++;
4401
4402 device_param->pws_cnt = pws_cnt;
4403
4404 if (pws_cnt == device_param->gpu_power_user) break;
4405 }
4406
4407 const uint pw_cnt = device_param->pw_cnt;
4408 const uint pws_cnt = device_param->pws_cnt;
4409
4410 if (pws_cnt)
4411 {
4412 run_copy (device_param, pws_cnt);
4413
4414 run_cracker (device_param, pw_cnt, pws_cnt);
4415
4416 device_param->pw_cnt = 0;
4417 device_param->pws_cnt = 0;
4418 }
4419
4420 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4421
4422 if (data.devices_status == STATUS_CRACKED) break;
4423 if (data.devices_status == STATUS_ABORTED) break;
4424 if (data.devices_status == STATUS_QUIT) break;
4425 if (data.devices_status == STATUS_BYPASS) break;
4426 }
4427
4428 //
4429 // flush session 2
4430 //
4431
4432 {
4433 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4434 {
4435 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4436
4437 const uint pw_cache_cnt = pw_cache->cnt;
4438
4439 if (pw_cache_cnt == 0) continue;
4440
4441 pw_cache->cnt = 0;
4442
4443 uint pws_cnt = device_param->pws_cnt;
4444
4445 pw_t *pw = device_param->pws_buf + pws_cnt;
4446
4447 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4448
4449 pw->pw_len = pw_len;
4450
4451 uint pw_cnt = device_param->pw_cnt;
4452
4453 pw_cnt += pw_cache_cnt;
4454
4455 device_param->pw_cnt = pw_cnt;
4456
4457 pws_cnt++;
4458
4459 device_param->pws_cnt = pws_cnt;
4460 }
4461
4462 const uint pw_cnt = device_param->pw_cnt;
4463 const uint pws_cnt = device_param->pws_cnt;
4464
4465 if (pws_cnt)
4466 {
4467 run_copy (device_param, pws_cnt);
4468
4469 run_cracker (device_param, pw_cnt, pws_cnt);
4470
4471 device_param->pw_cnt = 0;
4472 device_param->pws_cnt = 0;
4473 }
4474
4475 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4476
4477 if (data.devices_status == STATUS_CRACKED) break;
4478 if (data.devices_status == STATUS_ABORTED) break;
4479 if (data.devices_status == STATUS_QUIT) break;
4480 if (data.devices_status == STATUS_BYPASS) break;
4481 }
4482
4483 if (words_fin == 0) break;
4484
4485 device_param->words_done = words_fin;
4486 }
4487
4488 if (attack_mode == ATTACK_MODE_COMBI)
4489 {
4490 fclose (device_param->combs_fp);
4491 }
4492
4493 free (wl_data->buf);
4494 free (wl_data);
4495
4496 fclose (fd);
4497 }
4498
4499 return NULL;
4500 }
4501
4502 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos, const uint gpu_loops)
4503 {
4504 salt_t *salt_buf = &data.salts_buf[salt_pos];
4505
4506 device_param->kernel_params_buf32[24] = salt_pos;
4507 device_param->kernel_params_buf32[27] = 1;
4508 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4509 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4510 device_param->kernel_params_buf32[30] = 0;
4511 device_param->kernel_params_buf32[31] = 1;
4512
4513 char *dictfile_old = data.dictfile;
4514 char *dictfile2_old = data.dictfile2;
4515 char *mask_old = data.mask;
4516
4517 const char *weak_hash_check = "weak-hash-check";
4518
4519 data.dictfile = (char *) weak_hash_check;
4520 data.dictfile2 = (char *) weak_hash_check;
4521 data.mask = (char *) weak_hash_check;
4522
4523 /**
4524 * run the kernel
4525 */
4526
4527 if (data.attack_exec == ATTACK_EXEC_ON_GPU)
4528 {
4529 run_kernel (KERN_RUN_1, device_param, 1);
4530 }
4531 else
4532 {
4533 run_kernel (KERN_RUN_1, device_param, 1);
4534
4535 const uint iter = salt_buf->salt_iter;
4536
4537 for (uint loop_pos = 0; loop_pos < iter; loop_pos += gpu_loops)
4538 {
4539 uint loop_left = iter - loop_pos;
4540
4541 loop_left = MIN (loop_left, gpu_loops);
4542
4543 device_param->kernel_params_buf32[25] = loop_pos;
4544 device_param->kernel_params_buf32[26] = loop_left;
4545
4546 run_kernel (KERN_RUN_2, device_param, 1);
4547 }
4548
4549 run_kernel (KERN_RUN_3, device_param, 1);
4550 }
4551
4552 /**
4553 * result
4554 */
4555
4556 check_cracked (device_param, salt_pos);
4557
4558 /**
4559 * cleanup
4560 */
4561
4562 device_param->kernel_params_buf32[24] = 0;
4563 device_param->kernel_params_buf32[25] = 0;
4564 device_param->kernel_params_buf32[26] = 0;
4565 device_param->kernel_params_buf32[27] = 0;
4566 device_param->kernel_params_buf32[28] = 0;
4567 device_param->kernel_params_buf32[29] = 0;
4568 device_param->kernel_params_buf32[30] = 0;
4569 device_param->kernel_params_buf32[31] = 0;
4570
4571 data.dictfile = dictfile_old;
4572 data.dictfile2 = dictfile2_old;
4573 data.mask = mask_old;
4574 }
4575
4576 // hlfmt hashcat
4577
4578 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4579 {
4580 if (data.username == 0)
4581 {
4582 *hashbuf_pos = line_buf;
4583 *hashbuf_len = line_len;
4584 }
4585 else
4586 {
4587 char *pos = line_buf;
4588 int len = line_len;
4589
4590 for (int i = 0; i < line_len; i++, pos++, len--)
4591 {
4592 if (line_buf[i] == data.separator)
4593 {
4594 pos++;
4595
4596 len--;
4597
4598 break;
4599 }
4600 }
4601
4602 *hashbuf_pos = pos;
4603 *hashbuf_len = len;
4604 }
4605 }
4606
4607 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4608 {
4609 char *pos = NULL;
4610 int len = 0;
4611
4612 int sep_cnt = 0;
4613
4614 for (int i = 0; i < line_len; i++)
4615 {
4616 if (line_buf[i] == data.separator)
4617 {
4618 sep_cnt++;
4619
4620 continue;
4621 }
4622
4623 if (sep_cnt == 0)
4624 {
4625 if (pos == NULL) pos = line_buf + i;
4626
4627 len++;
4628 }
4629 }
4630
4631 *userbuf_pos = pos;
4632 *userbuf_len = len;
4633 }
4634
4635 // hlfmt pwdump
4636
4637 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
4638 {
4639 int sep_cnt = 0;
4640
4641 int sep2_len = 0;
4642 int sep3_len = 0;
4643
4644 for (int i = 0; i < line_len; i++)
4645 {
4646 if (line_buf[i] == ':')
4647 {
4648 sep_cnt++;
4649
4650 continue;
4651 }
4652
4653 if (sep_cnt == 2) sep2_len++;
4654 if (sep_cnt == 3) sep3_len++;
4655 }
4656
4657 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4658
4659 return 0;
4660 }
4661
4662 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4663 {
4664 char *pos = NULL;
4665 int len = 0;
4666
4667 int sep_cnt = 0;
4668
4669 for (int i = 0; i < line_len; i++)
4670 {
4671 if (line_buf[i] == ':')
4672 {
4673 sep_cnt++;
4674
4675 continue;
4676 }
4677
4678 if (data.hash_mode == 1000)
4679 {
4680 if (sep_cnt == 3)
4681 {
4682 if (pos == NULL) pos = line_buf + i;
4683
4684 len++;
4685 }
4686 }
4687 else if (data.hash_mode == 3000)
4688 {
4689 if (sep_cnt == 2)
4690 {
4691 if (pos == NULL) pos = line_buf + i;
4692
4693 len++;
4694 }
4695 }
4696 }
4697
4698 *hashbuf_pos = pos;
4699 *hashbuf_len = len;
4700 }
4701
4702 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4703 {
4704 char *pos = NULL;
4705 int len = 0;
4706
4707 int sep_cnt = 0;
4708
4709 for (int i = 0; i < line_len; i++)
4710 {
4711 if (line_buf[i] == ':')
4712 {
4713 sep_cnt++;
4714
4715 continue;
4716 }
4717
4718 if (sep_cnt == 0)
4719 {
4720 if (pos == NULL) pos = line_buf + i;
4721
4722 len++;
4723 }
4724 }
4725
4726 *userbuf_pos = pos;
4727 *userbuf_len = len;
4728 }
4729
4730 // hlfmt passwd
4731
4732 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
4733 {
4734 int sep_cnt = 0;
4735
4736 char sep5_first = 0;
4737 char sep6_first = 0;
4738
4739 for (int i = 0; i < line_len; i++)
4740 {
4741 if (line_buf[i] == ':')
4742 {
4743 sep_cnt++;
4744
4745 continue;
4746 }
4747
4748 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
4749 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
4750 }
4751
4752 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
4753
4754 return 0;
4755 }
4756
4757 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4758 {
4759 char *pos = NULL;
4760 int len = 0;
4761
4762 int sep_cnt = 0;
4763
4764 for (int i = 0; i < line_len; i++)
4765 {
4766 if (line_buf[i] == ':')
4767 {
4768 sep_cnt++;
4769
4770 continue;
4771 }
4772
4773 if (sep_cnt == 1)
4774 {
4775 if (pos == NULL) pos = line_buf + i;
4776
4777 len++;
4778 }
4779 }
4780
4781 *hashbuf_pos = pos;
4782 *hashbuf_len = len;
4783 }
4784
4785 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4786 {
4787 char *pos = NULL;
4788 int len = 0;
4789
4790 int sep_cnt = 0;
4791
4792 for (int i = 0; i < line_len; i++)
4793 {
4794 if (line_buf[i] == ':')
4795 {
4796 sep_cnt++;
4797
4798 continue;
4799 }
4800
4801 if (sep_cnt == 0)
4802 {
4803 if (pos == NULL) pos = line_buf + i;
4804
4805 len++;
4806 }
4807 }
4808
4809 *userbuf_pos = pos;
4810 *userbuf_len = len;
4811 }
4812
4813 // hlfmt shadow
4814
4815 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
4816 {
4817 int sep_cnt = 0;
4818
4819 for (int i = 0; i < line_len; i++)
4820 {
4821 if (line_buf[i] == ':') sep_cnt++;
4822 }
4823
4824 if (sep_cnt == 8) return 1;
4825
4826 return 0;
4827 }
4828
4829 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4830 {
4831 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
4832 }
4833
4834 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4835 {
4836 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
4837 }
4838
4839 // hlfmt main
4840
4841 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4842 {
4843 switch (hashfile_format)
4844 {
4845 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4846 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4847 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4848 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4849 }
4850 }
4851
4852 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4853 {
4854 switch (hashfile_format)
4855 {
4856 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
4857 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
4858 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
4859 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
4860 }
4861 }
4862
4863 static uint hlfmt_detect (FILE *fp, uint max_check)
4864 {
4865 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
4866
4867 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
4868 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
4869
4870 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
4871
4872 uint num_check = 0;
4873
4874 while (!feof (fp))
4875 {
4876 char line_buf[BUFSIZ];
4877
4878 int line_len = fgetl (fp, line_buf);
4879
4880 if (line_len == 0) continue;
4881
4882 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
4883 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
4884 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
4885
4886 if (num_check == max_check) break;
4887
4888 num_check++;
4889 }
4890
4891 uint hashlist_format = HLFMT_HASHCAT;
4892
4893 for (int i = 1; i < HLFMTS_CNT; i++)
4894 {
4895 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
4896
4897 hashlist_format = i;
4898 }
4899
4900 free (formats_cnt);
4901
4902 return hashlist_format;
4903 }
4904
4905 /**
4906 * some further helper function
4907 */
4908
4909 // wrapper around mymalloc for ADL
4910
4911 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
4912 {
4913 return mymalloc (iSize);
4914 }
4915
4916 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)
4917 {
4918 uint64_t collisions = 0;
4919
4920 const uint dgst_pos0 = data.dgst_pos0;
4921 const uint dgst_pos1 = data.dgst_pos1;
4922 const uint dgst_pos2 = data.dgst_pos2;
4923 const uint dgst_pos3 = data.dgst_pos3;
4924
4925 memset (bitmap_a, 0, bitmap_size);
4926 memset (bitmap_b, 0, bitmap_size);
4927 memset (bitmap_c, 0, bitmap_size);
4928 memset (bitmap_d, 0, bitmap_size);
4929
4930 for (uint i = 0; i < digests_cnt; i++)
4931 {
4932 uint *digest_ptr = (uint *) digests_buf_ptr;
4933
4934 digests_buf_ptr += dgst_size;
4935
4936 const uint val0 = 1 << (digest_ptr[dgst_pos0] & 0x1f);
4937 const uint val1 = 1 << (digest_ptr[dgst_pos1] & 0x1f);
4938 const uint val2 = 1 << (digest_ptr[dgst_pos2] & 0x1f);
4939 const uint val3 = 1 << (digest_ptr[dgst_pos3] & 0x1f);
4940
4941 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
4942 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
4943 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
4944 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
4945
4946 if (bitmap_a[idx0] & val0) collisions++;
4947 if (bitmap_b[idx1] & val1) collisions++;
4948 if (bitmap_c[idx2] & val2) collisions++;
4949 if (bitmap_d[idx3] & val3) collisions++;
4950
4951 bitmap_a[idx0] |= val0;
4952 bitmap_b[idx1] |= val1;
4953 bitmap_c[idx2] |= val2;
4954 bitmap_d[idx3] |= val3;
4955
4956 if (collisions >= collisions_max) return 0x7fffffff;
4957 }
4958
4959 return collisions;
4960 }
4961
4962 /**
4963 * main
4964 */
4965
4966 int main (int argc, char **argv)
4967 {
4968 /**
4969 * To help users a bit
4970 */
4971
4972 char *compute = getenv ("COMPUTE");
4973
4974 if (compute)
4975 {
4976 char display[100];
4977
4978 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
4979
4980 putenv (display);
4981 }
4982 else
4983 {
4984 if (getenv ("DISPLAY") == NULL)
4985 putenv ((char *) "DISPLAY=:0");
4986 }
4987
4988 /*
4989 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
4990 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
4991
4992 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
4993 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
4994 */
4995
4996 /**
4997 * Real init
4998 */
4999
5000 memset (&data, 0, sizeof (hc_global_data_t));
5001
5002 time_t proc_start;
5003
5004 time (&proc_start);
5005
5006 data.proc_start = proc_start;
5007
5008 int myargc = argc;
5009 char **myargv = argv;
5010
5011 hc_thread_mutex_init (mux_dispatcher);
5012 hc_thread_mutex_init (mux_counter);
5013 hc_thread_mutex_init (mux_display);
5014 hc_thread_mutex_init (mux_adl);
5015
5016 /**
5017 * commandline parameters
5018 */
5019
5020 uint usage = USAGE;
5021 uint version = VERSION;
5022 uint quiet = QUIET;
5023 uint benchmark = BENCHMARK;
5024 uint benchmark_mode = BENCHMARK_MODE;
5025 uint show = SHOW;
5026 uint left = LEFT;
5027 uint username = USERNAME;
5028 uint remove = REMOVE;
5029 uint remove_timer = REMOVE_TIMER;
5030 uint64_t skip = SKIP;
5031 uint64_t limit = LIMIT;
5032 uint keyspace = KEYSPACE;
5033 uint potfile_disable = POTFILE_DISABLE;
5034 uint debug_mode = DEBUG_MODE;
5035 char *debug_file = NULL;
5036 char *induction_dir = NULL;
5037 char *outfile_check_dir = NULL;
5038 uint force = FORCE;
5039 uint runtime = RUNTIME;
5040 uint hash_mode = HASH_MODE;
5041 uint attack_mode = ATTACK_MODE;
5042 uint markov_disable = MARKOV_DISABLE;
5043 uint markov_classic = MARKOV_CLASSIC;
5044 uint markov_threshold = MARKOV_THRESHOLD;
5045 char *markov_hcstat = NULL;
5046 char *outfile = NULL;
5047 uint outfile_format = OUTFILE_FORMAT;
5048 uint outfile_autohex = OUTFILE_AUTOHEX;
5049 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5050 uint restore = RESTORE;
5051 uint restore_timer = RESTORE_TIMER;
5052 uint restore_disable = RESTORE_DISABLE;
5053 uint status = STATUS;
5054 uint status_timer = STATUS_TIMER;
5055 uint status_automat = STATUS_AUTOMAT;
5056 uint loopback = LOOPBACK;
5057 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5058 char *session = NULL;
5059 uint hex_charset = HEX_CHARSET;
5060 uint hex_salt = HEX_SALT;
5061 uint hex_wordlist = HEX_WORDLIST;
5062 uint rp_gen = RP_GEN;
5063 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5064 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5065 uint rp_gen_seed = RP_GEN_SEED;
5066 char *rule_buf_l = (char *) RULE_BUF_L;
5067 char *rule_buf_r = (char *) RULE_BUF_R;
5068 uint increment = INCREMENT;
5069 uint increment_min = INCREMENT_MIN;
5070 uint increment_max = INCREMENT_MAX;
5071 char *cpu_affinity = NULL;
5072 char *gpu_devices = NULL;
5073 char *truecrypt_keyfiles = NULL;
5074 uint workload_profile = WORKLOAD_PROFILE;
5075 uint gpu_accel = GPU_ACCEL;
5076 uint gpu_loops = GPU_LOOPS;
5077 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5078 uint gpu_temp_abort = GPU_TEMP_ABORT;
5079 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5080 uint powertune_enable = POWERTUNE_ENABLE;
5081 uint logfile_disable = LOGFILE_DISABLE;
5082 uint segment_size = SEGMENT_SIZE;
5083 uint scrypt_tmto = SCRYPT_TMTO;
5084 char separator = SEPARATOR;
5085 uint bitmap_min = BITMAP_MIN;
5086 uint bitmap_max = BITMAP_MAX;
5087 char *custom_charset_1 = NULL;
5088 char *custom_charset_2 = NULL;
5089 char *custom_charset_3 = NULL;
5090 char *custom_charset_4 = NULL;
5091
5092 #define IDX_HELP 'h'
5093 #define IDX_VERSION 'V'
5094 #define IDX_VERSION_LOWER 'v'
5095 #define IDX_QUIET 0xff02
5096 #define IDX_SHOW 0xff03
5097 #define IDX_LEFT 0xff04
5098 #define IDX_REMOVE 0xff05
5099 #define IDX_REMOVE_TIMER 0xff37
5100 #define IDX_SKIP 's'
5101 #define IDX_LIMIT 'l'
5102 #define IDX_KEYSPACE 0xff35
5103 #define IDX_POTFILE_DISABLE 0xff06
5104 #define IDX_DEBUG_MODE 0xff43
5105 #define IDX_DEBUG_FILE 0xff44
5106 #define IDX_INDUCTION_DIR 0xff46
5107 #define IDX_OUTFILE_CHECK_DIR 0xff47
5108 #define IDX_USERNAME 0xff07
5109 #define IDX_FORCE 0xff08
5110 #define IDX_RUNTIME 0xff09
5111 #define IDX_BENCHMARK 'b'
5112 #define IDX_BENCHMARK_MODE 0xff32
5113 #define IDX_HASH_MODE 'm'
5114 #define IDX_ATTACK_MODE 'a'
5115 #define IDX_RP_FILE 'r'
5116 #define IDX_RP_GEN 'g'
5117 #define IDX_RP_GEN_FUNC_MIN 0xff10
5118 #define IDX_RP_GEN_FUNC_MAX 0xff11
5119 #define IDX_RP_GEN_SEED 0xff34
5120 #define IDX_RULE_BUF_L 'j'
5121 #define IDX_RULE_BUF_R 'k'
5122 #define IDX_INCREMENT 'i'
5123 #define IDX_INCREMENT_MIN 0xff12
5124 #define IDX_INCREMENT_MAX 0xff13
5125 #define IDX_OUTFILE 'o'
5126 #define IDX_OUTFILE_FORMAT 0xff14
5127 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5128 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5129 #define IDX_RESTORE 0xff15
5130 #define IDX_RESTORE_DISABLE 0xff27
5131 #define IDX_STATUS 0xff17
5132 #define IDX_STATUS_TIMER 0xff18
5133 #define IDX_STATUS_AUTOMAT 0xff50
5134 #define IDX_LOOPBACK 0xff38
5135 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5136 #define IDX_SESSION 0xff19
5137 #define IDX_HEX_CHARSET 0xff20
5138 #define IDX_HEX_SALT 0xff21
5139 #define IDX_HEX_WORDLIST 0xff40
5140 #define IDX_MARKOV_DISABLE 0xff22
5141 #define IDX_MARKOV_CLASSIC 0xff23
5142 #define IDX_MARKOV_THRESHOLD 't'
5143 #define IDX_MARKOV_HCSTAT 0xff24
5144 #define IDX_CPU_AFFINITY 0xff25
5145 #define IDX_GPU_DEVICES 'd'
5146 #define IDX_WORKLOAD_PROFILE 'w'
5147 #define IDX_GPU_ACCEL 'n'
5148 #define IDX_GPU_LOOPS 'u'
5149 #define IDX_GPU_TEMP_DISABLE 0xff29
5150 #define IDX_GPU_TEMP_ABORT 0xff30
5151 #define IDX_GPU_TEMP_RETAIN 0xff31
5152 #define IDX_POWERTUNE_ENABLE 0xff41
5153 #define IDX_LOGFILE_DISABLE 0xff51
5154 #define IDX_TRUECRYPT_KEYFILES 0xff52
5155 #define IDX_SCRYPT_TMTO 0xff61
5156 #define IDX_SEGMENT_SIZE 'c'
5157 #define IDX_SEPARATOR 'p'
5158 #define IDX_BITMAP_MIN 0xff70
5159 #define IDX_BITMAP_MAX 0xff71
5160 #define IDX_CUSTOM_CHARSET_1 '1'
5161 #define IDX_CUSTOM_CHARSET_2 '2'
5162 #define IDX_CUSTOM_CHARSET_3 '3'
5163 #define IDX_CUSTOM_CHARSET_4 '4'
5164
5165 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5166
5167 struct option long_options[] =
5168 {
5169 {"help", no_argument, 0, IDX_HELP},
5170 {"version", no_argument, 0, IDX_VERSION},
5171 {"quiet", no_argument, 0, IDX_QUIET},
5172 {"show", no_argument, 0, IDX_SHOW},
5173 {"left", no_argument, 0, IDX_LEFT},
5174 {"username", no_argument, 0, IDX_USERNAME},
5175 {"remove", no_argument, 0, IDX_REMOVE},
5176 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5177 {"skip", required_argument, 0, IDX_SKIP},
5178 {"limit", required_argument, 0, IDX_LIMIT},
5179 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5180 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5181 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5182 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5183 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5184 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5185 {"force", no_argument, 0, IDX_FORCE},
5186 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5187 {"benchmark-mode", required_argument, 0, IDX_BENCHMARK_MODE},
5188 {"restore", no_argument, 0, IDX_RESTORE},
5189 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5190 {"status", no_argument, 0, IDX_STATUS},
5191 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5192 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5193 {"loopback", no_argument, 0, IDX_LOOPBACK},
5194 {"weak-hash-threshold",
5195 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5196 {"session", required_argument, 0, IDX_SESSION},
5197 {"runtime", required_argument, 0, IDX_RUNTIME},
5198 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5199 {"generate-rules-func-min",
5200 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5201 {"generate-rules-func-max",
5202 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5203 {"generate-rules-seed",
5204 required_argument, 0, IDX_RP_GEN_SEED},
5205 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5206 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5207 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5208 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5209 {"rules-file", required_argument, 0, IDX_RP_FILE},
5210 {"outfile", required_argument, 0, IDX_OUTFILE},
5211 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5212 {"outfile-autohex-disable",
5213 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5214 {"outfile-check-timer",
5215 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5216 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5217 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5218 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5219 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5220 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5221 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5222 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5223 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5224 {"gpu-devices", required_argument, 0, IDX_GPU_DEVICES},
5225 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5226 {"gpu-accel", required_argument, 0, IDX_GPU_ACCEL},
5227 {"gpu-loops", required_argument, 0, IDX_GPU_LOOPS},
5228 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5229 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5230 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5231 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5232 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5233 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5234 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5235 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5236 // deprecated
5237 {"seperator", required_argument, 0, IDX_SEPARATOR},
5238 {"separator", required_argument, 0, IDX_SEPARATOR},
5239 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5240 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5241 {"increment", no_argument, 0, IDX_INCREMENT},
5242 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5243 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5244 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5245 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5246 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5247 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5248
5249 {0, 0, 0, 0}
5250 };
5251
5252 uint rp_files_cnt = 0;
5253
5254 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5255
5256 int option_index;
5257 int c;
5258
5259 optind = 1;
5260 optopt = 0;
5261 option_index = 0;
5262
5263 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5264 {
5265 switch (c)
5266 {
5267 case IDX_HELP: usage = 1; break;
5268 case IDX_VERSION:
5269 case IDX_VERSION_LOWER: version = 1; break;
5270 case IDX_RESTORE: restore = 1; break;
5271 case IDX_SESSION: session = optarg; break;
5272 case IDX_SHOW: show = 1; break;
5273 case IDX_LEFT: left = 1; break;
5274 case '?': return (-1);
5275 }
5276 }
5277
5278 if (optopt != 0)
5279 {
5280 log_error ("ERROR: Invalid argument specified");
5281
5282 return (-1);
5283 }
5284
5285 /**
5286 * exit functions
5287 */
5288
5289 if (version)
5290 {
5291 log_info (VERSION_TXT);
5292
5293 return (0);
5294 }
5295
5296 if (usage)
5297 {
5298 usage_big_print (PROGNAME);
5299
5300 return (0);
5301 }
5302
5303 /**
5304 * session
5305 */
5306
5307 if (session == NULL) session = (char *) PROGNAME;
5308
5309 size_t session_size = strlen (session) + 32;
5310
5311 data.session = session;
5312
5313 char *eff_restore_file = (char *) mymalloc (session_size);
5314 char *new_restore_file = (char *) mymalloc (session_size);
5315
5316 snprintf (eff_restore_file, session_size - 1, "%s.restore", session);
5317 snprintf (new_restore_file, session_size - 1, "%s.restore.new", session);
5318
5319 data.eff_restore_file = eff_restore_file;
5320 data.new_restore_file = new_restore_file;
5321
5322 if (((show == 1) || (left == 1)) && (restore == 1))
5323 {
5324 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5325 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5326
5327 return (-1);
5328 }
5329
5330 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5331 if ((show == 1) || (left == 1))
5332 {
5333 restore_disable = 1;
5334
5335 restore = 0;
5336 }
5337
5338 data.restore_disable = restore_disable;
5339
5340 restore_data_t *rd = init_restore (argc, argv);
5341
5342 data.rd = rd;
5343
5344 /**
5345 * restore file
5346 */
5347
5348 if (restore == 1)
5349 {
5350 read_restore (eff_restore_file, rd);
5351
5352 if (rd->version_bin < RESTORE_MIN)
5353 {
5354 log_error ("ERROR: Incompatible restore-file version");
5355
5356 return (-1);
5357 }
5358
5359 myargc = rd->argc;
5360 myargv = rd->argv;
5361
5362 #ifdef _POSIX
5363 rd->pid = getpid ();
5364 #elif _WIN
5365 rd->pid = GetCurrentProcessId ();
5366 #endif
5367 }
5368
5369 uint hash_mode_chgd = 0;
5370 uint runtime_chgd = 0;
5371 uint gpu_loops_chgd = 0;
5372 uint gpu_accel_chgd = 0;
5373 uint attack_mode_chgd = 0;
5374 uint outfile_format_chgd = 0;
5375 uint rp_gen_seed_chgd = 0;
5376 uint remove_timer_chgd = 0;
5377 uint increment_min_chgd = 0;
5378 uint increment_max_chgd = 0;
5379 uint gpu_temp_abort_chgd = 0;
5380 uint gpu_temp_retain_chgd = 0;
5381
5382 optind = 1;
5383 optopt = 0;
5384 option_index = 0;
5385
5386 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5387 {
5388 switch (c)
5389 {
5390 //case IDX_HELP: usage = 1; break;
5391 //case IDX_VERSION: version = 1; break;
5392 //case IDX_RESTORE: restore = 1; break;
5393 case IDX_QUIET: quiet = 1; break;
5394 //case IDX_SHOW: show = 1; break;
5395 case IDX_SHOW: break;
5396 //case IDX_LEFT: left = 1; break;
5397 case IDX_LEFT: break;
5398 case IDX_USERNAME: username = 1; break;
5399 case IDX_REMOVE: remove = 1; break;
5400 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5401 remove_timer_chgd = 1; break;
5402 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5403 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5404 case IDX_DEBUG_FILE: debug_file = optarg; break;
5405 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5406 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5407 case IDX_FORCE: force = 1; break;
5408 case IDX_SKIP: skip = atoll (optarg); break;
5409 case IDX_LIMIT: limit = atoll (optarg); break;
5410 case IDX_KEYSPACE: keyspace = 1; break;
5411 case IDX_BENCHMARK: benchmark = 1; break;
5412 case IDX_BENCHMARK_MODE: benchmark_mode = atoi (optarg); break;
5413 case IDX_RESTORE: break;
5414 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5415 case IDX_STATUS: status = 1; break;
5416 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5417 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5418 case IDX_LOOPBACK: loopback = 1; break;
5419 case IDX_WEAK_HASH_THRESHOLD:
5420 weak_hash_threshold = atoi (optarg); break;
5421 //case IDX_SESSION: session = optarg; break;
5422 case IDX_SESSION: break;
5423 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5424 hash_mode_chgd = 1; break;
5425 case IDX_RUNTIME: runtime = atoi (optarg);
5426 runtime_chgd = 1; break;
5427 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5428 attack_mode_chgd = 1; break;
5429 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5430 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5431 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5432 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5433 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5434 rp_gen_seed_chgd = 1; break;
5435 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5436 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5437 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5438 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5439 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5440 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5441 case IDX_OUTFILE: outfile = optarg; break;
5442 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5443 outfile_format_chgd = 1; break;
5444 case IDX_OUTFILE_AUTOHEX_DISABLE:
5445 outfile_autohex = 0; break;
5446 case IDX_OUTFILE_CHECK_TIMER:
5447 outfile_check_timer = atoi (optarg); break;
5448 case IDX_HEX_CHARSET: hex_charset = 1; break;
5449 case IDX_HEX_SALT: hex_salt = 1; break;
5450 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5451 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5452 case IDX_GPU_DEVICES: gpu_devices = optarg; break;
5453 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg); break;
5454 case IDX_GPU_ACCEL: gpu_accel = atoi (optarg);
5455 gpu_accel_chgd = 1; break;
5456 case IDX_GPU_LOOPS: gpu_loops = atoi (optarg);
5457 gpu_loops_chgd = 1; break;
5458 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5459 case IDX_GPU_TEMP_ABORT: gpu_temp_abort_chgd = 1;
5460 gpu_temp_abort = atoi (optarg); break;
5461 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain_chgd = 1;
5462 gpu_temp_retain = atoi (optarg); break;
5463 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5464 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5465 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5466 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5467 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5468 case IDX_SEPARATOR: separator = optarg[0]; break;
5469 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5470 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5471 case IDX_INCREMENT: increment = 1; break;
5472 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5473 increment_min_chgd = 1; break;
5474 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5475 increment_max_chgd = 1; break;
5476 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5477 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5478 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5479 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5480
5481 default:
5482 log_error ("ERROR: Invalid argument specified");
5483 return (-1);
5484 }
5485 }
5486
5487 if (optopt != 0)
5488 {
5489 log_error ("ERROR: Invalid argument specified");
5490
5491 return (-1);
5492 }
5493
5494 /**
5495 * Inform user things getting started,
5496 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5497 * - we do not need to check algorithm_pos
5498 */
5499
5500 if (quiet == 0)
5501 {
5502 if (benchmark == 1)
5503 {
5504 log_info ("%s v%.2f starting in benchmark-mode...", PROGNAME, (float) VERSION_BIN / 100);
5505
5506 log_info ("");
5507 }
5508 else if (restore == 1)
5509 {
5510 log_info ("%s v%.2f starting in restore-mode...", PROGNAME, (float) VERSION_BIN / 100);
5511
5512 log_info ("");
5513 }
5514 else
5515 {
5516 log_info ("%s v%.2f starting...", PROGNAME, (float) VERSION_BIN / 100);
5517
5518 log_info ("");
5519 }
5520 }
5521
5522 /**
5523 * sanity check
5524 */
5525
5526 if (attack_mode > 7)
5527 {
5528 log_error ("ERROR: Invalid attack-mode specified");
5529
5530 return (-1);
5531 }
5532
5533 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5534 {
5535 log_error ("ERROR: Invalid runtime specified");
5536
5537 return (-1);
5538 }
5539
5540 if (hash_mode_chgd && hash_mode > 12800) // just added to remove compiler warnings for hash_mode_chgd
5541 {
5542 log_error ("ERROR: Invalid hash-type specified");
5543
5544 return (-1);
5545 }
5546
5547 // renamed hash modes
5548
5549 if (hash_mode_chgd)
5550 {
5551 int n = -1;
5552
5553 switch (hash_mode)
5554 {
5555 case 123: n = 124;
5556 break;
5557 }
5558
5559 if (n >= 0)
5560 {
5561 log_error ("Old -m specified, use -m %d instead", n);
5562
5563 return (-1);
5564 }
5565 }
5566
5567 if (username == 1)
5568 {
5569 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5570 {
5571 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5572
5573 return (-1);
5574 }
5575 }
5576
5577 if (outfile_format > 16)
5578 {
5579 log_error ("ERROR: Invalid outfile-format specified");
5580
5581 return (-1);
5582 }
5583
5584 if (left == 1)
5585 {
5586 if (outfile_format_chgd == 1)
5587 {
5588 if (outfile_format > 1)
5589 {
5590 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5591
5592 return (-1);
5593 }
5594 }
5595 else
5596 {
5597 outfile_format = OUTFILE_FMT_HASH;
5598 }
5599 }
5600
5601 if (show == 1)
5602 {
5603 if (outfile_format_chgd == 1)
5604 {
5605 if ((outfile_format > 7) && (outfile_format < 16))
5606 {
5607 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
5608
5609 return (-1);
5610 }
5611 }
5612 }
5613
5614 if (increment_min < INCREMENT_MIN)
5615 {
5616 log_error ("ERROR: Invalid increment-min specified");
5617
5618 return (-1);
5619 }
5620
5621 if (increment_max > INCREMENT_MAX)
5622 {
5623 log_error ("ERROR: Invalid increment-max specified");
5624
5625 return (-1);
5626 }
5627
5628 if (increment_min > increment_max)
5629 {
5630 log_error ("ERROR: Invalid increment-min specified");
5631
5632 return (-1);
5633 }
5634
5635 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
5636 {
5637 log_error ("ERROR: increment is not allowed in attack-mode 0");
5638
5639 return (-1);
5640 }
5641
5642 if ((increment == 0) && (increment_min_chgd == 1))
5643 {
5644 log_error ("ERROR: increment-min is only supported together with increment switch");
5645
5646 return (-1);
5647 }
5648
5649 if ((increment == 0) && (increment_max_chgd == 1))
5650 {
5651 log_error ("ERROR: increment-max is only supported together with increment switch");
5652
5653 return (-1);
5654 }
5655
5656 if (rp_files_cnt && rp_gen)
5657 {
5658 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
5659
5660 return (-1);
5661 }
5662
5663 if (rp_files_cnt || rp_gen)
5664 {
5665 if (attack_mode != ATTACK_MODE_STRAIGHT)
5666 {
5667 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
5668
5669 return (-1);
5670 }
5671 }
5672
5673 if (rp_gen_func_min > rp_gen_func_max)
5674 {
5675 log_error ("ERROR: Invalid rp-gen-func-min specified");
5676
5677 return (-1);
5678 }
5679
5680 if (gpu_accel_chgd == 1)
5681 {
5682 if (workload_profile != WORKLOAD_PROFILE)
5683 {
5684 log_error ("ERROR: gpu-accel parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5685
5686 return (-1);
5687 }
5688
5689 if (gpu_accel < 1)
5690 {
5691 log_error ("ERROR: Invalid gpu-accel specified");
5692
5693 return (-1);
5694 }
5695
5696 if (gpu_accel > 800)
5697 {
5698 log_error ("ERROR: Invalid gpu-accel specified");
5699
5700 return (-1);
5701 }
5702 }
5703
5704 if (gpu_loops_chgd == 1)
5705 {
5706 if (workload_profile != WORKLOAD_PROFILE)
5707 {
5708 log_error ("ERROR: gpu-loops parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5709
5710 return (-1);
5711 }
5712
5713 if (gpu_loops < 1)
5714 {
5715 log_error ("ERROR: Invalid gpu-loops specified");
5716
5717 return (-1);
5718 }
5719
5720 if (gpu_loops > 1024)
5721 {
5722 log_error ("ERROR: Invalid gpu-loops specified");
5723
5724 return (-1);
5725 }
5726 }
5727
5728 if (benchmark == 1)
5729 {
5730 if (workload_profile != WORKLOAD_PROFILE)
5731 {
5732 log_error ("ERROR: Using the workload-profile in benchmark mode is not allowed");
5733
5734 return (-1);
5735 }
5736 }
5737
5738 if ((workload_profile < 1) || (workload_profile > 3))
5739 {
5740 log_error ("ERROR: workload-profile %i not available", workload_profile);
5741
5742 return (-1);
5743 }
5744
5745 if (show == 1 || left == 1)
5746 {
5747 attack_mode = ATTACK_MODE_NONE;
5748
5749 if (remove == 1)
5750 {
5751 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
5752
5753 return (-1);
5754 }
5755
5756 if (potfile_disable == 1)
5757 {
5758 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
5759
5760 return (-1);
5761 }
5762 }
5763
5764 uint attack_kern = ATTACK_KERN_NONE;
5765
5766 switch (attack_mode)
5767 {
5768 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
5769 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
5770 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
5771 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
5772 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
5773 }
5774
5775 if (benchmark == 0)
5776 {
5777 if (keyspace == 1)
5778 {
5779 int num_additional_params = 1;
5780
5781 if (attack_kern == ATTACK_KERN_COMBI)
5782 {
5783 num_additional_params = 2;
5784 }
5785
5786 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
5787
5788 if (keyspace_wordlist_specified == 0) optind--;
5789 }
5790
5791 if (attack_kern == ATTACK_KERN_NONE)
5792 {
5793 if ((optind + 1) != myargc)
5794 {
5795 usage_mini_print (myargv[0]);
5796
5797 return (-1);
5798 }
5799 }
5800 else if (attack_kern == ATTACK_KERN_STRAIGHT)
5801 {
5802 if ((optind + 1) > myargc)
5803 {
5804 usage_mini_print (myargv[0]);
5805
5806 return (-1);
5807 }
5808 }
5809 else if (attack_kern == ATTACK_KERN_COMBI)
5810 {
5811 if ((optind + 3) != myargc)
5812 {
5813 usage_mini_print (myargv[0]);
5814
5815 return (-1);
5816 }
5817 }
5818 else if (attack_kern == ATTACK_KERN_BF)
5819 {
5820 if ((optind + 1) > myargc)
5821 {
5822 usage_mini_print (myargv[0]);
5823
5824 return (-1);
5825 }
5826 }
5827 else
5828 {
5829 usage_mini_print (myargv[0]);
5830
5831 return (-1);
5832 }
5833 }
5834 else
5835 {
5836 if (myargv[optind] != 0)
5837 {
5838 log_error ("ERROR: Invalid argument for benchmark mode specified");
5839
5840 return (-1);
5841 }
5842
5843 if (attack_mode_chgd == 1)
5844 {
5845 if (attack_mode != ATTACK_MODE_BF)
5846 {
5847 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
5848
5849 return (-1);
5850 }
5851 }
5852
5853 if (benchmark_mode == 0)
5854 {
5855 // nothing to do
5856 }
5857 else if (benchmark_mode == 1)
5858 {
5859 if (gpu_accel_chgd == 1 || gpu_loops_chgd == 1)
5860 {
5861 log_error ("ERROR: Benchmark-mode 1 does not allow gpu-accel or gpu-loops changed");
5862
5863 return (-1);
5864 }
5865 }
5866 else
5867 {
5868 log_error ("ERROR: Benchmark-mode must be 0 or 1");
5869
5870 return (-1);
5871 }
5872 }
5873
5874 if (skip != 0 && limit != 0)
5875 {
5876 limit += skip;
5877 }
5878
5879 if (keyspace == 1)
5880 {
5881 if (show == 1)
5882 {
5883 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
5884
5885 return (-1);
5886 }
5887 else if (left == 1)
5888 {
5889 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
5890
5891 return (-1);
5892 }
5893
5894 potfile_disable = 1;
5895
5896 restore_disable = 1;
5897
5898 restore = 0;
5899
5900 weak_hash_threshold = 0;
5901
5902 quiet = 1;
5903 }
5904
5905 if (remove_timer_chgd == 1)
5906 {
5907 if (remove == 0)
5908 {
5909 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
5910
5911 return (-1);
5912 }
5913
5914 if (remove_timer < 1)
5915 {
5916 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
5917
5918 return (-1);
5919 }
5920 }
5921
5922 if (loopback == 1)
5923 {
5924 if (attack_mode == ATTACK_MODE_BF)
5925 {
5926 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
5927
5928 return (-1);
5929 }
5930 else if (attack_mode == ATTACK_MODE_STRAIGHT)
5931 {
5932 if ((rp_files_cnt == 0) && (rp_gen == 0))
5933 {
5934 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
5935
5936 return (-1);
5937 }
5938 }
5939 }
5940
5941 if (debug_mode > 0)
5942 {
5943 if (attack_mode != ATTACK_MODE_STRAIGHT)
5944 {
5945 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
5946
5947 return (-1);
5948 }
5949
5950 if ((rp_files_cnt == 0) && (rp_gen == 0))
5951 {
5952 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
5953
5954 return (-1);
5955 }
5956 }
5957
5958 if (debug_mode > 4)
5959 {
5960 log_error ("ERROR: Invalid debug-mode specified");
5961
5962 return (-1);
5963 }
5964
5965 if (debug_file != NULL)
5966 {
5967 if (debug_mode < 1)
5968 {
5969 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
5970
5971 return (-1);
5972 }
5973 }
5974
5975 if (induction_dir != NULL)
5976 {
5977 if (attack_mode == ATTACK_MODE_BF)
5978 {
5979 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
5980
5981 return (-1);
5982 }
5983 }
5984
5985 /**
5986 * induction directory
5987 */
5988
5989 char *induction_directory = NULL;
5990
5991 if (attack_mode != ATTACK_MODE_BF)
5992 {
5993 if (induction_dir == NULL)
5994 {
5995 induction_directory = (char *) mymalloc (session_size);
5996
5997 snprintf (induction_directory, session_size - 1, "%s.%s", session, INDUCT_DIR);
5998
5999 // create induction folder if it does not already exist
6000
6001 if (keyspace == 0)
6002 {
6003 if (rmdir (induction_directory) == -1)
6004 {
6005 if (errno == ENOENT)
6006 {
6007 // good, we can ignore
6008 }
6009 else if (errno == ENOTEMPTY)
6010 {
6011 char *induction_directory_mv = (char *) mymalloc (session_size);
6012
6013 snprintf (induction_directory_mv, session_size - 1, "%s.induct.%d", session, (int) proc_start);
6014
6015 if (rename (induction_directory, induction_directory_mv) != 0)
6016 {
6017 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6018
6019 return (-1);
6020 }
6021 }
6022 else
6023 {
6024 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6025
6026 return (-1);
6027 }
6028 }
6029
6030 #ifdef _WIN
6031 #define mkdir(name,mode) mkdir (name)
6032 #endif
6033
6034 if (mkdir (induction_directory, 0700) == -1)
6035 {
6036 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6037
6038 return (-1);
6039 }
6040 }
6041 }
6042 else
6043 {
6044 induction_directory = induction_dir;
6045 }
6046 }
6047
6048 data.induction_directory = induction_directory;
6049
6050 /**
6051 * loopback
6052 */
6053
6054 size_t loopback_size = session_size + strlen (LOOPBACK_FILE) + 12;
6055
6056 char *loopback_file = (char *) mymalloc (loopback_size);
6057
6058 /**
6059 * outfile-check directory
6060 */
6061
6062 char *outfile_check_directory = NULL;
6063
6064 if (outfile_check_dir == NULL)
6065 {
6066 outfile_check_directory = (char *) mymalloc (session_size);
6067
6068 snprintf (outfile_check_directory, session_size - 1, "%s.%s", session, OUTFILES_DIR);
6069 }
6070 else
6071 {
6072 outfile_check_directory = outfile_check_dir;
6073 }
6074
6075 data.outfile_check_directory = outfile_check_directory;
6076
6077 if (keyspace == 0)
6078 {
6079 struct stat outfile_check_stat;
6080
6081 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6082 {
6083 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6084
6085 if (is_dir == 0)
6086 {
6087 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6088
6089 return (-1);
6090 }
6091 }
6092 else if (outfile_check_dir == NULL)
6093 {
6094 #ifdef _WIN
6095 #define mkdir(name,mode) mkdir (name)
6096 #endif
6097
6098 if (mkdir (outfile_check_directory, 0700) == -1)
6099 {
6100 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6101
6102 return (-1);
6103 }
6104 }
6105 }
6106
6107 /**
6108 * special other stuff
6109 */
6110
6111 if (hash_mode == 9710)
6112 {
6113 outfile_format = 5;
6114 outfile_format_chgd = 1;
6115 }
6116
6117 if (hash_mode == 9810)
6118 {
6119 outfile_format = 5;
6120 outfile_format_chgd = 1;
6121 }
6122
6123 if (hash_mode == 10410)
6124 {
6125 outfile_format = 5;
6126 outfile_format_chgd = 1;
6127 }
6128
6129 /**
6130 * store stuff
6131 */
6132
6133 data.hash_mode = hash_mode;
6134 data.restore = restore;
6135 data.restore_timer = restore_timer;
6136 data.restore_disable = restore_disable;
6137 data.status = status;
6138 data.status_timer = status_timer;
6139 data.status_automat = status_automat;
6140 data.loopback = loopback;
6141 data.runtime = runtime;
6142 data.remove = remove;
6143 data.remove_timer = remove_timer;
6144 data.debug_mode = debug_mode;
6145 data.debug_file = debug_file;
6146 data.username = username;
6147 data.quiet = quiet;
6148 data.outfile = outfile;
6149 data.outfile_format = outfile_format;
6150 data.outfile_autohex = outfile_autohex;
6151 data.hex_charset = hex_charset;
6152 data.hex_salt = hex_salt;
6153 data.hex_wordlist = hex_wordlist;
6154 data.separator = separator;
6155 data.rp_files = rp_files;
6156 data.rp_files_cnt = rp_files_cnt;
6157 data.rp_gen = rp_gen;
6158 data.rp_gen_seed = rp_gen_seed;
6159 data.force = force;
6160 data.benchmark = benchmark;
6161 data.skip = skip;
6162 data.limit = limit;
6163 data.powertune_enable = powertune_enable;
6164 data.logfile_disable = logfile_disable;
6165 data.truecrypt_keyfiles = truecrypt_keyfiles;
6166 data.scrypt_tmto = scrypt_tmto;
6167
6168 /**
6169 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
6170 */
6171
6172 #ifdef LINUX
6173
6174 char *resolved_path = realpath (myargv[0], NULL);
6175
6176 char *install_dir = get_install_dir (resolved_path);
6177 char *profile_dir = NULL;
6178 char *session_dir = NULL;
6179
6180 if (strcmp (install_dir, INSTALL_FOLDER) == 0)
6181 {
6182 struct passwd *pw = getpwuid (getuid ());
6183
6184 const char *homedir = pw->pw_dir;
6185
6186 profile_dir = get_profile_dir (homedir);
6187 session_dir = get_session_dir (profile_dir, session);
6188 }
6189 else
6190 {
6191 profile_dir = install_dir;
6192 session_dir = install_dir;
6193 }
6194
6195 myfree (resolved_path);
6196
6197 #else
6198
6199 char *install_dir = get_install_dir (myargv[0]);
6200 char *profile_dir = install_dir;
6201 char *session_dir = install_dir;
6202
6203 #endif
6204
6205 data.install_dir = install_dir;
6206 data.profile_dir = profile_dir;
6207 data.session_dir = session_dir;
6208
6209 /**
6210 * cpu affinity
6211 */
6212
6213 if (cpu_affinity)
6214 {
6215 set_cpu_affinity (cpu_affinity);
6216 }
6217
6218 if (rp_gen_seed_chgd == 0)
6219 {
6220 srand (proc_start);
6221 }
6222 else
6223 {
6224 srand (rp_gen_seed);
6225 }
6226
6227 /**
6228 * logfile init
6229 */
6230
6231 if (logfile_disable == 0)
6232 {
6233 size_t logfile_size = strlen (session) + 32;
6234
6235 char *logfile = (char *) mymalloc (logfile_size);
6236
6237 snprintf (logfile, logfile_size - 1, "%s.log", session);
6238
6239 data.logfile = logfile;
6240
6241 char *topid = logfile_generate_topid ();
6242
6243 data.topid = topid;
6244 }
6245
6246 // logfile_append() checks for logfile_disable internally to make it easier from here
6247
6248 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6249 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6250 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6251 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6252 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6253 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6254 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6255 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6256 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6257 #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));
6258
6259 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6260 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6261 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6262 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6263 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6264 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6265 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6266 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6267
6268 logfile_top_msg ("START");
6269
6270 logfile_top_uint (attack_mode);
6271 logfile_top_uint (attack_kern);
6272 logfile_top_uint (benchmark);
6273 logfile_top_uint (benchmark_mode);
6274 logfile_top_uint (bitmap_min);
6275 logfile_top_uint (bitmap_max);
6276 logfile_top_uint (debug_mode);
6277 logfile_top_uint (force);
6278 logfile_top_uint (gpu_accel);
6279 logfile_top_uint (gpu_loops);
6280 logfile_top_uint (gpu_temp_abort);
6281 logfile_top_uint (gpu_temp_disable);
6282 logfile_top_uint (gpu_temp_retain);
6283 logfile_top_uint (hash_mode);
6284 logfile_top_uint (hex_charset);
6285 logfile_top_uint (hex_salt);
6286 logfile_top_uint (hex_wordlist);
6287 logfile_top_uint (increment);
6288 logfile_top_uint (increment_max);
6289 logfile_top_uint (increment_min);
6290 logfile_top_uint (keyspace);
6291 logfile_top_uint (left);
6292 logfile_top_uint (logfile_disable);
6293 logfile_top_uint (loopback);
6294 logfile_top_uint (markov_classic);
6295 logfile_top_uint (markov_disable);
6296 logfile_top_uint (markov_threshold);
6297 logfile_top_uint (outfile_autohex);
6298 logfile_top_uint (outfile_check_timer);
6299 logfile_top_uint (outfile_format);
6300 logfile_top_uint (potfile_disable);
6301 logfile_top_uint (powertune_enable);
6302 logfile_top_uint (scrypt_tmto);
6303 logfile_top_uint (quiet);
6304 logfile_top_uint (remove);
6305 logfile_top_uint (remove_timer);
6306 logfile_top_uint (restore);
6307 logfile_top_uint (restore_disable);
6308 logfile_top_uint (restore_timer);
6309 logfile_top_uint (rp_gen);
6310 logfile_top_uint (rp_gen_func_max);
6311 logfile_top_uint (rp_gen_func_min);
6312 logfile_top_uint (rp_gen_seed);
6313 logfile_top_uint (runtime);
6314 logfile_top_uint (segment_size);
6315 logfile_top_uint (show);
6316 logfile_top_uint (status);
6317 logfile_top_uint (status_automat);
6318 logfile_top_uint (status_timer);
6319 logfile_top_uint (usage);
6320 logfile_top_uint (username);
6321 logfile_top_uint (version);
6322 logfile_top_uint (weak_hash_threshold);
6323 logfile_top_uint (workload_profile);
6324 logfile_top_uint64 (limit);
6325 logfile_top_uint64 (skip);
6326 logfile_top_char (separator);
6327 logfile_top_string (cpu_affinity);
6328 logfile_top_string (custom_charset_1);
6329 logfile_top_string (custom_charset_2);
6330 logfile_top_string (custom_charset_3);
6331 logfile_top_string (custom_charset_4);
6332 logfile_top_string (debug_file);
6333 logfile_top_string (gpu_devices);
6334 logfile_top_string (induction_dir);
6335 logfile_top_string (markov_hcstat);
6336 logfile_top_string (outfile);
6337 logfile_top_string (outfile_check_dir);
6338 logfile_top_string (rule_buf_l);
6339 logfile_top_string (rule_buf_r);
6340 logfile_top_string (session);
6341 logfile_top_string (truecrypt_keyfiles);
6342
6343 /**
6344 * devices
6345 */
6346
6347 uint gpu_devicemask = devices_to_devicemask (gpu_devices);
6348
6349 /**
6350 * benchmark
6351 */
6352
6353 if (benchmark == 1)
6354 {
6355 /**
6356 * disable useless stuff for benchmark
6357 */
6358
6359 restore_timer = 0;
6360 status_timer = 0;
6361 restore_disable = 1;
6362 potfile_disable = 1;
6363 weak_hash_threshold = 0;
6364
6365 data.restore_timer = restore_timer;
6366 data.status_timer = status_timer;
6367 data.restore_disable = restore_disable;
6368
6369 if (benchmark_mode == 1)
6370 {
6371 markov_disable = 1;
6372 }
6373
6374 /**
6375 * force attack mode to be bruteforce
6376 */
6377
6378 attack_mode = ATTACK_MODE_BF;
6379 attack_kern = ATTACK_KERN_BF;
6380
6381 if (runtime_chgd == 0)
6382 {
6383 runtime = 4;
6384
6385 if (benchmark_mode == 1) runtime = 17;
6386
6387 data.runtime = runtime;
6388 }
6389 }
6390
6391 /**
6392 * config
6393 */
6394
6395 uint hash_type = 0;
6396 uint salt_type = 0;
6397 uint attack_exec = 0;
6398 uint opts_type = 0;
6399 uint kern_type = 0;
6400 uint dgst_size = 0;
6401 uint esalt_size = 0;
6402 uint opti_type = 0;
6403 uint dgst_pos0 = -1;
6404 uint dgst_pos1 = -1;
6405 uint dgst_pos2 = -1;
6406 uint dgst_pos3 = -1;
6407
6408 int (*parse_func) (char *, uint, hash_t *);
6409 int (*sort_by_digest) (const void *, const void *);
6410
6411 uint algorithm_pos = 0;
6412 uint algorithm_max = 1;
6413
6414 uint *algorithms = default_benchmark_algorithms;
6415
6416 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6417
6418 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6419 {
6420 /*
6421 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6422 * the following algos are skipped entirely
6423 */
6424
6425 if (algorithm_pos > 0)
6426 {
6427 local_free (rd);
6428
6429 rd = init_restore (argc, argv);
6430
6431 data.rd = rd;
6432 }
6433
6434 /**
6435 * update hash_mode in case of multihash benchmark
6436 */
6437
6438 if (benchmark == 1)
6439 {
6440 if (hash_mode_chgd == 0)
6441 {
6442 hash_mode = algorithms[algorithm_pos];
6443
6444 data.hash_mode = hash_mode;
6445 }
6446
6447 quiet = 1;
6448
6449 data.quiet = quiet;
6450 }
6451
6452 switch (hash_mode)
6453 {
6454 case 0: hash_type = HASH_TYPE_MD5;
6455 salt_type = SALT_TYPE_NONE;
6456 attack_exec = ATTACK_EXEC_ON_GPU;
6457 opts_type = OPTS_TYPE_PT_GENERATE_LE
6458 | OPTS_TYPE_PT_ADD80
6459 | OPTS_TYPE_PT_ADDBITS14;
6460 kern_type = KERN_TYPE_MD5;
6461 dgst_size = DGST_SIZE_4_4;
6462 parse_func = md5_parse_hash;
6463 sort_by_digest = sort_by_digest_4_4;
6464 opti_type = OPTI_TYPE_ZERO_BYTE
6465 | OPTI_TYPE_PRECOMPUTE_INIT
6466 | OPTI_TYPE_PRECOMPUTE_MERKLE
6467 | OPTI_TYPE_MEET_IN_MIDDLE
6468 | OPTI_TYPE_EARLY_SKIP
6469 | OPTI_TYPE_NOT_ITERATED
6470 | OPTI_TYPE_NOT_SALTED
6471 | OPTI_TYPE_RAW_HASH;
6472 dgst_pos0 = 0;
6473 dgst_pos1 = 3;
6474 dgst_pos2 = 2;
6475 dgst_pos3 = 1;
6476 break;
6477
6478 case 10: hash_type = HASH_TYPE_MD5;
6479 salt_type = SALT_TYPE_INTERN;
6480 attack_exec = ATTACK_EXEC_ON_GPU;
6481 opts_type = OPTS_TYPE_PT_GENERATE_LE
6482 | OPTS_TYPE_ST_ADD80
6483 | OPTS_TYPE_ST_ADDBITS14;
6484 kern_type = KERN_TYPE_MD5_PWSLT;
6485 dgst_size = DGST_SIZE_4_4;
6486 parse_func = md5s_parse_hash;
6487 sort_by_digest = sort_by_digest_4_4;
6488 opti_type = OPTI_TYPE_ZERO_BYTE
6489 | OPTI_TYPE_PRECOMPUTE_INIT
6490 | OPTI_TYPE_PRECOMPUTE_MERKLE
6491 | OPTI_TYPE_MEET_IN_MIDDLE
6492 | OPTI_TYPE_EARLY_SKIP
6493 | OPTI_TYPE_NOT_ITERATED
6494 | OPTI_TYPE_APPENDED_SALT
6495 | OPTI_TYPE_RAW_HASH;
6496 dgst_pos0 = 0;
6497 dgst_pos1 = 3;
6498 dgst_pos2 = 2;
6499 dgst_pos3 = 1;
6500 break;
6501
6502 case 11: hash_type = HASH_TYPE_MD5;
6503 salt_type = SALT_TYPE_INTERN;
6504 attack_exec = ATTACK_EXEC_ON_GPU;
6505 opts_type = OPTS_TYPE_PT_GENERATE_LE
6506 | OPTS_TYPE_ST_ADD80
6507 | OPTS_TYPE_ST_ADDBITS14;
6508 kern_type = KERN_TYPE_MD5_PWSLT;
6509 dgst_size = DGST_SIZE_4_4;
6510 parse_func = joomla_parse_hash;
6511 sort_by_digest = sort_by_digest_4_4;
6512 opti_type = OPTI_TYPE_ZERO_BYTE
6513 | OPTI_TYPE_PRECOMPUTE_INIT
6514 | OPTI_TYPE_PRECOMPUTE_MERKLE
6515 | OPTI_TYPE_MEET_IN_MIDDLE
6516 | OPTI_TYPE_EARLY_SKIP
6517 | OPTI_TYPE_NOT_ITERATED
6518 | OPTI_TYPE_APPENDED_SALT
6519 | OPTI_TYPE_RAW_HASH;
6520 dgst_pos0 = 0;
6521 dgst_pos1 = 3;
6522 dgst_pos2 = 2;
6523 dgst_pos3 = 1;
6524 break;
6525
6526 case 12: hash_type = HASH_TYPE_MD5;
6527 salt_type = SALT_TYPE_INTERN;
6528 attack_exec = ATTACK_EXEC_ON_GPU;
6529 opts_type = OPTS_TYPE_PT_GENERATE_LE
6530 | OPTS_TYPE_ST_ADD80
6531 | OPTS_TYPE_ST_ADDBITS14;
6532 kern_type = KERN_TYPE_MD5_PWSLT;
6533 dgst_size = DGST_SIZE_4_4;
6534 parse_func = postgresql_parse_hash;
6535 sort_by_digest = sort_by_digest_4_4;
6536 opti_type = OPTI_TYPE_ZERO_BYTE
6537 | OPTI_TYPE_PRECOMPUTE_INIT
6538 | OPTI_TYPE_PRECOMPUTE_MERKLE
6539 | OPTI_TYPE_MEET_IN_MIDDLE
6540 | OPTI_TYPE_EARLY_SKIP
6541 | OPTI_TYPE_NOT_ITERATED
6542 | OPTI_TYPE_APPENDED_SALT
6543 | OPTI_TYPE_RAW_HASH;
6544 dgst_pos0 = 0;
6545 dgst_pos1 = 3;
6546 dgst_pos2 = 2;
6547 dgst_pos3 = 1;
6548 break;
6549
6550 case 20: hash_type = HASH_TYPE_MD5;
6551 salt_type = SALT_TYPE_INTERN;
6552 attack_exec = ATTACK_EXEC_ON_GPU;
6553 opts_type = OPTS_TYPE_PT_GENERATE_LE
6554 | OPTS_TYPE_PT_ADD80
6555 | OPTS_TYPE_PT_ADDBITS14;
6556 kern_type = KERN_TYPE_MD5_SLTPW;
6557 dgst_size = DGST_SIZE_4_4;
6558 parse_func = md5s_parse_hash;
6559 sort_by_digest = sort_by_digest_4_4;
6560 opti_type = OPTI_TYPE_ZERO_BYTE
6561 | OPTI_TYPE_PRECOMPUTE_INIT
6562 | OPTI_TYPE_PRECOMPUTE_MERKLE
6563 | OPTI_TYPE_EARLY_SKIP
6564 | OPTI_TYPE_NOT_ITERATED
6565 | OPTI_TYPE_PREPENDED_SALT
6566 | OPTI_TYPE_RAW_HASH;
6567 dgst_pos0 = 0;
6568 dgst_pos1 = 3;
6569 dgst_pos2 = 2;
6570 dgst_pos3 = 1;
6571 break;
6572
6573 case 21: hash_type = HASH_TYPE_MD5;
6574 salt_type = SALT_TYPE_INTERN;
6575 attack_exec = ATTACK_EXEC_ON_GPU;
6576 opts_type = OPTS_TYPE_PT_GENERATE_LE
6577 | OPTS_TYPE_PT_ADD80
6578 | OPTS_TYPE_PT_ADDBITS14;
6579 kern_type = KERN_TYPE_MD5_SLTPW;
6580 dgst_size = DGST_SIZE_4_4;
6581 parse_func = osc_parse_hash;
6582 sort_by_digest = sort_by_digest_4_4;
6583 opti_type = OPTI_TYPE_ZERO_BYTE
6584 | OPTI_TYPE_PRECOMPUTE_INIT
6585 | OPTI_TYPE_PRECOMPUTE_MERKLE
6586 | OPTI_TYPE_EARLY_SKIP
6587 | OPTI_TYPE_NOT_ITERATED
6588 | OPTI_TYPE_PREPENDED_SALT
6589 | OPTI_TYPE_RAW_HASH;
6590 dgst_pos0 = 0;
6591 dgst_pos1 = 3;
6592 dgst_pos2 = 2;
6593 dgst_pos3 = 1;
6594 break;
6595
6596 case 22: hash_type = HASH_TYPE_MD5;
6597 salt_type = SALT_TYPE_EMBEDDED;
6598 attack_exec = ATTACK_EXEC_ON_GPU;
6599 opts_type = OPTS_TYPE_PT_GENERATE_LE
6600 | OPTS_TYPE_PT_ADD80
6601 | OPTS_TYPE_PT_ADDBITS14;
6602 kern_type = KERN_TYPE_MD5_SLTPW;
6603 dgst_size = DGST_SIZE_4_4;
6604 parse_func = netscreen_parse_hash;
6605 sort_by_digest = sort_by_digest_4_4;
6606 opti_type = OPTI_TYPE_ZERO_BYTE
6607 | OPTI_TYPE_PRECOMPUTE_INIT
6608 | OPTI_TYPE_PRECOMPUTE_MERKLE
6609 | OPTI_TYPE_EARLY_SKIP
6610 | OPTI_TYPE_NOT_ITERATED
6611 | OPTI_TYPE_PREPENDED_SALT
6612 | OPTI_TYPE_RAW_HASH;
6613 dgst_pos0 = 0;
6614 dgst_pos1 = 3;
6615 dgst_pos2 = 2;
6616 dgst_pos3 = 1;
6617 break;
6618
6619 case 23: hash_type = HASH_TYPE_MD5;
6620 salt_type = SALT_TYPE_EMBEDDED;
6621 attack_exec = ATTACK_EXEC_ON_GPU;
6622 opts_type = OPTS_TYPE_PT_GENERATE_LE
6623 | OPTS_TYPE_PT_ADD80
6624 | OPTS_TYPE_PT_ADDBITS14;
6625 kern_type = KERN_TYPE_MD5_SLTPW;
6626 dgst_size = DGST_SIZE_4_4;
6627 parse_func = skype_parse_hash;
6628 sort_by_digest = sort_by_digest_4_4;
6629 opti_type = OPTI_TYPE_ZERO_BYTE
6630 | OPTI_TYPE_PRECOMPUTE_INIT
6631 | OPTI_TYPE_PRECOMPUTE_MERKLE
6632 | OPTI_TYPE_EARLY_SKIP
6633 | OPTI_TYPE_NOT_ITERATED
6634 | OPTI_TYPE_PREPENDED_SALT
6635 | OPTI_TYPE_RAW_HASH;
6636 dgst_pos0 = 0;
6637 dgst_pos1 = 3;
6638 dgst_pos2 = 2;
6639 dgst_pos3 = 1;
6640 break;
6641
6642 case 30: hash_type = HASH_TYPE_MD5;
6643 salt_type = SALT_TYPE_INTERN;
6644 attack_exec = ATTACK_EXEC_ON_GPU;
6645 opts_type = OPTS_TYPE_PT_GENERATE_LE
6646 | OPTS_TYPE_PT_UNICODE
6647 | OPTS_TYPE_ST_ADD80
6648 | OPTS_TYPE_ST_ADDBITS14;
6649 kern_type = KERN_TYPE_MD5_PWUSLT;
6650 dgst_size = DGST_SIZE_4_4;
6651 parse_func = md5s_parse_hash;
6652 sort_by_digest = sort_by_digest_4_4;
6653 opti_type = OPTI_TYPE_ZERO_BYTE
6654 | OPTI_TYPE_PRECOMPUTE_INIT
6655 | OPTI_TYPE_PRECOMPUTE_MERKLE
6656 | OPTI_TYPE_MEET_IN_MIDDLE
6657 | OPTI_TYPE_EARLY_SKIP
6658 | OPTI_TYPE_NOT_ITERATED
6659 | OPTI_TYPE_APPENDED_SALT
6660 | OPTI_TYPE_RAW_HASH;
6661 dgst_pos0 = 0;
6662 dgst_pos1 = 3;
6663 dgst_pos2 = 2;
6664 dgst_pos3 = 1;
6665 break;
6666
6667 case 40: hash_type = HASH_TYPE_MD5;
6668 salt_type = SALT_TYPE_INTERN;
6669 attack_exec = ATTACK_EXEC_ON_GPU;
6670 opts_type = OPTS_TYPE_PT_GENERATE_LE
6671 | OPTS_TYPE_PT_ADD80
6672 | OPTS_TYPE_PT_ADDBITS14
6673 | OPTS_TYPE_PT_UNICODE;
6674 kern_type = KERN_TYPE_MD5_SLTPWU;
6675 dgst_size = DGST_SIZE_4_4;
6676 parse_func = md5s_parse_hash;
6677 sort_by_digest = sort_by_digest_4_4;
6678 opti_type = OPTI_TYPE_ZERO_BYTE
6679 | OPTI_TYPE_PRECOMPUTE_INIT
6680 | OPTI_TYPE_PRECOMPUTE_MERKLE
6681 | OPTI_TYPE_EARLY_SKIP
6682 | OPTI_TYPE_NOT_ITERATED
6683 | OPTI_TYPE_PREPENDED_SALT
6684 | OPTI_TYPE_RAW_HASH;
6685 dgst_pos0 = 0;
6686 dgst_pos1 = 3;
6687 dgst_pos2 = 2;
6688 dgst_pos3 = 1;
6689 break;
6690
6691 case 50: hash_type = HASH_TYPE_MD5;
6692 salt_type = SALT_TYPE_INTERN;
6693 attack_exec = ATTACK_EXEC_ON_GPU;
6694 opts_type = OPTS_TYPE_PT_GENERATE_LE
6695 | OPTS_TYPE_ST_ADD80
6696 | OPTS_TYPE_ST_ADDBITS14;
6697 kern_type = KERN_TYPE_HMACMD5_PW;
6698 dgst_size = DGST_SIZE_4_4;
6699 parse_func = hmacmd5_parse_hash;
6700 sort_by_digest = sort_by_digest_4_4;
6701 opti_type = OPTI_TYPE_ZERO_BYTE
6702 | OPTI_TYPE_NOT_ITERATED;
6703 dgst_pos0 = 0;
6704 dgst_pos1 = 3;
6705 dgst_pos2 = 2;
6706 dgst_pos3 = 1;
6707 break;
6708
6709 case 60: hash_type = HASH_TYPE_MD5;
6710 salt_type = SALT_TYPE_INTERN;
6711 attack_exec = ATTACK_EXEC_ON_GPU;
6712 opts_type = OPTS_TYPE_PT_GENERATE_LE
6713 | OPTS_TYPE_PT_ADD80
6714 | OPTS_TYPE_PT_ADDBITS14;
6715 kern_type = KERN_TYPE_HMACMD5_SLT;
6716 dgst_size = DGST_SIZE_4_4;
6717 parse_func = hmacmd5_parse_hash;
6718 sort_by_digest = sort_by_digest_4_4;
6719 opti_type = OPTI_TYPE_ZERO_BYTE
6720 | OPTI_TYPE_NOT_ITERATED;
6721 dgst_pos0 = 0;
6722 dgst_pos1 = 3;
6723 dgst_pos2 = 2;
6724 dgst_pos3 = 1;
6725 break;
6726
6727 case 100: hash_type = HASH_TYPE_SHA1;
6728 salt_type = SALT_TYPE_NONE;
6729 attack_exec = ATTACK_EXEC_ON_GPU;
6730 opts_type = OPTS_TYPE_PT_GENERATE_BE
6731 | OPTS_TYPE_PT_ADD80
6732 | OPTS_TYPE_PT_ADDBITS15;
6733 kern_type = KERN_TYPE_SHA1;
6734 dgst_size = DGST_SIZE_4_5;
6735 parse_func = sha1_parse_hash;
6736 sort_by_digest = sort_by_digest_4_5;
6737 opti_type = OPTI_TYPE_ZERO_BYTE
6738 | OPTI_TYPE_PRECOMPUTE_INIT
6739 | OPTI_TYPE_PRECOMPUTE_MERKLE
6740 | OPTI_TYPE_EARLY_SKIP
6741 | OPTI_TYPE_NOT_ITERATED
6742 | OPTI_TYPE_NOT_SALTED
6743 | OPTI_TYPE_RAW_HASH;
6744 dgst_pos0 = 3;
6745 dgst_pos1 = 4;
6746 dgst_pos2 = 2;
6747 dgst_pos3 = 1;
6748 break;
6749
6750 case 101: hash_type = HASH_TYPE_SHA1;
6751 salt_type = SALT_TYPE_NONE;
6752 attack_exec = ATTACK_EXEC_ON_GPU;
6753 opts_type = OPTS_TYPE_PT_GENERATE_BE
6754 | OPTS_TYPE_PT_ADD80
6755 | OPTS_TYPE_PT_ADDBITS15;
6756 kern_type = KERN_TYPE_SHA1;
6757 dgst_size = DGST_SIZE_4_5;
6758 parse_func = sha1b64_parse_hash;
6759 sort_by_digest = sort_by_digest_4_5;
6760 opti_type = OPTI_TYPE_ZERO_BYTE
6761 | OPTI_TYPE_PRECOMPUTE_INIT
6762 | OPTI_TYPE_PRECOMPUTE_MERKLE
6763 | OPTI_TYPE_EARLY_SKIP
6764 | OPTI_TYPE_NOT_ITERATED
6765 | OPTI_TYPE_NOT_SALTED
6766 | OPTI_TYPE_RAW_HASH;
6767 dgst_pos0 = 3;
6768 dgst_pos1 = 4;
6769 dgst_pos2 = 2;
6770 dgst_pos3 = 1;
6771 break;
6772
6773 case 110: hash_type = HASH_TYPE_SHA1;
6774 salt_type = SALT_TYPE_INTERN;
6775 attack_exec = ATTACK_EXEC_ON_GPU;
6776 opts_type = OPTS_TYPE_PT_GENERATE_BE
6777 | OPTS_TYPE_ST_ADD80
6778 | OPTS_TYPE_ST_ADDBITS15;
6779 kern_type = KERN_TYPE_SHA1_PWSLT;
6780 dgst_size = DGST_SIZE_4_5;
6781 parse_func = sha1s_parse_hash;
6782 sort_by_digest = sort_by_digest_4_5;
6783 opti_type = OPTI_TYPE_ZERO_BYTE
6784 | OPTI_TYPE_PRECOMPUTE_INIT
6785 | OPTI_TYPE_PRECOMPUTE_MERKLE
6786 | OPTI_TYPE_EARLY_SKIP
6787 | OPTI_TYPE_NOT_ITERATED
6788 | OPTI_TYPE_APPENDED_SALT
6789 | OPTI_TYPE_RAW_HASH;
6790 dgst_pos0 = 3;
6791 dgst_pos1 = 4;
6792 dgst_pos2 = 2;
6793 dgst_pos3 = 1;
6794 break;
6795
6796 case 111: hash_type = HASH_TYPE_SHA1;
6797 salt_type = SALT_TYPE_EMBEDDED;
6798 attack_exec = ATTACK_EXEC_ON_GPU;
6799 opts_type = OPTS_TYPE_PT_GENERATE_BE
6800 | OPTS_TYPE_ST_ADD80
6801 | OPTS_TYPE_ST_ADDBITS15;
6802 kern_type = KERN_TYPE_SHA1_PWSLT;
6803 dgst_size = DGST_SIZE_4_5;
6804 parse_func = sha1b64s_parse_hash;
6805 sort_by_digest = sort_by_digest_4_5;
6806 opti_type = OPTI_TYPE_ZERO_BYTE
6807 | OPTI_TYPE_PRECOMPUTE_INIT
6808 | OPTI_TYPE_PRECOMPUTE_MERKLE
6809 | OPTI_TYPE_EARLY_SKIP
6810 | OPTI_TYPE_NOT_ITERATED
6811 | OPTI_TYPE_APPENDED_SALT
6812 | OPTI_TYPE_RAW_HASH;
6813 dgst_pos0 = 3;
6814 dgst_pos1 = 4;
6815 dgst_pos2 = 2;
6816 dgst_pos3 = 1;
6817 break;
6818
6819 case 112: hash_type = HASH_TYPE_SHA1;
6820 salt_type = SALT_TYPE_INTERN;
6821 attack_exec = ATTACK_EXEC_ON_GPU;
6822 opts_type = OPTS_TYPE_PT_GENERATE_BE
6823 | OPTS_TYPE_ST_ADD80
6824 | OPTS_TYPE_ST_ADDBITS15
6825 | OPTS_TYPE_ST_HEX;
6826 kern_type = KERN_TYPE_SHA1_PWSLT;
6827 dgst_size = DGST_SIZE_4_5;
6828 parse_func = oracles_parse_hash;
6829 sort_by_digest = sort_by_digest_4_5;
6830 opti_type = OPTI_TYPE_ZERO_BYTE
6831 | OPTI_TYPE_PRECOMPUTE_INIT
6832 | OPTI_TYPE_PRECOMPUTE_MERKLE
6833 | OPTI_TYPE_EARLY_SKIP
6834 | OPTI_TYPE_NOT_ITERATED
6835 | OPTI_TYPE_APPENDED_SALT
6836 | OPTI_TYPE_RAW_HASH;
6837 dgst_pos0 = 3;
6838 dgst_pos1 = 4;
6839 dgst_pos2 = 2;
6840 dgst_pos3 = 1;
6841 break;
6842
6843 case 120: hash_type = HASH_TYPE_SHA1;
6844 salt_type = SALT_TYPE_INTERN;
6845 attack_exec = ATTACK_EXEC_ON_GPU;
6846 opts_type = OPTS_TYPE_PT_GENERATE_BE
6847 | OPTS_TYPE_PT_ADD80
6848 | OPTS_TYPE_PT_ADDBITS15;
6849 kern_type = KERN_TYPE_SHA1_SLTPW;
6850 dgst_size = DGST_SIZE_4_5;
6851 parse_func = sha1s_parse_hash;
6852 sort_by_digest = sort_by_digest_4_5;
6853 opti_type = OPTI_TYPE_ZERO_BYTE
6854 | OPTI_TYPE_PRECOMPUTE_INIT
6855 | OPTI_TYPE_PRECOMPUTE_MERKLE
6856 | OPTI_TYPE_EARLY_SKIP
6857 | OPTI_TYPE_NOT_ITERATED
6858 | OPTI_TYPE_PREPENDED_SALT
6859 | OPTI_TYPE_RAW_HASH;
6860 dgst_pos0 = 3;
6861 dgst_pos1 = 4;
6862 dgst_pos2 = 2;
6863 dgst_pos3 = 1;
6864 break;
6865
6866 case 121: hash_type = HASH_TYPE_SHA1;
6867 salt_type = SALT_TYPE_INTERN;
6868 attack_exec = ATTACK_EXEC_ON_GPU;
6869 opts_type = OPTS_TYPE_PT_GENERATE_BE
6870 | OPTS_TYPE_PT_ADD80
6871 | OPTS_TYPE_PT_ADDBITS15
6872 | OPTS_TYPE_ST_LOWER;
6873 kern_type = KERN_TYPE_SHA1_SLTPW;
6874 dgst_size = DGST_SIZE_4_5;
6875 parse_func = smf_parse_hash;
6876 sort_by_digest = sort_by_digest_4_5;
6877 opti_type = OPTI_TYPE_ZERO_BYTE
6878 | OPTI_TYPE_PRECOMPUTE_INIT
6879 | OPTI_TYPE_PRECOMPUTE_MERKLE
6880 | OPTI_TYPE_EARLY_SKIP
6881 | OPTI_TYPE_NOT_ITERATED
6882 | OPTI_TYPE_PREPENDED_SALT
6883 | OPTI_TYPE_RAW_HASH;
6884 dgst_pos0 = 3;
6885 dgst_pos1 = 4;
6886 dgst_pos2 = 2;
6887 dgst_pos3 = 1;
6888 break;
6889
6890 case 122: hash_type = HASH_TYPE_SHA1;
6891 salt_type = SALT_TYPE_EMBEDDED;
6892 attack_exec = ATTACK_EXEC_ON_GPU;
6893 opts_type = OPTS_TYPE_PT_GENERATE_BE
6894 | OPTS_TYPE_PT_ADD80
6895 | OPTS_TYPE_PT_ADDBITS15
6896 | OPTS_TYPE_ST_HEX;
6897 kern_type = KERN_TYPE_SHA1_SLTPW;
6898 dgst_size = DGST_SIZE_4_5;
6899 parse_func = osx1_parse_hash;
6900 sort_by_digest = sort_by_digest_4_5;
6901 opti_type = OPTI_TYPE_ZERO_BYTE
6902 | OPTI_TYPE_PRECOMPUTE_INIT
6903 | OPTI_TYPE_PRECOMPUTE_MERKLE
6904 | OPTI_TYPE_EARLY_SKIP
6905 | OPTI_TYPE_NOT_ITERATED
6906 | OPTI_TYPE_PREPENDED_SALT
6907 | OPTI_TYPE_RAW_HASH;
6908 dgst_pos0 = 3;
6909 dgst_pos1 = 4;
6910 dgst_pos2 = 2;
6911 dgst_pos3 = 1;
6912 break;
6913
6914 case 124: hash_type = HASH_TYPE_SHA1;
6915 salt_type = SALT_TYPE_EMBEDDED;
6916 attack_exec = ATTACK_EXEC_ON_GPU;
6917 opts_type = OPTS_TYPE_PT_GENERATE_BE
6918 | OPTS_TYPE_PT_ADD80
6919 | OPTS_TYPE_PT_ADDBITS15;
6920 kern_type = KERN_TYPE_SHA1_SLTPW;
6921 dgst_size = DGST_SIZE_4_5;
6922 parse_func = djangosha1_parse_hash;
6923 sort_by_digest = sort_by_digest_4_5;
6924 opti_type = OPTI_TYPE_ZERO_BYTE
6925 | OPTI_TYPE_PRECOMPUTE_INIT
6926 | OPTI_TYPE_PRECOMPUTE_MERKLE
6927 | OPTI_TYPE_EARLY_SKIP
6928 | OPTI_TYPE_NOT_ITERATED
6929 | OPTI_TYPE_PREPENDED_SALT
6930 | OPTI_TYPE_RAW_HASH;
6931 dgst_pos0 = 3;
6932 dgst_pos1 = 4;
6933 dgst_pos2 = 2;
6934 dgst_pos3 = 1;
6935 break;
6936
6937 case 130: hash_type = HASH_TYPE_SHA1;
6938 salt_type = SALT_TYPE_INTERN;
6939 attack_exec = ATTACK_EXEC_ON_GPU;
6940 opts_type = OPTS_TYPE_PT_GENERATE_BE
6941 | OPTS_TYPE_PT_UNICODE
6942 | OPTS_TYPE_ST_ADD80
6943 | OPTS_TYPE_ST_ADDBITS15;
6944 kern_type = KERN_TYPE_SHA1_PWUSLT;
6945 dgst_size = DGST_SIZE_4_5;
6946 parse_func = sha1s_parse_hash;
6947 sort_by_digest = sort_by_digest_4_5;
6948 opti_type = OPTI_TYPE_ZERO_BYTE
6949 | OPTI_TYPE_PRECOMPUTE_INIT
6950 | OPTI_TYPE_PRECOMPUTE_MERKLE
6951 | OPTI_TYPE_EARLY_SKIP
6952 | OPTI_TYPE_NOT_ITERATED
6953 | OPTI_TYPE_APPENDED_SALT
6954 | OPTI_TYPE_RAW_HASH;
6955 dgst_pos0 = 3;
6956 dgst_pos1 = 4;
6957 dgst_pos2 = 2;
6958 dgst_pos3 = 1;
6959 break;
6960
6961 case 131: hash_type = HASH_TYPE_SHA1;
6962 salt_type = SALT_TYPE_EMBEDDED;
6963 attack_exec = ATTACK_EXEC_ON_GPU;
6964 opts_type = OPTS_TYPE_PT_GENERATE_BE
6965 | OPTS_TYPE_PT_UNICODE
6966 | OPTS_TYPE_PT_UPPER
6967 | OPTS_TYPE_ST_ADD80
6968 | OPTS_TYPE_ST_ADDBITS15
6969 | OPTS_TYPE_ST_HEX;
6970 kern_type = KERN_TYPE_SHA1_PWUSLT;
6971 dgst_size = DGST_SIZE_4_5;
6972 parse_func = mssql2000_parse_hash;
6973 sort_by_digest = sort_by_digest_4_5;
6974 opti_type = OPTI_TYPE_ZERO_BYTE
6975 | OPTI_TYPE_PRECOMPUTE_INIT
6976 | OPTI_TYPE_PRECOMPUTE_MERKLE
6977 | OPTI_TYPE_EARLY_SKIP
6978 | OPTI_TYPE_NOT_ITERATED
6979 | OPTI_TYPE_APPENDED_SALT
6980 | OPTI_TYPE_RAW_HASH;
6981 dgst_pos0 = 3;
6982 dgst_pos1 = 4;
6983 dgst_pos2 = 2;
6984 dgst_pos3 = 1;
6985 break;
6986
6987 case 132: hash_type = HASH_TYPE_SHA1;
6988 salt_type = SALT_TYPE_EMBEDDED;
6989 attack_exec = ATTACK_EXEC_ON_GPU;
6990 opts_type = OPTS_TYPE_PT_GENERATE_BE
6991 | OPTS_TYPE_PT_UNICODE
6992 | OPTS_TYPE_ST_ADD80
6993 | OPTS_TYPE_ST_ADDBITS15
6994 | OPTS_TYPE_ST_HEX;
6995 kern_type = KERN_TYPE_SHA1_PWUSLT;
6996 dgst_size = DGST_SIZE_4_5;
6997 parse_func = mssql2005_parse_hash;
6998 sort_by_digest = sort_by_digest_4_5;
6999 opti_type = OPTI_TYPE_ZERO_BYTE
7000 | OPTI_TYPE_PRECOMPUTE_INIT
7001 | OPTI_TYPE_PRECOMPUTE_MERKLE
7002 | OPTI_TYPE_EARLY_SKIP
7003 | OPTI_TYPE_NOT_ITERATED
7004 | OPTI_TYPE_APPENDED_SALT
7005 | OPTI_TYPE_RAW_HASH;
7006 dgst_pos0 = 3;
7007 dgst_pos1 = 4;
7008 dgst_pos2 = 2;
7009 dgst_pos3 = 1;
7010 break;
7011
7012 case 133: hash_type = HASH_TYPE_SHA1;
7013 salt_type = SALT_TYPE_EMBEDDED;
7014 attack_exec = ATTACK_EXEC_ON_GPU;
7015 opts_type = OPTS_TYPE_PT_GENERATE_BE
7016 | OPTS_TYPE_PT_UNICODE
7017 | OPTS_TYPE_ST_ADD80
7018 | OPTS_TYPE_ST_ADDBITS15;
7019 kern_type = KERN_TYPE_SHA1_PWUSLT;
7020 dgst_size = DGST_SIZE_4_5;
7021 parse_func = peoplesoft_parse_hash;
7022 sort_by_digest = sort_by_digest_4_5;
7023 opti_type = OPTI_TYPE_ZERO_BYTE
7024 | OPTI_TYPE_PRECOMPUTE_INIT
7025 | OPTI_TYPE_PRECOMPUTE_MERKLE
7026 | OPTI_TYPE_EARLY_SKIP
7027 | OPTI_TYPE_NOT_ITERATED
7028 | OPTI_TYPE_APPENDED_SALT
7029 | OPTI_TYPE_RAW_HASH;
7030 dgst_pos0 = 3;
7031 dgst_pos1 = 4;
7032 dgst_pos2 = 2;
7033 dgst_pos3 = 1;
7034 break;
7035
7036 case 140: hash_type = HASH_TYPE_SHA1;
7037 salt_type = SALT_TYPE_INTERN;
7038 attack_exec = ATTACK_EXEC_ON_GPU;
7039 opts_type = OPTS_TYPE_PT_GENERATE_BE
7040 | OPTS_TYPE_PT_ADD80
7041 | OPTS_TYPE_PT_ADDBITS15
7042 | OPTS_TYPE_PT_UNICODE;
7043 kern_type = KERN_TYPE_SHA1_SLTPWU;
7044 dgst_size = DGST_SIZE_4_5;
7045 parse_func = sha1s_parse_hash;
7046 sort_by_digest = sort_by_digest_4_5;
7047 opti_type = OPTI_TYPE_ZERO_BYTE
7048 | OPTI_TYPE_PRECOMPUTE_INIT
7049 | OPTI_TYPE_PRECOMPUTE_MERKLE
7050 | OPTI_TYPE_EARLY_SKIP
7051 | OPTI_TYPE_NOT_ITERATED
7052 | OPTI_TYPE_PREPENDED_SALT
7053 | OPTI_TYPE_RAW_HASH;
7054 dgst_pos0 = 3;
7055 dgst_pos1 = 4;
7056 dgst_pos2 = 2;
7057 dgst_pos3 = 1;
7058 break;
7059
7060 case 141: hash_type = HASH_TYPE_SHA1;
7061 salt_type = SALT_TYPE_EMBEDDED;
7062 attack_exec = ATTACK_EXEC_ON_GPU;
7063 opts_type = OPTS_TYPE_PT_GENERATE_BE
7064 | OPTS_TYPE_PT_ADD80
7065 | OPTS_TYPE_PT_ADDBITS15
7066 | OPTS_TYPE_PT_UNICODE
7067 | OPTS_TYPE_ST_BASE64;
7068 kern_type = KERN_TYPE_SHA1_SLTPWU;
7069 dgst_size = DGST_SIZE_4_5;
7070 parse_func = episerver_parse_hash;
7071 sort_by_digest = sort_by_digest_4_5;
7072 opti_type = OPTI_TYPE_ZERO_BYTE
7073 | OPTI_TYPE_PRECOMPUTE_INIT
7074 | OPTI_TYPE_PRECOMPUTE_MERKLE
7075 | OPTI_TYPE_EARLY_SKIP
7076 | OPTI_TYPE_NOT_ITERATED
7077 | OPTI_TYPE_PREPENDED_SALT
7078 | OPTI_TYPE_RAW_HASH;
7079 dgst_pos0 = 3;
7080 dgst_pos1 = 4;
7081 dgst_pos2 = 2;
7082 dgst_pos3 = 1;
7083 break;
7084
7085 case 150: hash_type = HASH_TYPE_SHA1;
7086 salt_type = SALT_TYPE_INTERN;
7087 attack_exec = ATTACK_EXEC_ON_GPU;
7088 opts_type = OPTS_TYPE_PT_GENERATE_BE
7089 | OPTS_TYPE_ST_ADD80
7090 | OPTS_TYPE_ST_ADDBITS15;
7091 kern_type = KERN_TYPE_HMACSHA1_PW;
7092 dgst_size = DGST_SIZE_4_5;
7093 parse_func = hmacsha1_parse_hash;
7094 sort_by_digest = sort_by_digest_4_5;
7095 opti_type = OPTI_TYPE_ZERO_BYTE
7096 | OPTI_TYPE_NOT_ITERATED;
7097 dgst_pos0 = 3;
7098 dgst_pos1 = 4;
7099 dgst_pos2 = 2;
7100 dgst_pos3 = 1;
7101 break;
7102
7103 case 160: hash_type = HASH_TYPE_SHA1;
7104 salt_type = SALT_TYPE_INTERN;
7105 attack_exec = ATTACK_EXEC_ON_GPU;
7106 opts_type = OPTS_TYPE_PT_GENERATE_BE
7107 | OPTS_TYPE_PT_ADD80
7108 | OPTS_TYPE_PT_ADDBITS15;
7109 kern_type = KERN_TYPE_HMACSHA1_SLT;
7110 dgst_size = DGST_SIZE_4_5;
7111 parse_func = hmacsha1_parse_hash;
7112 sort_by_digest = sort_by_digest_4_5;
7113 opti_type = OPTI_TYPE_ZERO_BYTE
7114 | OPTI_TYPE_NOT_ITERATED;
7115 dgst_pos0 = 3;
7116 dgst_pos1 = 4;
7117 dgst_pos2 = 2;
7118 dgst_pos3 = 1;
7119 break;
7120
7121 case 190: hash_type = HASH_TYPE_SHA1;
7122 salt_type = SALT_TYPE_NONE;
7123 attack_exec = ATTACK_EXEC_ON_GPU;
7124 opts_type = OPTS_TYPE_PT_GENERATE_BE
7125 | OPTS_TYPE_PT_ADD80
7126 | OPTS_TYPE_PT_ADDBITS15;
7127 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7128 dgst_size = DGST_SIZE_4_5;
7129 parse_func = sha1linkedin_parse_hash;
7130 sort_by_digest = sort_by_digest_4_5;
7131 opti_type = OPTI_TYPE_ZERO_BYTE
7132 | OPTI_TYPE_PRECOMPUTE_INIT
7133 | OPTI_TYPE_EARLY_SKIP
7134 | OPTI_TYPE_NOT_ITERATED
7135 | OPTI_TYPE_NOT_SALTED;
7136 dgst_pos0 = 0;
7137 dgst_pos1 = 4;
7138 dgst_pos2 = 3;
7139 dgst_pos3 = 2;
7140 break;
7141
7142 case 200: hash_type = HASH_TYPE_MYSQL;
7143 salt_type = SALT_TYPE_NONE;
7144 attack_exec = ATTACK_EXEC_ON_GPU;
7145 opts_type = 0;
7146 kern_type = KERN_TYPE_MYSQL;
7147 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7148 parse_func = mysql323_parse_hash;
7149 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7150 opti_type = OPTI_TYPE_ZERO_BYTE;
7151 dgst_pos0 = 0;
7152 dgst_pos1 = 1;
7153 dgst_pos2 = 2;
7154 dgst_pos3 = 3;
7155 break;
7156
7157 case 300: hash_type = HASH_TYPE_SHA1;
7158 salt_type = SALT_TYPE_NONE;
7159 attack_exec = ATTACK_EXEC_ON_GPU;
7160 opts_type = OPTS_TYPE_PT_GENERATE_BE
7161 | OPTS_TYPE_PT_ADD80
7162 | OPTS_TYPE_PT_ADDBITS15;
7163 kern_type = KERN_TYPE_MYSQL41;
7164 dgst_size = DGST_SIZE_4_5;
7165 parse_func = sha1_parse_hash;
7166 sort_by_digest = sort_by_digest_4_5;
7167 opti_type = OPTI_TYPE_ZERO_BYTE
7168 | OPTI_TYPE_PRECOMPUTE_INIT
7169 | OPTI_TYPE_PRECOMPUTE_MERKLE
7170 | OPTI_TYPE_EARLY_SKIP
7171 | OPTI_TYPE_NOT_ITERATED
7172 | OPTI_TYPE_NOT_SALTED;
7173 dgst_pos0 = 3;
7174 dgst_pos1 = 4;
7175 dgst_pos2 = 2;
7176 dgst_pos3 = 1;
7177 break;
7178
7179 case 400: hash_type = HASH_TYPE_MD5;
7180 salt_type = SALT_TYPE_EMBEDDED;
7181 attack_exec = ATTACK_EXEC_ON_CPU;
7182 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7183 kern_type = KERN_TYPE_PHPASS;
7184 dgst_size = DGST_SIZE_4_4;
7185 parse_func = phpass_parse_hash;
7186 sort_by_digest = sort_by_digest_4_4;
7187 opti_type = OPTI_TYPE_ZERO_BYTE;
7188 dgst_pos0 = 0;
7189 dgst_pos1 = 1;
7190 dgst_pos2 = 2;
7191 dgst_pos3 = 3;
7192 break;
7193
7194 case 500: hash_type = HASH_TYPE_MD5;
7195 salt_type = SALT_TYPE_EMBEDDED;
7196 attack_exec = ATTACK_EXEC_ON_CPU;
7197 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7198 kern_type = KERN_TYPE_MD5CRYPT;
7199 dgst_size = DGST_SIZE_4_4;
7200 parse_func = md5crypt_parse_hash;
7201 sort_by_digest = sort_by_digest_4_4;
7202 opti_type = OPTI_TYPE_ZERO_BYTE;
7203 dgst_pos0 = 0;
7204 dgst_pos1 = 1;
7205 dgst_pos2 = 2;
7206 dgst_pos3 = 3;
7207 break;
7208
7209 case 501: hash_type = HASH_TYPE_MD5;
7210 salt_type = SALT_TYPE_EMBEDDED;
7211 attack_exec = ATTACK_EXEC_ON_CPU;
7212 opts_type = OPTS_TYPE_PT_GENERATE_LE
7213 | OPTS_TYPE_HASH_COPY;
7214 kern_type = KERN_TYPE_MD5CRYPT;
7215 dgst_size = DGST_SIZE_4_4;
7216 parse_func = juniper_parse_hash;
7217 sort_by_digest = sort_by_digest_4_4;
7218 opti_type = OPTI_TYPE_ZERO_BYTE;
7219 dgst_pos0 = 0;
7220 dgst_pos1 = 1;
7221 dgst_pos2 = 2;
7222 dgst_pos3 = 3;
7223 break;
7224
7225 case 900: hash_type = HASH_TYPE_MD4;
7226 salt_type = SALT_TYPE_NONE;
7227 attack_exec = ATTACK_EXEC_ON_GPU;
7228 opts_type = OPTS_TYPE_PT_GENERATE_LE
7229 | OPTS_TYPE_PT_ADD80
7230 | OPTS_TYPE_PT_ADDBITS14;
7231 kern_type = KERN_TYPE_MD4;
7232 dgst_size = DGST_SIZE_4_4;
7233 parse_func = md4_parse_hash;
7234 sort_by_digest = sort_by_digest_4_4;
7235 opti_type = OPTI_TYPE_ZERO_BYTE
7236 | OPTI_TYPE_PRECOMPUTE_INIT
7237 | OPTI_TYPE_PRECOMPUTE_MERKLE
7238 | OPTI_TYPE_MEET_IN_MIDDLE
7239 | OPTI_TYPE_EARLY_SKIP
7240 | OPTI_TYPE_NOT_ITERATED
7241 | OPTI_TYPE_NOT_SALTED
7242 | OPTI_TYPE_RAW_HASH;
7243 dgst_pos0 = 0;
7244 dgst_pos1 = 3;
7245 dgst_pos2 = 2;
7246 dgst_pos3 = 1;
7247 break;
7248
7249 case 1000: hash_type = HASH_TYPE_MD4;
7250 salt_type = SALT_TYPE_NONE;
7251 attack_exec = ATTACK_EXEC_ON_GPU;
7252 opts_type = OPTS_TYPE_PT_GENERATE_LE
7253 | OPTS_TYPE_PT_ADD80
7254 | OPTS_TYPE_PT_ADDBITS14
7255 | OPTS_TYPE_PT_UNICODE;
7256 kern_type = KERN_TYPE_MD4_PWU;
7257 dgst_size = DGST_SIZE_4_4;
7258 parse_func = md4_parse_hash;
7259 sort_by_digest = sort_by_digest_4_4;
7260 opti_type = OPTI_TYPE_ZERO_BYTE
7261 | OPTI_TYPE_PRECOMPUTE_INIT
7262 | OPTI_TYPE_PRECOMPUTE_MERKLE
7263 | OPTI_TYPE_MEET_IN_MIDDLE
7264 | OPTI_TYPE_EARLY_SKIP
7265 | OPTI_TYPE_NOT_ITERATED
7266 | OPTI_TYPE_NOT_SALTED
7267 | OPTI_TYPE_RAW_HASH;
7268 dgst_pos0 = 0;
7269 dgst_pos1 = 3;
7270 dgst_pos2 = 2;
7271 dgst_pos3 = 1;
7272 break;
7273
7274 case 1100: hash_type = HASH_TYPE_MD4;
7275 salt_type = SALT_TYPE_INTERN;
7276 attack_exec = ATTACK_EXEC_ON_GPU;
7277 opts_type = OPTS_TYPE_PT_GENERATE_LE
7278 | OPTS_TYPE_PT_ADD80
7279 | OPTS_TYPE_PT_ADDBITS14
7280 | OPTS_TYPE_PT_UNICODE
7281 | OPTS_TYPE_ST_ADD80
7282 | OPTS_TYPE_ST_UNICODE
7283 | OPTS_TYPE_ST_LOWER;
7284 kern_type = KERN_TYPE_MD44_PWUSLT;
7285 dgst_size = DGST_SIZE_4_4;
7286 parse_func = dcc_parse_hash;
7287 sort_by_digest = sort_by_digest_4_4;
7288 opti_type = OPTI_TYPE_ZERO_BYTE
7289 | OPTI_TYPE_PRECOMPUTE_INIT
7290 | OPTI_TYPE_PRECOMPUTE_MERKLE
7291 | OPTI_TYPE_EARLY_SKIP
7292 | OPTI_TYPE_NOT_ITERATED;
7293 dgst_pos0 = 0;
7294 dgst_pos1 = 3;
7295 dgst_pos2 = 2;
7296 dgst_pos3 = 1;
7297 break;
7298
7299 case 1400: hash_type = HASH_TYPE_SHA256;
7300 salt_type = SALT_TYPE_NONE;
7301 attack_exec = ATTACK_EXEC_ON_GPU;
7302 opts_type = OPTS_TYPE_PT_GENERATE_BE
7303 | OPTS_TYPE_PT_ADD80
7304 | OPTS_TYPE_PT_ADDBITS15;
7305 kern_type = KERN_TYPE_SHA256;
7306 dgst_size = DGST_SIZE_4_8;
7307 parse_func = sha256_parse_hash;
7308 sort_by_digest = sort_by_digest_4_8;
7309 opti_type = OPTI_TYPE_ZERO_BYTE
7310 | OPTI_TYPE_PRECOMPUTE_INIT
7311 | OPTI_TYPE_PRECOMPUTE_MERKLE
7312 | OPTI_TYPE_EARLY_SKIP
7313 | OPTI_TYPE_NOT_ITERATED
7314 | OPTI_TYPE_NOT_SALTED
7315 | OPTI_TYPE_RAW_HASH;
7316 dgst_pos0 = 3;
7317 dgst_pos1 = 7;
7318 dgst_pos2 = 2;
7319 dgst_pos3 = 6;
7320 break;
7321
7322 case 1410: hash_type = HASH_TYPE_SHA256;
7323 salt_type = SALT_TYPE_INTERN;
7324 attack_exec = ATTACK_EXEC_ON_GPU;
7325 opts_type = OPTS_TYPE_PT_GENERATE_BE
7326 | OPTS_TYPE_ST_ADD80
7327 | OPTS_TYPE_ST_ADDBITS15;
7328 kern_type = KERN_TYPE_SHA256_PWSLT;
7329 dgst_size = DGST_SIZE_4_8;
7330 parse_func = sha256s_parse_hash;
7331 sort_by_digest = sort_by_digest_4_8;
7332 opti_type = OPTI_TYPE_ZERO_BYTE
7333 | OPTI_TYPE_PRECOMPUTE_INIT
7334 | OPTI_TYPE_PRECOMPUTE_MERKLE
7335 | OPTI_TYPE_EARLY_SKIP
7336 | OPTI_TYPE_NOT_ITERATED
7337 | OPTI_TYPE_APPENDED_SALT
7338 | OPTI_TYPE_RAW_HASH;
7339 dgst_pos0 = 3;
7340 dgst_pos1 = 7;
7341 dgst_pos2 = 2;
7342 dgst_pos3 = 6;
7343 break;
7344
7345 case 1420: hash_type = HASH_TYPE_SHA256;
7346 salt_type = SALT_TYPE_INTERN;
7347 attack_exec = ATTACK_EXEC_ON_GPU;
7348 opts_type = OPTS_TYPE_PT_GENERATE_BE
7349 | OPTS_TYPE_PT_ADD80
7350 | OPTS_TYPE_PT_ADDBITS15;
7351 kern_type = KERN_TYPE_SHA256_SLTPW;
7352 dgst_size = DGST_SIZE_4_8;
7353 parse_func = sha256s_parse_hash;
7354 sort_by_digest = sort_by_digest_4_8;
7355 opti_type = OPTI_TYPE_ZERO_BYTE
7356 | OPTI_TYPE_PRECOMPUTE_INIT
7357 | OPTI_TYPE_PRECOMPUTE_MERKLE
7358 | OPTI_TYPE_EARLY_SKIP
7359 | OPTI_TYPE_NOT_ITERATED
7360 | OPTI_TYPE_PREPENDED_SALT
7361 | OPTI_TYPE_RAW_HASH;
7362 dgst_pos0 = 3;
7363 dgst_pos1 = 7;
7364 dgst_pos2 = 2;
7365 dgst_pos3 = 6;
7366 break;
7367
7368 case 1421: hash_type = HASH_TYPE_SHA256;
7369 salt_type = SALT_TYPE_EMBEDDED;
7370 attack_exec = ATTACK_EXEC_ON_GPU;
7371 opts_type = OPTS_TYPE_PT_GENERATE_BE
7372 | OPTS_TYPE_PT_ADD80
7373 | OPTS_TYPE_PT_ADDBITS15;
7374 kern_type = KERN_TYPE_SHA256_SLTPW;
7375 dgst_size = DGST_SIZE_4_8;
7376 parse_func = hmailserver_parse_hash;
7377 sort_by_digest = sort_by_digest_4_8;
7378 opti_type = OPTI_TYPE_ZERO_BYTE
7379 | OPTI_TYPE_PRECOMPUTE_INIT
7380 | OPTI_TYPE_PRECOMPUTE_MERKLE
7381 | OPTI_TYPE_EARLY_SKIP
7382 | OPTI_TYPE_NOT_ITERATED
7383 | OPTI_TYPE_PREPENDED_SALT
7384 | OPTI_TYPE_RAW_HASH;
7385 dgst_pos0 = 3;
7386 dgst_pos1 = 7;
7387 dgst_pos2 = 2;
7388 dgst_pos3 = 6;
7389 break;
7390
7391 case 1430: hash_type = HASH_TYPE_SHA256;
7392 salt_type = SALT_TYPE_INTERN;
7393 attack_exec = ATTACK_EXEC_ON_GPU;
7394 opts_type = OPTS_TYPE_PT_GENERATE_BE
7395 | OPTS_TYPE_PT_UNICODE
7396 | OPTS_TYPE_ST_ADD80
7397 | OPTS_TYPE_ST_ADDBITS15;
7398 kern_type = KERN_TYPE_SHA256_PWUSLT;
7399 dgst_size = DGST_SIZE_4_8;
7400 parse_func = sha256s_parse_hash;
7401 sort_by_digest = sort_by_digest_4_8;
7402 opti_type = OPTI_TYPE_ZERO_BYTE
7403 | OPTI_TYPE_PRECOMPUTE_INIT
7404 | OPTI_TYPE_PRECOMPUTE_MERKLE
7405 | OPTI_TYPE_EARLY_SKIP
7406 | OPTI_TYPE_NOT_ITERATED
7407 | OPTI_TYPE_APPENDED_SALT
7408 | OPTI_TYPE_RAW_HASH;
7409 dgst_pos0 = 3;
7410 dgst_pos1 = 7;
7411 dgst_pos2 = 2;
7412 dgst_pos3 = 6;
7413 break;
7414
7415 case 1440: hash_type = HASH_TYPE_SHA256;
7416 salt_type = SALT_TYPE_INTERN;
7417 attack_exec = ATTACK_EXEC_ON_GPU;
7418 opts_type = OPTS_TYPE_PT_GENERATE_BE
7419 | OPTS_TYPE_PT_ADD80
7420 | OPTS_TYPE_PT_ADDBITS15
7421 | OPTS_TYPE_PT_UNICODE;
7422 kern_type = KERN_TYPE_SHA256_SLTPWU;
7423 dgst_size = DGST_SIZE_4_8;
7424 parse_func = sha256s_parse_hash;
7425 sort_by_digest = sort_by_digest_4_8;
7426 opti_type = OPTI_TYPE_ZERO_BYTE
7427 | OPTI_TYPE_PRECOMPUTE_INIT
7428 | OPTI_TYPE_PRECOMPUTE_MERKLE
7429 | OPTI_TYPE_EARLY_SKIP
7430 | OPTI_TYPE_NOT_ITERATED
7431 | OPTI_TYPE_PREPENDED_SALT
7432 | OPTI_TYPE_RAW_HASH;
7433 dgst_pos0 = 3;
7434 dgst_pos1 = 7;
7435 dgst_pos2 = 2;
7436 dgst_pos3 = 6;
7437 break;
7438
7439 case 1441: hash_type = HASH_TYPE_SHA256;
7440 salt_type = SALT_TYPE_EMBEDDED;
7441 attack_exec = ATTACK_EXEC_ON_GPU;
7442 opts_type = OPTS_TYPE_PT_GENERATE_BE
7443 | OPTS_TYPE_PT_ADD80
7444 | OPTS_TYPE_PT_ADDBITS15
7445 | OPTS_TYPE_PT_UNICODE
7446 | OPTS_TYPE_ST_BASE64;
7447 kern_type = KERN_TYPE_SHA256_SLTPWU;
7448 dgst_size = DGST_SIZE_4_8;
7449 parse_func = episerver4_parse_hash;
7450 sort_by_digest = sort_by_digest_4_8;
7451 opti_type = OPTI_TYPE_ZERO_BYTE
7452 | OPTI_TYPE_PRECOMPUTE_INIT
7453 | OPTI_TYPE_PRECOMPUTE_MERKLE
7454 | OPTI_TYPE_EARLY_SKIP
7455 | OPTI_TYPE_NOT_ITERATED
7456 | OPTI_TYPE_PREPENDED_SALT
7457 | OPTI_TYPE_RAW_HASH;
7458 dgst_pos0 = 3;
7459 dgst_pos1 = 7;
7460 dgst_pos2 = 2;
7461 dgst_pos3 = 6;
7462 break;
7463
7464 case 1450: hash_type = HASH_TYPE_SHA256;
7465 salt_type = SALT_TYPE_INTERN;
7466 attack_exec = ATTACK_EXEC_ON_GPU;
7467 opts_type = OPTS_TYPE_PT_GENERATE_BE
7468 | OPTS_TYPE_ST_ADD80;
7469 kern_type = KERN_TYPE_HMACSHA256_PW;
7470 dgst_size = DGST_SIZE_4_8;
7471 parse_func = hmacsha256_parse_hash;
7472 sort_by_digest = sort_by_digest_4_8;
7473 opti_type = OPTI_TYPE_ZERO_BYTE
7474 | OPTI_TYPE_NOT_ITERATED;
7475 dgst_pos0 = 3;
7476 dgst_pos1 = 7;
7477 dgst_pos2 = 2;
7478 dgst_pos3 = 6;
7479 break;
7480
7481 case 1460: hash_type = HASH_TYPE_SHA256;
7482 salt_type = SALT_TYPE_INTERN;
7483 attack_exec = ATTACK_EXEC_ON_GPU;
7484 opts_type = OPTS_TYPE_PT_GENERATE_BE
7485 | OPTS_TYPE_PT_ADD80
7486 | OPTS_TYPE_PT_ADDBITS15;
7487 kern_type = KERN_TYPE_HMACSHA256_SLT;
7488 dgst_size = DGST_SIZE_4_8;
7489 parse_func = hmacsha256_parse_hash;
7490 sort_by_digest = sort_by_digest_4_8;
7491 opti_type = OPTI_TYPE_ZERO_BYTE
7492 | OPTI_TYPE_NOT_ITERATED;
7493 dgst_pos0 = 3;
7494 dgst_pos1 = 7;
7495 dgst_pos2 = 2;
7496 dgst_pos3 = 6;
7497 break;
7498
7499 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7500 salt_type = SALT_TYPE_EMBEDDED;
7501 attack_exec = ATTACK_EXEC_ON_GPU;
7502 opts_type = OPTS_TYPE_PT_GENERATE_LE
7503 | OPTS_TYPE_PT_BITSLICE;
7504 kern_type = KERN_TYPE_DESCRYPT;
7505 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7506 parse_func = descrypt_parse_hash;
7507 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7508 opti_type = OPTI_TYPE_ZERO_BYTE
7509 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7510 dgst_pos0 = 0;
7511 dgst_pos1 = 1;
7512 dgst_pos2 = 2;
7513 dgst_pos3 = 3;
7514 break;
7515
7516 case 1600: hash_type = HASH_TYPE_MD5;
7517 salt_type = SALT_TYPE_EMBEDDED;
7518 attack_exec = ATTACK_EXEC_ON_CPU;
7519 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7520 kern_type = KERN_TYPE_APR1CRYPT;
7521 dgst_size = DGST_SIZE_4_4;
7522 parse_func = md5apr1_parse_hash;
7523 sort_by_digest = sort_by_digest_4_4;
7524 opti_type = OPTI_TYPE_ZERO_BYTE;
7525 dgst_pos0 = 0;
7526 dgst_pos1 = 1;
7527 dgst_pos2 = 2;
7528 dgst_pos3 = 3;
7529 break;
7530
7531 case 1700: hash_type = HASH_TYPE_SHA512;
7532 salt_type = SALT_TYPE_NONE;
7533 attack_exec = ATTACK_EXEC_ON_GPU;
7534 opts_type = OPTS_TYPE_PT_GENERATE_BE
7535 | OPTS_TYPE_PT_ADD80
7536 | OPTS_TYPE_PT_ADDBITS15;
7537 kern_type = KERN_TYPE_SHA512;
7538 dgst_size = DGST_SIZE_8_8;
7539 parse_func = sha512_parse_hash;
7540 sort_by_digest = sort_by_digest_8_8;
7541 opti_type = OPTI_TYPE_ZERO_BYTE
7542 | OPTI_TYPE_PRECOMPUTE_INIT
7543 | OPTI_TYPE_PRECOMPUTE_MERKLE
7544 | OPTI_TYPE_EARLY_SKIP
7545 | OPTI_TYPE_NOT_ITERATED
7546 | OPTI_TYPE_NOT_SALTED
7547 | OPTI_TYPE_RAW_HASH;
7548 dgst_pos0 = 14;
7549 dgst_pos1 = 15;
7550 dgst_pos2 = 6;
7551 dgst_pos3 = 7;
7552 break;
7553
7554 case 1710: hash_type = HASH_TYPE_SHA512;
7555 salt_type = SALT_TYPE_INTERN;
7556 attack_exec = ATTACK_EXEC_ON_GPU;
7557 opts_type = OPTS_TYPE_PT_GENERATE_BE
7558 | OPTS_TYPE_ST_ADD80
7559 | OPTS_TYPE_ST_ADDBITS15;
7560 kern_type = KERN_TYPE_SHA512_PWSLT;
7561 dgst_size = DGST_SIZE_8_8;
7562 parse_func = sha512s_parse_hash;
7563 sort_by_digest = sort_by_digest_8_8;
7564 opti_type = OPTI_TYPE_ZERO_BYTE
7565 | OPTI_TYPE_PRECOMPUTE_INIT
7566 | OPTI_TYPE_PRECOMPUTE_MERKLE
7567 | OPTI_TYPE_EARLY_SKIP
7568 | OPTI_TYPE_NOT_ITERATED
7569 | OPTI_TYPE_APPENDED_SALT
7570 | OPTI_TYPE_RAW_HASH;
7571 dgst_pos0 = 14;
7572 dgst_pos1 = 15;
7573 dgst_pos2 = 6;
7574 dgst_pos3 = 7;
7575 break;
7576
7577 case 1711: hash_type = HASH_TYPE_SHA512;
7578 salt_type = SALT_TYPE_EMBEDDED;
7579 attack_exec = ATTACK_EXEC_ON_GPU;
7580 opts_type = OPTS_TYPE_PT_GENERATE_BE
7581 | OPTS_TYPE_ST_ADD80
7582 | OPTS_TYPE_ST_ADDBITS15;
7583 kern_type = KERN_TYPE_SHA512_PWSLT;
7584 dgst_size = DGST_SIZE_8_8;
7585 parse_func = sha512b64s_parse_hash;
7586 sort_by_digest = sort_by_digest_8_8;
7587 opti_type = OPTI_TYPE_ZERO_BYTE
7588 | OPTI_TYPE_PRECOMPUTE_INIT
7589 | OPTI_TYPE_PRECOMPUTE_MERKLE
7590 | OPTI_TYPE_EARLY_SKIP
7591 | OPTI_TYPE_NOT_ITERATED
7592 | OPTI_TYPE_APPENDED_SALT
7593 | OPTI_TYPE_RAW_HASH;
7594 dgst_pos0 = 14;
7595 dgst_pos1 = 15;
7596 dgst_pos2 = 6;
7597 dgst_pos3 = 7;
7598 break;
7599
7600 case 1720: hash_type = HASH_TYPE_SHA512;
7601 salt_type = SALT_TYPE_INTERN;
7602 attack_exec = ATTACK_EXEC_ON_GPU;
7603 opts_type = OPTS_TYPE_PT_GENERATE_BE
7604 | OPTS_TYPE_PT_ADD80
7605 | OPTS_TYPE_PT_ADDBITS15;
7606 kern_type = KERN_TYPE_SHA512_SLTPW;
7607 dgst_size = DGST_SIZE_8_8;
7608 parse_func = sha512s_parse_hash;
7609 sort_by_digest = sort_by_digest_8_8;
7610 opti_type = OPTI_TYPE_ZERO_BYTE
7611 | OPTI_TYPE_PRECOMPUTE_INIT
7612 | OPTI_TYPE_PRECOMPUTE_MERKLE
7613 | OPTI_TYPE_EARLY_SKIP
7614 | OPTI_TYPE_NOT_ITERATED
7615 | OPTI_TYPE_PREPENDED_SALT
7616 | OPTI_TYPE_RAW_HASH;
7617 dgst_pos0 = 14;
7618 dgst_pos1 = 15;
7619 dgst_pos2 = 6;
7620 dgst_pos3 = 7;
7621 break;
7622
7623 case 1722: hash_type = HASH_TYPE_SHA512;
7624 salt_type = SALT_TYPE_EMBEDDED;
7625 attack_exec = ATTACK_EXEC_ON_GPU;
7626 opts_type = OPTS_TYPE_PT_GENERATE_BE
7627 | OPTS_TYPE_PT_ADD80
7628 | OPTS_TYPE_PT_ADDBITS15
7629 | OPTS_TYPE_ST_HEX;
7630 kern_type = KERN_TYPE_SHA512_SLTPW;
7631 dgst_size = DGST_SIZE_8_8;
7632 parse_func = osx512_parse_hash;
7633 sort_by_digest = sort_by_digest_8_8;
7634 opti_type = OPTI_TYPE_ZERO_BYTE
7635 | OPTI_TYPE_PRECOMPUTE_INIT
7636 | OPTI_TYPE_PRECOMPUTE_MERKLE
7637 | OPTI_TYPE_EARLY_SKIP
7638 | OPTI_TYPE_NOT_ITERATED
7639 | OPTI_TYPE_PREPENDED_SALT
7640 | OPTI_TYPE_RAW_HASH;
7641 dgst_pos0 = 14;
7642 dgst_pos1 = 15;
7643 dgst_pos2 = 6;
7644 dgst_pos3 = 7;
7645 break;
7646
7647 case 1730: hash_type = HASH_TYPE_SHA512;
7648 salt_type = SALT_TYPE_INTERN;
7649 attack_exec = ATTACK_EXEC_ON_GPU;
7650 opts_type = OPTS_TYPE_PT_GENERATE_BE
7651 | OPTS_TYPE_PT_UNICODE
7652 | OPTS_TYPE_ST_ADD80
7653 | OPTS_TYPE_ST_ADDBITS15;
7654 kern_type = KERN_TYPE_SHA512_PWSLTU;
7655 dgst_size = DGST_SIZE_8_8;
7656 parse_func = sha512s_parse_hash;
7657 sort_by_digest = sort_by_digest_8_8;
7658 opti_type = OPTI_TYPE_ZERO_BYTE
7659 | OPTI_TYPE_PRECOMPUTE_INIT
7660 | OPTI_TYPE_PRECOMPUTE_MERKLE
7661 | OPTI_TYPE_EARLY_SKIP
7662 | OPTI_TYPE_NOT_ITERATED
7663 | OPTI_TYPE_APPENDED_SALT
7664 | OPTI_TYPE_RAW_HASH;
7665 dgst_pos0 = 14;
7666 dgst_pos1 = 15;
7667 dgst_pos2 = 6;
7668 dgst_pos3 = 7;
7669 break;
7670
7671 case 1731: hash_type = HASH_TYPE_SHA512;
7672 salt_type = SALT_TYPE_EMBEDDED;
7673 attack_exec = ATTACK_EXEC_ON_GPU;
7674 opts_type = OPTS_TYPE_PT_GENERATE_BE
7675 | OPTS_TYPE_PT_UNICODE
7676 | OPTS_TYPE_ST_ADD80
7677 | OPTS_TYPE_ST_ADDBITS15
7678 | OPTS_TYPE_ST_HEX;
7679 kern_type = KERN_TYPE_SHA512_PWSLTU;
7680 dgst_size = DGST_SIZE_8_8;
7681 parse_func = mssql2012_parse_hash;
7682 sort_by_digest = sort_by_digest_8_8;
7683 opti_type = OPTI_TYPE_ZERO_BYTE
7684 | OPTI_TYPE_PRECOMPUTE_INIT
7685 | OPTI_TYPE_PRECOMPUTE_MERKLE
7686 | OPTI_TYPE_EARLY_SKIP
7687 | OPTI_TYPE_NOT_ITERATED
7688 | OPTI_TYPE_APPENDED_SALT
7689 | OPTI_TYPE_RAW_HASH;
7690 dgst_pos0 = 14;
7691 dgst_pos1 = 15;
7692 dgst_pos2 = 6;
7693 dgst_pos3 = 7;
7694 break;
7695
7696 case 1740: hash_type = HASH_TYPE_SHA512;
7697 salt_type = SALT_TYPE_INTERN;
7698 attack_exec = ATTACK_EXEC_ON_GPU;
7699 opts_type = OPTS_TYPE_PT_GENERATE_BE
7700 | OPTS_TYPE_PT_ADD80
7701 | OPTS_TYPE_PT_ADDBITS15
7702 | OPTS_TYPE_PT_UNICODE;
7703 kern_type = KERN_TYPE_SHA512_SLTPWU;
7704 dgst_size = DGST_SIZE_8_8;
7705 parse_func = sha512s_parse_hash;
7706 sort_by_digest = sort_by_digest_8_8;
7707 opti_type = OPTI_TYPE_ZERO_BYTE
7708 | OPTI_TYPE_PRECOMPUTE_INIT
7709 | OPTI_TYPE_PRECOMPUTE_MERKLE
7710 | OPTI_TYPE_EARLY_SKIP
7711 | OPTI_TYPE_NOT_ITERATED
7712 | OPTI_TYPE_PREPENDED_SALT
7713 | OPTI_TYPE_RAW_HASH;
7714 dgst_pos0 = 14;
7715 dgst_pos1 = 15;
7716 dgst_pos2 = 6;
7717 dgst_pos3 = 7;
7718 break;
7719
7720 case 1750: hash_type = HASH_TYPE_SHA512;
7721 salt_type = SALT_TYPE_INTERN;
7722 attack_exec = ATTACK_EXEC_ON_GPU;
7723 opts_type = OPTS_TYPE_PT_GENERATE_BE
7724 | OPTS_TYPE_ST_ADD80;
7725 kern_type = KERN_TYPE_HMACSHA512_PW;
7726 dgst_size = DGST_SIZE_8_8;
7727 parse_func = hmacsha512_parse_hash;
7728 sort_by_digest = sort_by_digest_8_8;
7729 opti_type = OPTI_TYPE_ZERO_BYTE
7730 | OPTI_TYPE_NOT_ITERATED;
7731 dgst_pos0 = 14;
7732 dgst_pos1 = 15;
7733 dgst_pos2 = 6;
7734 dgst_pos3 = 7;
7735 break;
7736
7737 case 1760: hash_type = HASH_TYPE_SHA512;
7738 salt_type = SALT_TYPE_INTERN;
7739 attack_exec = ATTACK_EXEC_ON_GPU;
7740 opts_type = OPTS_TYPE_PT_GENERATE_BE
7741 | OPTS_TYPE_PT_ADD80
7742 | OPTS_TYPE_PT_ADDBITS15;
7743 kern_type = KERN_TYPE_HMACSHA512_SLT;
7744 dgst_size = DGST_SIZE_8_8;
7745 parse_func = hmacsha512_parse_hash;
7746 sort_by_digest = sort_by_digest_8_8;
7747 opti_type = OPTI_TYPE_ZERO_BYTE
7748 | OPTI_TYPE_NOT_ITERATED;
7749 dgst_pos0 = 14;
7750 dgst_pos1 = 15;
7751 dgst_pos2 = 6;
7752 dgst_pos3 = 7;
7753 break;
7754
7755 case 1800: hash_type = HASH_TYPE_SHA512;
7756 salt_type = SALT_TYPE_EMBEDDED;
7757 attack_exec = ATTACK_EXEC_ON_CPU;
7758 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7759 kern_type = KERN_TYPE_SHA512CRYPT;
7760 dgst_size = DGST_SIZE_8_8;
7761 parse_func = sha512crypt_parse_hash;
7762 sort_by_digest = sort_by_digest_8_8;
7763 opti_type = OPTI_TYPE_ZERO_BYTE;
7764 dgst_pos0 = 0;
7765 dgst_pos1 = 1;
7766 dgst_pos2 = 2;
7767 dgst_pos3 = 3;
7768 break;
7769
7770 case 2100: hash_type = HASH_TYPE_DCC2;
7771 salt_type = SALT_TYPE_EMBEDDED;
7772 attack_exec = ATTACK_EXEC_ON_CPU;
7773 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
7774 | OPTS_TYPE_ST_LOWER
7775 | OPTS_TYPE_ST_UNICODE;
7776 kern_type = KERN_TYPE_DCC2;
7777 dgst_size = DGST_SIZE_4_4;
7778 parse_func = dcc2_parse_hash;
7779 sort_by_digest = sort_by_digest_4_4;
7780 opti_type = OPTI_TYPE_ZERO_BYTE;
7781 dgst_pos0 = 0;
7782 dgst_pos1 = 1;
7783 dgst_pos2 = 2;
7784 dgst_pos3 = 3;
7785 break;
7786
7787 case 2400: hash_type = HASH_TYPE_MD5;
7788 salt_type = SALT_TYPE_NONE;
7789 attack_exec = ATTACK_EXEC_ON_GPU;
7790 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7791 kern_type = KERN_TYPE_MD5PIX;
7792 dgst_size = DGST_SIZE_4_4;
7793 parse_func = md5pix_parse_hash;
7794 sort_by_digest = sort_by_digest_4_4;
7795 opti_type = OPTI_TYPE_ZERO_BYTE
7796 | OPTI_TYPE_PRECOMPUTE_INIT
7797 | OPTI_TYPE_PRECOMPUTE_MERKLE
7798 | OPTI_TYPE_EARLY_SKIP
7799 | OPTI_TYPE_NOT_ITERATED
7800 | OPTI_TYPE_NOT_SALTED;
7801 dgst_pos0 = 0;
7802 dgst_pos1 = 3;
7803 dgst_pos2 = 2;
7804 dgst_pos3 = 1;
7805 break;
7806
7807 case 2410: hash_type = HASH_TYPE_MD5;
7808 salt_type = SALT_TYPE_INTERN;
7809 attack_exec = ATTACK_EXEC_ON_GPU;
7810 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7811 kern_type = KERN_TYPE_MD5ASA;
7812 dgst_size = DGST_SIZE_4_4;
7813 parse_func = md5asa_parse_hash;
7814 sort_by_digest = sort_by_digest_4_4;
7815 opti_type = OPTI_TYPE_ZERO_BYTE
7816 | OPTI_TYPE_PRECOMPUTE_INIT
7817 | OPTI_TYPE_PRECOMPUTE_MERKLE
7818 | OPTI_TYPE_EARLY_SKIP
7819 | OPTI_TYPE_NOT_ITERATED;
7820 dgst_pos0 = 0;
7821 dgst_pos1 = 3;
7822 dgst_pos2 = 2;
7823 dgst_pos3 = 1;
7824 break;
7825
7826 case 2500: hash_type = HASH_TYPE_WPA;
7827 salt_type = SALT_TYPE_EMBEDDED;
7828 attack_exec = ATTACK_EXEC_ON_CPU;
7829 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7830 kern_type = KERN_TYPE_WPA;
7831 dgst_size = DGST_SIZE_4_4;
7832 parse_func = wpa_parse_hash;
7833 sort_by_digest = sort_by_digest_4_4;
7834 opti_type = OPTI_TYPE_ZERO_BYTE;
7835 dgst_pos0 = 0;
7836 dgst_pos1 = 1;
7837 dgst_pos2 = 2;
7838 dgst_pos3 = 3;
7839 break;
7840
7841 case 2600: hash_type = HASH_TYPE_MD5;
7842 salt_type = SALT_TYPE_VIRTUAL;
7843 attack_exec = ATTACK_EXEC_ON_GPU;
7844 opts_type = OPTS_TYPE_PT_GENERATE_LE
7845 | OPTS_TYPE_PT_ADD80
7846 | OPTS_TYPE_PT_ADDBITS14
7847 | OPTS_TYPE_ST_ADD80;
7848 kern_type = KERN_TYPE_MD55_PWSLT1;
7849 dgst_size = DGST_SIZE_4_4;
7850 parse_func = md5md5_parse_hash;
7851 sort_by_digest = sort_by_digest_4_4;
7852 opti_type = OPTI_TYPE_ZERO_BYTE
7853 | OPTI_TYPE_PRECOMPUTE_INIT
7854 | OPTI_TYPE_PRECOMPUTE_MERKLE
7855 | OPTI_TYPE_EARLY_SKIP;
7856 dgst_pos0 = 0;
7857 dgst_pos1 = 3;
7858 dgst_pos2 = 2;
7859 dgst_pos3 = 1;
7860 break;
7861
7862 case 2611: hash_type = HASH_TYPE_MD5;
7863 salt_type = SALT_TYPE_INTERN;
7864 attack_exec = ATTACK_EXEC_ON_GPU;
7865 opts_type = OPTS_TYPE_PT_GENERATE_LE
7866 | OPTS_TYPE_PT_ADD80
7867 | OPTS_TYPE_PT_ADDBITS14
7868 | OPTS_TYPE_ST_ADD80;
7869 kern_type = KERN_TYPE_MD55_PWSLT1;
7870 dgst_size = DGST_SIZE_4_4;
7871 parse_func = vb3_parse_hash;
7872 sort_by_digest = sort_by_digest_4_4;
7873 opti_type = OPTI_TYPE_ZERO_BYTE
7874 | OPTI_TYPE_PRECOMPUTE_INIT
7875 | OPTI_TYPE_PRECOMPUTE_MERKLE
7876 | OPTI_TYPE_EARLY_SKIP;
7877 dgst_pos0 = 0;
7878 dgst_pos1 = 3;
7879 dgst_pos2 = 2;
7880 dgst_pos3 = 1;
7881 break;
7882
7883 case 2612: hash_type = HASH_TYPE_MD5;
7884 salt_type = SALT_TYPE_EMBEDDED;
7885 attack_exec = ATTACK_EXEC_ON_GPU;
7886 opts_type = OPTS_TYPE_PT_GENERATE_LE
7887 | OPTS_TYPE_PT_ADD80
7888 | OPTS_TYPE_PT_ADDBITS14
7889 | OPTS_TYPE_ST_ADD80
7890 | OPTS_TYPE_ST_HEX;
7891 kern_type = KERN_TYPE_MD55_PWSLT1;
7892 dgst_size = DGST_SIZE_4_4;
7893 parse_func = phps_parse_hash;
7894 sort_by_digest = sort_by_digest_4_4;
7895 opti_type = OPTI_TYPE_ZERO_BYTE
7896 | OPTI_TYPE_PRECOMPUTE_INIT
7897 | OPTI_TYPE_PRECOMPUTE_MERKLE
7898 | OPTI_TYPE_EARLY_SKIP;
7899 dgst_pos0 = 0;
7900 dgst_pos1 = 3;
7901 dgst_pos2 = 2;
7902 dgst_pos3 = 1;
7903 break;
7904
7905 case 2711: hash_type = HASH_TYPE_MD5;
7906 salt_type = SALT_TYPE_INTERN;
7907 attack_exec = ATTACK_EXEC_ON_GPU;
7908 opts_type = OPTS_TYPE_PT_GENERATE_LE
7909 | OPTS_TYPE_PT_ADD80
7910 | OPTS_TYPE_PT_ADDBITS14
7911 | OPTS_TYPE_ST_ADD80;
7912 kern_type = KERN_TYPE_MD55_PWSLT2;
7913 dgst_size = DGST_SIZE_4_4;
7914 parse_func = vb30_parse_hash;
7915 sort_by_digest = sort_by_digest_4_4;
7916 opti_type = OPTI_TYPE_ZERO_BYTE
7917 | OPTI_TYPE_PRECOMPUTE_INIT
7918 | OPTI_TYPE_EARLY_SKIP;
7919 dgst_pos0 = 0;
7920 dgst_pos1 = 3;
7921 dgst_pos2 = 2;
7922 dgst_pos3 = 1;
7923 break;
7924
7925 case 2811: hash_type = HASH_TYPE_MD5;
7926 salt_type = SALT_TYPE_INTERN;
7927 attack_exec = ATTACK_EXEC_ON_GPU;
7928 opts_type = OPTS_TYPE_PT_GENERATE_LE
7929 | OPTS_TYPE_PT_ADD80
7930 | OPTS_TYPE_PT_ADDBITS14;
7931 kern_type = KERN_TYPE_MD55_SLTPW;
7932 dgst_size = DGST_SIZE_4_4;
7933 parse_func = ipb2_parse_hash;
7934 sort_by_digest = sort_by_digest_4_4;
7935 opti_type = OPTI_TYPE_ZERO_BYTE
7936 | OPTI_TYPE_PRECOMPUTE_INIT
7937 | OPTI_TYPE_EARLY_SKIP;
7938 dgst_pos0 = 0;
7939 dgst_pos1 = 3;
7940 dgst_pos2 = 2;
7941 dgst_pos3 = 1;
7942 break;
7943
7944 case 3000: hash_type = HASH_TYPE_LM;
7945 salt_type = SALT_TYPE_NONE;
7946 attack_exec = ATTACK_EXEC_ON_GPU;
7947 opts_type = OPTS_TYPE_PT_GENERATE_LE
7948 | OPTS_TYPE_PT_UPPER
7949 | OPTS_TYPE_PT_BITSLICE;
7950 kern_type = KERN_TYPE_LM;
7951 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7952 parse_func = lm_parse_hash;
7953 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7954 opti_type = OPTI_TYPE_ZERO_BYTE
7955 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7956 dgst_pos0 = 0;
7957 dgst_pos1 = 1;
7958 dgst_pos2 = 2;
7959 dgst_pos3 = 3;
7960 break;
7961
7962 case 3100: hash_type = HASH_TYPE_ORACLEH;
7963 salt_type = SALT_TYPE_INTERN;
7964 attack_exec = ATTACK_EXEC_ON_GPU;
7965 opts_type = OPTS_TYPE_PT_GENERATE_LE
7966 | OPTS_TYPE_PT_UPPER
7967 | OPTS_TYPE_ST_UPPER;
7968 kern_type = KERN_TYPE_ORACLEH;
7969 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7970 parse_func = oracleh_parse_hash;
7971 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7972 opti_type = OPTI_TYPE_ZERO_BYTE;
7973 dgst_pos0 = 0;
7974 dgst_pos1 = 1;
7975 dgst_pos2 = 2;
7976 dgst_pos3 = 3;
7977 break;
7978
7979 case 3200: hash_type = HASH_TYPE_BCRYPT;
7980 salt_type = SALT_TYPE_EMBEDDED;
7981 attack_exec = ATTACK_EXEC_ON_CPU;
7982 opts_type = OPTS_TYPE_PT_GENERATE_LE
7983 | OPTS_TYPE_ST_GENERATE_LE;
7984 kern_type = KERN_TYPE_BCRYPT;
7985 dgst_size = DGST_SIZE_4_6;
7986 parse_func = bcrypt_parse_hash;
7987 sort_by_digest = sort_by_digest_4_6;
7988 opti_type = OPTI_TYPE_ZERO_BYTE;
7989 dgst_pos0 = 0;
7990 dgst_pos1 = 1;
7991 dgst_pos2 = 2;
7992 dgst_pos3 = 3;
7993 break;
7994
7995 case 3710: hash_type = HASH_TYPE_MD5;
7996 salt_type = SALT_TYPE_INTERN;
7997 attack_exec = ATTACK_EXEC_ON_GPU;
7998 opts_type = OPTS_TYPE_PT_GENERATE_LE
7999 | OPTS_TYPE_PT_ADD80
8000 | OPTS_TYPE_PT_ADDBITS14;
8001 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8002 dgst_size = DGST_SIZE_4_4;
8003 parse_func = md5s_parse_hash;
8004 sort_by_digest = sort_by_digest_4_4;
8005 opti_type = OPTI_TYPE_ZERO_BYTE
8006 | OPTI_TYPE_PRECOMPUTE_INIT
8007 | OPTI_TYPE_PRECOMPUTE_MERKLE
8008 | OPTI_TYPE_EARLY_SKIP;
8009 dgst_pos0 = 0;
8010 dgst_pos1 = 3;
8011 dgst_pos2 = 2;
8012 dgst_pos3 = 1;
8013 break;
8014
8015 case 3711: hash_type = HASH_TYPE_MD5;
8016 salt_type = SALT_TYPE_EMBEDDED;
8017 attack_exec = ATTACK_EXEC_ON_GPU;
8018 opts_type = OPTS_TYPE_PT_GENERATE_LE
8019 | OPTS_TYPE_PT_ADD80
8020 | OPTS_TYPE_PT_ADDBITS14;
8021 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8022 dgst_size = DGST_SIZE_4_4;
8023 parse_func = mediawiki_b_parse_hash;
8024 sort_by_digest = sort_by_digest_4_4;
8025 opti_type = OPTI_TYPE_ZERO_BYTE
8026 | OPTI_TYPE_PRECOMPUTE_INIT
8027 | OPTI_TYPE_PRECOMPUTE_MERKLE
8028 | OPTI_TYPE_EARLY_SKIP;
8029 dgst_pos0 = 0;
8030 dgst_pos1 = 3;
8031 dgst_pos2 = 2;
8032 dgst_pos3 = 1;
8033 break;
8034
8035 case 3800: hash_type = HASH_TYPE_MD5;
8036 salt_type = SALT_TYPE_INTERN;
8037 attack_exec = ATTACK_EXEC_ON_GPU;
8038 opts_type = OPTS_TYPE_PT_GENERATE_LE
8039 | OPTS_TYPE_ST_ADDBITS14;
8040 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8041 dgst_size = DGST_SIZE_4_4;
8042 parse_func = md5s_parse_hash;
8043 sort_by_digest = sort_by_digest_4_4;
8044 opti_type = OPTI_TYPE_ZERO_BYTE
8045 | OPTI_TYPE_PRECOMPUTE_INIT
8046 | OPTI_TYPE_PRECOMPUTE_MERKLE
8047 | OPTI_TYPE_EARLY_SKIP
8048 | OPTI_TYPE_NOT_ITERATED
8049 | OPTI_TYPE_RAW_HASH;
8050 dgst_pos0 = 0;
8051 dgst_pos1 = 3;
8052 dgst_pos2 = 2;
8053 dgst_pos3 = 1;
8054 break;
8055
8056 case 4300: hash_type = HASH_TYPE_MD5;
8057 salt_type = SALT_TYPE_VIRTUAL;
8058 attack_exec = ATTACK_EXEC_ON_GPU;
8059 opts_type = OPTS_TYPE_PT_GENERATE_LE
8060 | OPTS_TYPE_PT_ADD80
8061 | OPTS_TYPE_PT_ADDBITS14
8062 | OPTS_TYPE_ST_ADD80;
8063 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8064 dgst_size = DGST_SIZE_4_4;
8065 parse_func = md5md5_parse_hash;
8066 sort_by_digest = sort_by_digest_4_4;
8067 opti_type = OPTI_TYPE_ZERO_BYTE
8068 | OPTI_TYPE_PRECOMPUTE_INIT
8069 | OPTI_TYPE_PRECOMPUTE_MERKLE
8070 | OPTI_TYPE_EARLY_SKIP;
8071 dgst_pos0 = 0;
8072 dgst_pos1 = 3;
8073 dgst_pos2 = 2;
8074 dgst_pos3 = 1;
8075 break;
8076
8077
8078 case 4400: hash_type = HASH_TYPE_MD5;
8079 salt_type = SALT_TYPE_NONE;
8080 attack_exec = ATTACK_EXEC_ON_GPU;
8081 opts_type = OPTS_TYPE_PT_GENERATE_BE
8082 | OPTS_TYPE_PT_ADD80
8083 | OPTS_TYPE_PT_ADDBITS15;
8084 kern_type = KERN_TYPE_MD5_SHA1;
8085 dgst_size = DGST_SIZE_4_4;
8086 parse_func = md5_parse_hash;
8087 sort_by_digest = sort_by_digest_4_4;
8088 opti_type = OPTI_TYPE_ZERO_BYTE
8089 | OPTI_TYPE_PRECOMPUTE_INIT
8090 | OPTI_TYPE_PRECOMPUTE_MERKLE
8091 | OPTI_TYPE_EARLY_SKIP
8092 | OPTI_TYPE_NOT_ITERATED
8093 | OPTI_TYPE_NOT_SALTED
8094 | OPTI_TYPE_RAW_HASH;
8095 dgst_pos0 = 0;
8096 dgst_pos1 = 3;
8097 dgst_pos2 = 2;
8098 dgst_pos3 = 1;
8099 break;
8100
8101 case 4500: hash_type = HASH_TYPE_SHA1;
8102 salt_type = SALT_TYPE_NONE;
8103 attack_exec = ATTACK_EXEC_ON_GPU;
8104 opts_type = OPTS_TYPE_PT_GENERATE_BE
8105 | OPTS_TYPE_PT_ADD80
8106 | OPTS_TYPE_PT_ADDBITS15;
8107 kern_type = KERN_TYPE_SHA11;
8108 dgst_size = DGST_SIZE_4_5;
8109 parse_func = sha1_parse_hash;
8110 sort_by_digest = sort_by_digest_4_5;
8111 opti_type = OPTI_TYPE_ZERO_BYTE
8112 | OPTI_TYPE_PRECOMPUTE_INIT
8113 | OPTI_TYPE_PRECOMPUTE_MERKLE
8114 | OPTI_TYPE_EARLY_SKIP
8115 | OPTI_TYPE_NOT_SALTED;
8116 dgst_pos0 = 3;
8117 dgst_pos1 = 4;
8118 dgst_pos2 = 2;
8119 dgst_pos3 = 1;
8120 break;
8121
8122 case 4700: hash_type = HASH_TYPE_SHA1;
8123 salt_type = SALT_TYPE_NONE;
8124 attack_exec = ATTACK_EXEC_ON_GPU;
8125 opts_type = OPTS_TYPE_PT_GENERATE_LE
8126 | OPTS_TYPE_PT_ADD80
8127 | OPTS_TYPE_PT_ADDBITS14;
8128 kern_type = KERN_TYPE_SHA1_MD5;
8129 dgst_size = DGST_SIZE_4_5;
8130 parse_func = sha1_parse_hash;
8131 sort_by_digest = sort_by_digest_4_5;
8132 opti_type = OPTI_TYPE_ZERO_BYTE
8133 | OPTI_TYPE_PRECOMPUTE_INIT
8134 | OPTI_TYPE_PRECOMPUTE_MERKLE
8135 | OPTI_TYPE_EARLY_SKIP
8136 | OPTI_TYPE_NOT_ITERATED
8137 | OPTI_TYPE_NOT_SALTED
8138 | OPTI_TYPE_RAW_HASH;
8139 dgst_pos0 = 3;
8140 dgst_pos1 = 4;
8141 dgst_pos2 = 2;
8142 dgst_pos3 = 1;
8143 break;
8144
8145 case 4800: hash_type = HASH_TYPE_MD5;
8146 salt_type = SALT_TYPE_EMBEDDED;
8147 attack_exec = ATTACK_EXEC_ON_GPU;
8148 opts_type = OPTS_TYPE_PT_GENERATE_LE
8149 | OPTS_TYPE_PT_ADDBITS14;
8150 kern_type = KERN_TYPE_MD5_CHAP;
8151 dgst_size = DGST_SIZE_4_4;
8152 parse_func = chap_parse_hash;
8153 sort_by_digest = sort_by_digest_4_4;
8154 opti_type = OPTI_TYPE_ZERO_BYTE
8155 | OPTI_TYPE_PRECOMPUTE_INIT
8156 | OPTI_TYPE_PRECOMPUTE_MERKLE
8157 | OPTI_TYPE_MEET_IN_MIDDLE
8158 | OPTI_TYPE_EARLY_SKIP
8159 | OPTI_TYPE_NOT_ITERATED
8160 | OPTI_TYPE_RAW_HASH;
8161 dgst_pos0 = 0;
8162 dgst_pos1 = 3;
8163 dgst_pos2 = 2;
8164 dgst_pos3 = 1;
8165 break;
8166
8167 case 4900: hash_type = HASH_TYPE_SHA1;
8168 salt_type = SALT_TYPE_INTERN;
8169 attack_exec = ATTACK_EXEC_ON_GPU;
8170 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8171 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8172 dgst_size = DGST_SIZE_4_5;
8173 parse_func = sha1s_parse_hash;
8174 sort_by_digest = sort_by_digest_4_5;
8175 opti_type = OPTI_TYPE_ZERO_BYTE
8176 | OPTI_TYPE_PRECOMPUTE_INIT
8177 | OPTI_TYPE_PRECOMPUTE_MERKLE
8178 | OPTI_TYPE_EARLY_SKIP;
8179 dgst_pos0 = 3;
8180 dgst_pos1 = 4;
8181 dgst_pos2 = 2;
8182 dgst_pos3 = 1;
8183 break;
8184
8185 case 5000: hash_type = HASH_TYPE_KECCAK;
8186 salt_type = SALT_TYPE_EMBEDDED;
8187 attack_exec = ATTACK_EXEC_ON_GPU;
8188 opts_type = OPTS_TYPE_PT_GENERATE_LE
8189 | OPTS_TYPE_PT_ADD01;
8190 kern_type = KERN_TYPE_KECCAK;
8191 dgst_size = DGST_SIZE_8_25;
8192 parse_func = keccak_parse_hash;
8193 sort_by_digest = sort_by_digest_8_25;
8194 opti_type = OPTI_TYPE_ZERO_BYTE
8195 | OPTI_TYPE_RAW_HASH;
8196 dgst_pos0 = 2;
8197 dgst_pos1 = 3;
8198 dgst_pos2 = 4;
8199 dgst_pos3 = 5;
8200 break;
8201
8202 case 5100: hash_type = HASH_TYPE_MD5H;
8203 salt_type = SALT_TYPE_NONE;
8204 attack_exec = ATTACK_EXEC_ON_GPU;
8205 opts_type = OPTS_TYPE_PT_GENERATE_LE
8206 | OPTS_TYPE_PT_ADD80
8207 | OPTS_TYPE_PT_ADDBITS14;
8208 kern_type = KERN_TYPE_MD5H;
8209 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8210 parse_func = md5half_parse_hash;
8211 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8212 opti_type = OPTI_TYPE_ZERO_BYTE
8213 | OPTI_TYPE_RAW_HASH;
8214 dgst_pos0 = 0;
8215 dgst_pos1 = 1;
8216 dgst_pos2 = 2;
8217 dgst_pos3 = 3;
8218 break;
8219
8220 case 5200: hash_type = HASH_TYPE_SHA256;
8221 salt_type = SALT_TYPE_EMBEDDED;
8222 attack_exec = ATTACK_EXEC_ON_CPU;
8223 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8224 kern_type = KERN_TYPE_PSAFE3;
8225 dgst_size = DGST_SIZE_4_8;
8226 parse_func = psafe3_parse_hash;
8227 sort_by_digest = sort_by_digest_4_8;
8228 opti_type = OPTI_TYPE_ZERO_BYTE;
8229 dgst_pos0 = 0;
8230 dgst_pos1 = 1;
8231 dgst_pos2 = 2;
8232 dgst_pos3 = 3;
8233 break;
8234
8235 case 5300: hash_type = HASH_TYPE_MD5;
8236 salt_type = SALT_TYPE_EMBEDDED;
8237 attack_exec = ATTACK_EXEC_ON_GPU;
8238 opts_type = OPTS_TYPE_PT_GENERATE_LE
8239 | OPTS_TYPE_ST_ADD80;
8240 kern_type = KERN_TYPE_IKEPSK_MD5;
8241 dgst_size = DGST_SIZE_4_4;
8242 parse_func = ikepsk_md5_parse_hash;
8243 sort_by_digest = sort_by_digest_4_4;
8244 opti_type = OPTI_TYPE_ZERO_BYTE;
8245 dgst_pos0 = 0;
8246 dgst_pos1 = 3;
8247 dgst_pos2 = 2;
8248 dgst_pos3 = 1;
8249 break;
8250
8251 case 5400: hash_type = HASH_TYPE_SHA1;
8252 salt_type = SALT_TYPE_EMBEDDED;
8253 attack_exec = ATTACK_EXEC_ON_GPU;
8254 opts_type = OPTS_TYPE_PT_GENERATE_BE
8255 | OPTS_TYPE_ST_ADD80;
8256 kern_type = KERN_TYPE_IKEPSK_SHA1;
8257 dgst_size = DGST_SIZE_4_5;
8258 parse_func = ikepsk_sha1_parse_hash;
8259 sort_by_digest = sort_by_digest_4_5;
8260 opti_type = OPTI_TYPE_ZERO_BYTE;
8261 dgst_pos0 = 3;
8262 dgst_pos1 = 4;
8263 dgst_pos2 = 2;
8264 dgst_pos3 = 1;
8265 break;
8266
8267 case 5500: hash_type = HASH_TYPE_NETNTLM;
8268 salt_type = SALT_TYPE_EMBEDDED;
8269 attack_exec = ATTACK_EXEC_ON_GPU;
8270 opts_type = OPTS_TYPE_PT_GENERATE_LE
8271 | OPTS_TYPE_PT_ADD80
8272 | OPTS_TYPE_PT_ADDBITS14
8273 | OPTS_TYPE_PT_UNICODE
8274 | OPTS_TYPE_ST_HEX;
8275 kern_type = KERN_TYPE_NETNTLMv1;
8276 dgst_size = DGST_SIZE_4_4;
8277 parse_func = netntlmv1_parse_hash;
8278 sort_by_digest = sort_by_digest_4_4;
8279 opti_type = OPTI_TYPE_ZERO_BYTE
8280 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8281 dgst_pos0 = 0;
8282 dgst_pos1 = 1;
8283 dgst_pos2 = 2;
8284 dgst_pos3 = 3;
8285 break;
8286
8287 case 5600: hash_type = HASH_TYPE_MD5;
8288 salt_type = SALT_TYPE_EMBEDDED;
8289 attack_exec = ATTACK_EXEC_ON_GPU;
8290 opts_type = OPTS_TYPE_PT_GENERATE_LE
8291 | OPTS_TYPE_PT_ADD80
8292 | OPTS_TYPE_PT_ADDBITS14
8293 | OPTS_TYPE_PT_UNICODE;
8294 kern_type = KERN_TYPE_NETNTLMv2;
8295 dgst_size = DGST_SIZE_4_4;
8296 parse_func = netntlmv2_parse_hash;
8297 sort_by_digest = sort_by_digest_4_4;
8298 opti_type = OPTI_TYPE_ZERO_BYTE;
8299 dgst_pos0 = 0;
8300 dgst_pos1 = 3;
8301 dgst_pos2 = 2;
8302 dgst_pos3 = 1;
8303 break;
8304
8305 case 5700: hash_type = HASH_TYPE_SHA256;
8306 salt_type = SALT_TYPE_NONE;
8307 attack_exec = ATTACK_EXEC_ON_GPU;
8308 opts_type = OPTS_TYPE_PT_GENERATE_BE
8309 | OPTS_TYPE_PT_ADD80
8310 | OPTS_TYPE_PT_ADDBITS15;
8311 kern_type = KERN_TYPE_SHA256;
8312 dgst_size = DGST_SIZE_4_8;
8313 parse_func = cisco4_parse_hash;
8314 sort_by_digest = sort_by_digest_4_8;
8315 opti_type = OPTI_TYPE_ZERO_BYTE
8316 | OPTI_TYPE_PRECOMPUTE_INIT
8317 | OPTI_TYPE_PRECOMPUTE_MERKLE
8318 | OPTI_TYPE_EARLY_SKIP
8319 | OPTI_TYPE_NOT_ITERATED
8320 | OPTI_TYPE_NOT_SALTED
8321 | OPTI_TYPE_RAW_HASH;
8322 dgst_pos0 = 3;
8323 dgst_pos1 = 7;
8324 dgst_pos2 = 2;
8325 dgst_pos3 = 6;
8326 break;
8327
8328 case 5800: hash_type = HASH_TYPE_SHA1;
8329 salt_type = SALT_TYPE_INTERN;
8330 attack_exec = ATTACK_EXEC_ON_CPU;
8331 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8332 | OPTS_TYPE_ST_ADD80;
8333 kern_type = KERN_TYPE_ANDROIDPIN;
8334 dgst_size = DGST_SIZE_4_5;
8335 parse_func = androidpin_parse_hash;
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 6000: hash_type = HASH_TYPE_RIPEMD160;
8345 salt_type = SALT_TYPE_NONE;
8346 attack_exec = ATTACK_EXEC_ON_GPU;
8347 opts_type = OPTS_TYPE_PT_GENERATE_LE
8348 | OPTS_TYPE_PT_ADD80;
8349 kern_type = KERN_TYPE_RIPEMD160;
8350 dgst_size = DGST_SIZE_4_5;
8351 parse_func = ripemd160_parse_hash;
8352 sort_by_digest = sort_by_digest_4_5;
8353 opti_type = OPTI_TYPE_ZERO_BYTE;
8354 dgst_pos0 = 0;
8355 dgst_pos1 = 1;
8356 dgst_pos2 = 2;
8357 dgst_pos3 = 3;
8358 break;
8359
8360 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8361 salt_type = SALT_TYPE_NONE;
8362 attack_exec = ATTACK_EXEC_ON_GPU;
8363 opts_type = OPTS_TYPE_PT_GENERATE_BE
8364 | OPTS_TYPE_PT_ADD80;
8365 kern_type = KERN_TYPE_WHIRLPOOL;
8366 dgst_size = DGST_SIZE_4_16;
8367 parse_func = whirlpool_parse_hash;
8368 sort_by_digest = sort_by_digest_4_16;
8369 opti_type = OPTI_TYPE_ZERO_BYTE;
8370 dgst_pos0 = 0;
8371 dgst_pos1 = 1;
8372 dgst_pos2 = 2;
8373 dgst_pos3 = 3;
8374 break;
8375
8376 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8377 salt_type = SALT_TYPE_EMBEDDED;
8378 attack_exec = ATTACK_EXEC_ON_CPU;
8379 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8380 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8381 dgst_size = DGST_SIZE_4_5;
8382 parse_func = truecrypt_parse_hash_2k;
8383 sort_by_digest = sort_by_digest_4_5;
8384 opti_type = OPTI_TYPE_ZERO_BYTE;
8385 dgst_pos0 = 0;
8386 dgst_pos1 = 1;
8387 dgst_pos2 = 2;
8388 dgst_pos3 = 3;
8389 break;
8390
8391 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8392 salt_type = SALT_TYPE_EMBEDDED;
8393 attack_exec = ATTACK_EXEC_ON_CPU;
8394 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8395 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8396 dgst_size = DGST_SIZE_4_5;
8397 parse_func = truecrypt_parse_hash_2k;
8398 sort_by_digest = sort_by_digest_4_5;
8399 opti_type = OPTI_TYPE_ZERO_BYTE;
8400 dgst_pos0 = 0;
8401 dgst_pos1 = 1;
8402 dgst_pos2 = 2;
8403 dgst_pos3 = 3;
8404 break;
8405
8406 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8407 salt_type = SALT_TYPE_EMBEDDED;
8408 attack_exec = ATTACK_EXEC_ON_CPU;
8409 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8410 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8411 dgst_size = DGST_SIZE_4_5;
8412 parse_func = truecrypt_parse_hash_2k;
8413 sort_by_digest = sort_by_digest_4_5;
8414 opti_type = OPTI_TYPE_ZERO_BYTE;
8415 dgst_pos0 = 0;
8416 dgst_pos1 = 1;
8417 dgst_pos2 = 2;
8418 dgst_pos3 = 3;
8419 break;
8420
8421 case 6221: hash_type = HASH_TYPE_SHA512;
8422 salt_type = SALT_TYPE_EMBEDDED;
8423 attack_exec = ATTACK_EXEC_ON_CPU;
8424 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8425 kern_type = KERN_TYPE_TCSHA512_XTS512;
8426 dgst_size = DGST_SIZE_8_8;
8427 parse_func = truecrypt_parse_hash_1k;
8428 sort_by_digest = sort_by_digest_8_8;
8429 opti_type = OPTI_TYPE_ZERO_BYTE;
8430 dgst_pos0 = 0;
8431 dgst_pos1 = 1;
8432 dgst_pos2 = 2;
8433 dgst_pos3 = 3;
8434 break;
8435
8436 case 6222: hash_type = HASH_TYPE_SHA512;
8437 salt_type = SALT_TYPE_EMBEDDED;
8438 attack_exec = ATTACK_EXEC_ON_CPU;
8439 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8440 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8441 dgst_size = DGST_SIZE_8_8;
8442 parse_func = truecrypt_parse_hash_1k;
8443 sort_by_digest = sort_by_digest_8_8;
8444 opti_type = OPTI_TYPE_ZERO_BYTE;
8445 dgst_pos0 = 0;
8446 dgst_pos1 = 1;
8447 dgst_pos2 = 2;
8448 dgst_pos3 = 3;
8449 break;
8450
8451 case 6223: hash_type = HASH_TYPE_SHA512;
8452 salt_type = SALT_TYPE_EMBEDDED;
8453 attack_exec = ATTACK_EXEC_ON_CPU;
8454 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8455 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8456 dgst_size = DGST_SIZE_8_8;
8457 parse_func = truecrypt_parse_hash_1k;
8458 sort_by_digest = sort_by_digest_8_8;
8459 opti_type = OPTI_TYPE_ZERO_BYTE;
8460 dgst_pos0 = 0;
8461 dgst_pos1 = 1;
8462 dgst_pos2 = 2;
8463 dgst_pos3 = 3;
8464 break;
8465
8466 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8467 salt_type = SALT_TYPE_EMBEDDED;
8468 attack_exec = ATTACK_EXEC_ON_CPU;
8469 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8470 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8471 dgst_size = DGST_SIZE_4_8;
8472 parse_func = truecrypt_parse_hash_1k;
8473 sort_by_digest = sort_by_digest_4_8;
8474 opti_type = OPTI_TYPE_ZERO_BYTE;
8475 dgst_pos0 = 0;
8476 dgst_pos1 = 1;
8477 dgst_pos2 = 2;
8478 dgst_pos3 = 3;
8479 break;
8480
8481 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8482 salt_type = SALT_TYPE_EMBEDDED;
8483 attack_exec = ATTACK_EXEC_ON_CPU;
8484 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8485 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8486 dgst_size = DGST_SIZE_4_8;
8487 parse_func = truecrypt_parse_hash_1k;
8488 sort_by_digest = sort_by_digest_4_8;
8489 opti_type = OPTI_TYPE_ZERO_BYTE;
8490 dgst_pos0 = 0;
8491 dgst_pos1 = 1;
8492 dgst_pos2 = 2;
8493 dgst_pos3 = 3;
8494 break;
8495
8496 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8497 salt_type = SALT_TYPE_EMBEDDED;
8498 attack_exec = ATTACK_EXEC_ON_CPU;
8499 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8500 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8501 dgst_size = DGST_SIZE_4_8;
8502 parse_func = truecrypt_parse_hash_1k;
8503 sort_by_digest = sort_by_digest_4_8;
8504 opti_type = OPTI_TYPE_ZERO_BYTE;
8505 dgst_pos0 = 0;
8506 dgst_pos1 = 1;
8507 dgst_pos2 = 2;
8508 dgst_pos3 = 3;
8509 break;
8510
8511 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8512 salt_type = SALT_TYPE_EMBEDDED;
8513 attack_exec = ATTACK_EXEC_ON_CPU;
8514 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8515 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8516 dgst_size = DGST_SIZE_4_5;
8517 parse_func = truecrypt_parse_hash_1k;
8518 sort_by_digest = sort_by_digest_4_5;
8519 opti_type = OPTI_TYPE_ZERO_BYTE;
8520 dgst_pos0 = 0;
8521 dgst_pos1 = 1;
8522 dgst_pos2 = 2;
8523 dgst_pos3 = 3;
8524 break;
8525
8526 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8527 salt_type = SALT_TYPE_EMBEDDED;
8528 attack_exec = ATTACK_EXEC_ON_CPU;
8529 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8530 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8531 dgst_size = DGST_SIZE_4_5;
8532 parse_func = truecrypt_parse_hash_1k;
8533 sort_by_digest = sort_by_digest_4_5;
8534 opti_type = OPTI_TYPE_ZERO_BYTE;
8535 dgst_pos0 = 0;
8536 dgst_pos1 = 1;
8537 dgst_pos2 = 2;
8538 dgst_pos3 = 3;
8539 break;
8540
8541 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8542 salt_type = SALT_TYPE_EMBEDDED;
8543 attack_exec = ATTACK_EXEC_ON_CPU;
8544 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8545 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8546 dgst_size = DGST_SIZE_4_5;
8547 parse_func = truecrypt_parse_hash_1k;
8548 sort_by_digest = sort_by_digest_4_5;
8549 opti_type = OPTI_TYPE_ZERO_BYTE;
8550 dgst_pos0 = 0;
8551 dgst_pos1 = 1;
8552 dgst_pos2 = 2;
8553 dgst_pos3 = 3;
8554 break;
8555
8556 case 6300: hash_type = HASH_TYPE_MD5;
8557 salt_type = SALT_TYPE_EMBEDDED;
8558 attack_exec = ATTACK_EXEC_ON_CPU;
8559 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8560 kern_type = KERN_TYPE_MD5AIX;
8561 dgst_size = DGST_SIZE_4_4;
8562 parse_func = md5aix_parse_hash;
8563 sort_by_digest = sort_by_digest_4_4;
8564 opti_type = OPTI_TYPE_ZERO_BYTE;
8565 dgst_pos0 = 0;
8566 dgst_pos1 = 1;
8567 dgst_pos2 = 2;
8568 dgst_pos3 = 3;
8569 break;
8570
8571 case 6400: hash_type = HASH_TYPE_SHA256;
8572 salt_type = SALT_TYPE_EMBEDDED;
8573 attack_exec = ATTACK_EXEC_ON_CPU;
8574 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8575 kern_type = KERN_TYPE_SHA256AIX;
8576 dgst_size = DGST_SIZE_4_8;
8577 parse_func = sha256aix_parse_hash;
8578 sort_by_digest = sort_by_digest_4_8;
8579 opti_type = OPTI_TYPE_ZERO_BYTE;
8580 dgst_pos0 = 0;
8581 dgst_pos1 = 1;
8582 dgst_pos2 = 2;
8583 dgst_pos3 = 3;
8584 break;
8585
8586 case 6500: hash_type = HASH_TYPE_SHA512;
8587 salt_type = SALT_TYPE_EMBEDDED;
8588 attack_exec = ATTACK_EXEC_ON_CPU;
8589 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8590 kern_type = KERN_TYPE_SHA512AIX;
8591 dgst_size = DGST_SIZE_8_8;
8592 parse_func = sha512aix_parse_hash;
8593 sort_by_digest = sort_by_digest_8_8;
8594 opti_type = OPTI_TYPE_ZERO_BYTE;
8595 dgst_pos0 = 0;
8596 dgst_pos1 = 1;
8597 dgst_pos2 = 2;
8598 dgst_pos3 = 3;
8599 break;
8600
8601 case 6600: hash_type = HASH_TYPE_AES;
8602 salt_type = SALT_TYPE_EMBEDDED;
8603 attack_exec = ATTACK_EXEC_ON_CPU;
8604 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8605 kern_type = KERN_TYPE_AGILEKEY;
8606 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8607 parse_func = agilekey_parse_hash;
8608 sort_by_digest = sort_by_digest_4_5;
8609 opti_type = OPTI_TYPE_ZERO_BYTE;
8610 dgst_pos0 = 0;
8611 dgst_pos1 = 1;
8612 dgst_pos2 = 2;
8613 dgst_pos3 = 3;
8614 break;
8615
8616 case 6700: hash_type = HASH_TYPE_SHA1;
8617 salt_type = SALT_TYPE_EMBEDDED;
8618 attack_exec = ATTACK_EXEC_ON_CPU;
8619 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8620 kern_type = KERN_TYPE_SHA1AIX;
8621 dgst_size = DGST_SIZE_4_5;
8622 parse_func = sha1aix_parse_hash;
8623 sort_by_digest = sort_by_digest_4_5;
8624 opti_type = OPTI_TYPE_ZERO_BYTE;
8625 dgst_pos0 = 0;
8626 dgst_pos1 = 1;
8627 dgst_pos2 = 2;
8628 dgst_pos3 = 3;
8629 break;
8630
8631 case 6800: hash_type = HASH_TYPE_AES;
8632 salt_type = SALT_TYPE_EMBEDDED;
8633 attack_exec = ATTACK_EXEC_ON_CPU;
8634 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8635 kern_type = KERN_TYPE_LASTPASS;
8636 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
8637 parse_func = lastpass_parse_hash;
8638 sort_by_digest = sort_by_digest_4_8;
8639 opti_type = OPTI_TYPE_ZERO_BYTE;
8640 dgst_pos0 = 0;
8641 dgst_pos1 = 1;
8642 dgst_pos2 = 2;
8643 dgst_pos3 = 3;
8644 break;
8645
8646 case 6900: hash_type = HASH_TYPE_GOST;
8647 salt_type = SALT_TYPE_NONE;
8648 attack_exec = ATTACK_EXEC_ON_GPU;
8649 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8650 kern_type = KERN_TYPE_GOST;
8651 dgst_size = DGST_SIZE_4_8;
8652 parse_func = gost_parse_hash;
8653 sort_by_digest = sort_by_digest_4_8;
8654 opti_type = OPTI_TYPE_ZERO_BYTE;
8655 dgst_pos0 = 0;
8656 dgst_pos1 = 1;
8657 dgst_pos2 = 2;
8658 dgst_pos3 = 3;
8659 break;
8660
8661 case 7100: hash_type = HASH_TYPE_SHA512;
8662 salt_type = SALT_TYPE_EMBEDDED;
8663 attack_exec = ATTACK_EXEC_ON_CPU;
8664 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8665 kern_type = KERN_TYPE_PBKDF2_SHA512;
8666 dgst_size = DGST_SIZE_8_16;
8667 parse_func = sha512osx_parse_hash;
8668 sort_by_digest = sort_by_digest_8_16;
8669 opti_type = OPTI_TYPE_ZERO_BYTE;
8670 dgst_pos0 = 0;
8671 dgst_pos1 = 1;
8672 dgst_pos2 = 2;
8673 dgst_pos3 = 3;
8674 break;
8675
8676 case 7200: hash_type = HASH_TYPE_SHA512;
8677 salt_type = SALT_TYPE_EMBEDDED;
8678 attack_exec = ATTACK_EXEC_ON_CPU;
8679 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8680 kern_type = KERN_TYPE_PBKDF2_SHA512;
8681 dgst_size = DGST_SIZE_8_16;
8682 parse_func = sha512grub_parse_hash;
8683 sort_by_digest = sort_by_digest_8_16;
8684 opti_type = OPTI_TYPE_ZERO_BYTE;
8685 dgst_pos0 = 0;
8686 dgst_pos1 = 1;
8687 dgst_pos2 = 2;
8688 dgst_pos3 = 3;
8689 break;
8690
8691 case 7300: hash_type = HASH_TYPE_SHA1;
8692 salt_type = SALT_TYPE_EMBEDDED;
8693 attack_exec = ATTACK_EXEC_ON_GPU;
8694 opts_type = OPTS_TYPE_PT_GENERATE_BE
8695 | OPTS_TYPE_ST_ADD80
8696 | OPTS_TYPE_ST_ADDBITS15;
8697 kern_type = KERN_TYPE_RAKP;
8698 dgst_size = DGST_SIZE_4_5;
8699 parse_func = rakp_parse_hash;
8700 sort_by_digest = sort_by_digest_4_5;
8701 opti_type = OPTI_TYPE_ZERO_BYTE
8702 | OPTI_TYPE_NOT_ITERATED;
8703 dgst_pos0 = 3;
8704 dgst_pos1 = 4;
8705 dgst_pos2 = 2;
8706 dgst_pos3 = 1;
8707 break;
8708
8709 case 7400: hash_type = HASH_TYPE_SHA256;
8710 salt_type = SALT_TYPE_EMBEDDED;
8711 attack_exec = ATTACK_EXEC_ON_CPU;
8712 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8713 kern_type = KERN_TYPE_SHA256CRYPT;
8714 dgst_size = DGST_SIZE_4_8;
8715 parse_func = sha256crypt_parse_hash;
8716 sort_by_digest = sort_by_digest_4_8;
8717 opti_type = OPTI_TYPE_ZERO_BYTE;
8718 dgst_pos0 = 0;
8719 dgst_pos1 = 1;
8720 dgst_pos2 = 2;
8721 dgst_pos3 = 3;
8722 break;
8723
8724 case 7500: hash_type = HASH_TYPE_KRB5PA;
8725 salt_type = SALT_TYPE_EMBEDDED;
8726 attack_exec = ATTACK_EXEC_ON_GPU;
8727 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8728 kern_type = KERN_TYPE_KRB5PA;
8729 dgst_size = DGST_SIZE_4_4;
8730 parse_func = krb5pa_parse_hash;
8731 sort_by_digest = sort_by_digest_4_4;
8732 opti_type = OPTI_TYPE_ZERO_BYTE
8733 | OPTI_TYPE_NOT_ITERATED;
8734 dgst_pos0 = 3;
8735 dgst_pos1 = 7;
8736 dgst_pos2 = 2;
8737 dgst_pos3 = 6;
8738 break;
8739
8740 case 7600: hash_type = HASH_TYPE_SHA1;
8741 salt_type = SALT_TYPE_INTERN;
8742 attack_exec = ATTACK_EXEC_ON_GPU;
8743 opts_type = OPTS_TYPE_PT_GENERATE_BE
8744 | OPTS_TYPE_PT_ADD80
8745 | OPTS_TYPE_PT_ADDBITS15;
8746 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
8747 dgst_size = DGST_SIZE_4_5;
8748 parse_func = redmine_parse_hash;
8749 sort_by_digest = sort_by_digest_4_5;
8750 opti_type = OPTI_TYPE_ZERO_BYTE
8751 | OPTI_TYPE_PRECOMPUTE_INIT
8752 | OPTI_TYPE_EARLY_SKIP
8753 | OPTI_TYPE_NOT_ITERATED
8754 | OPTI_TYPE_PREPENDED_SALT;
8755 dgst_pos0 = 3;
8756 dgst_pos1 = 4;
8757 dgst_pos2 = 2;
8758 dgst_pos3 = 1;
8759 break;
8760
8761 case 7700: hash_type = HASH_TYPE_SAPB;
8762 salt_type = SALT_TYPE_EMBEDDED;
8763 attack_exec = ATTACK_EXEC_ON_GPU;
8764 opts_type = OPTS_TYPE_PT_GENERATE_LE
8765 | OPTS_TYPE_PT_UPPER
8766 | OPTS_TYPE_ST_UPPER;
8767 kern_type = KERN_TYPE_SAPB;
8768 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8769 parse_func = sapb_parse_hash;
8770 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8771 opti_type = OPTI_TYPE_ZERO_BYTE
8772 | OPTI_TYPE_PRECOMPUTE_INIT
8773 | OPTI_TYPE_NOT_ITERATED;
8774 dgst_pos0 = 0;
8775 dgst_pos1 = 1;
8776 dgst_pos2 = 2;
8777 dgst_pos3 = 3;
8778 break;
8779
8780 case 7800: hash_type = HASH_TYPE_SAPG;
8781 salt_type = SALT_TYPE_EMBEDDED;
8782 attack_exec = ATTACK_EXEC_ON_GPU;
8783 opts_type = OPTS_TYPE_PT_GENERATE_BE
8784 | OPTS_TYPE_ST_ADD80
8785 | OPTS_TYPE_ST_UPPER;
8786 kern_type = KERN_TYPE_SAPG;
8787 dgst_size = DGST_SIZE_4_5;
8788 parse_func = sapg_parse_hash;
8789 sort_by_digest = sort_by_digest_4_5;
8790 opti_type = OPTI_TYPE_ZERO_BYTE
8791 | OPTI_TYPE_PRECOMPUTE_INIT
8792 | OPTI_TYPE_NOT_ITERATED;
8793 dgst_pos0 = 3;
8794 dgst_pos1 = 4;
8795 dgst_pos2 = 2;
8796 dgst_pos3 = 1;
8797 break;
8798
8799 case 7900: hash_type = HASH_TYPE_SHA512;
8800 salt_type = SALT_TYPE_EMBEDDED;
8801 attack_exec = ATTACK_EXEC_ON_CPU;
8802 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8803 kern_type = KERN_TYPE_DRUPAL7;
8804 dgst_size = DGST_SIZE_8_8;
8805 parse_func = drupal7_parse_hash;
8806 sort_by_digest = sort_by_digest_8_8;
8807 opti_type = OPTI_TYPE_ZERO_BYTE;
8808 dgst_pos0 = 0;
8809 dgst_pos1 = 1;
8810 dgst_pos2 = 2;
8811 dgst_pos3 = 3;
8812 break;
8813
8814 case 8000: hash_type = HASH_TYPE_SHA256;
8815 salt_type = SALT_TYPE_EMBEDDED;
8816 attack_exec = ATTACK_EXEC_ON_GPU;
8817 opts_type = OPTS_TYPE_PT_GENERATE_BE
8818 | OPTS_TYPE_PT_UNICODE
8819 | OPTS_TYPE_ST_ADD80
8820 | OPTS_TYPE_ST_HEX;
8821 kern_type = KERN_TYPE_SYBASEASE;
8822 dgst_size = DGST_SIZE_4_8;
8823 parse_func = sybasease_parse_hash;
8824 sort_by_digest = sort_by_digest_4_8;
8825 opti_type = OPTI_TYPE_ZERO_BYTE
8826 | OPTI_TYPE_PRECOMPUTE_INIT
8827 | OPTI_TYPE_EARLY_SKIP
8828 | OPTI_TYPE_NOT_ITERATED
8829 | OPTI_TYPE_RAW_HASH;
8830 dgst_pos0 = 3;
8831 dgst_pos1 = 7;
8832 dgst_pos2 = 2;
8833 dgst_pos3 = 6;
8834 break;
8835
8836 case 8100: hash_type = HASH_TYPE_SHA1;
8837 salt_type = SALT_TYPE_EMBEDDED;
8838 attack_exec = ATTACK_EXEC_ON_GPU;
8839 opts_type = OPTS_TYPE_PT_GENERATE_BE;
8840 kern_type = KERN_TYPE_NETSCALER;
8841 dgst_size = DGST_SIZE_4_5;
8842 parse_func = netscaler_parse_hash;
8843 sort_by_digest = sort_by_digest_4_5;
8844 opti_type = OPTI_TYPE_ZERO_BYTE
8845 | OPTI_TYPE_PRECOMPUTE_INIT
8846 | OPTI_TYPE_PRECOMPUTE_MERKLE
8847 | OPTI_TYPE_EARLY_SKIP
8848 | OPTI_TYPE_NOT_ITERATED
8849 | OPTI_TYPE_PREPENDED_SALT
8850 | OPTI_TYPE_RAW_HASH;
8851 dgst_pos0 = 3;
8852 dgst_pos1 = 4;
8853 dgst_pos2 = 2;
8854 dgst_pos3 = 1;
8855 break;
8856
8857 case 8200: hash_type = HASH_TYPE_SHA256;
8858 salt_type = SALT_TYPE_EMBEDDED;
8859 attack_exec = ATTACK_EXEC_ON_CPU;
8860 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8861 kern_type = KERN_TYPE_CLOUDKEY;
8862 dgst_size = DGST_SIZE_4_8;
8863 parse_func = cloudkey_parse_hash;
8864 sort_by_digest = sort_by_digest_4_8;
8865 opti_type = OPTI_TYPE_ZERO_BYTE;
8866 dgst_pos0 = 0;
8867 dgst_pos1 = 1;
8868 dgst_pos2 = 2;
8869 dgst_pos3 = 3;
8870 break;
8871
8872 case 8300: hash_type = HASH_TYPE_SHA1;
8873 salt_type = SALT_TYPE_EMBEDDED;
8874 attack_exec = ATTACK_EXEC_ON_GPU;
8875 opts_type = OPTS_TYPE_PT_GENERATE_LE
8876 | OPTS_TYPE_ST_HEX
8877 | OPTS_TYPE_ST_ADD80;
8878 kern_type = KERN_TYPE_NSEC3;
8879 dgst_size = DGST_SIZE_4_5;
8880 parse_func = nsec3_parse_hash;
8881 sort_by_digest = sort_by_digest_4_5;
8882 opti_type = OPTI_TYPE_ZERO_BYTE;
8883 dgst_pos0 = 3;
8884 dgst_pos1 = 4;
8885 dgst_pos2 = 2;
8886 dgst_pos3 = 1;
8887 break;
8888
8889 case 8400: hash_type = HASH_TYPE_SHA1;
8890 salt_type = SALT_TYPE_INTERN;
8891 attack_exec = ATTACK_EXEC_ON_GPU;
8892 opts_type = OPTS_TYPE_PT_GENERATE_BE
8893 | OPTS_TYPE_PT_ADD80
8894 | OPTS_TYPE_PT_ADDBITS15;
8895 kern_type = KERN_TYPE_WBB3;
8896 dgst_size = DGST_SIZE_4_5;
8897 parse_func = wbb3_parse_hash;
8898 sort_by_digest = sort_by_digest_4_5;
8899 opti_type = OPTI_TYPE_ZERO_BYTE
8900 | OPTI_TYPE_PRECOMPUTE_INIT
8901 | OPTI_TYPE_NOT_ITERATED;
8902 dgst_pos0 = 3;
8903 dgst_pos1 = 4;
8904 dgst_pos2 = 2;
8905 dgst_pos3 = 1;
8906 break;
8907
8908 case 8500: hash_type = HASH_TYPE_DESRACF;
8909 salt_type = SALT_TYPE_EMBEDDED;
8910 attack_exec = ATTACK_EXEC_ON_GPU;
8911 opts_type = OPTS_TYPE_PT_GENERATE_LE
8912 | OPTS_TYPE_ST_UPPER;
8913 kern_type = KERN_TYPE_RACF;
8914 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8915 parse_func = racf_parse_hash;
8916 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8917 opti_type = OPTI_TYPE_ZERO_BYTE
8918 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8919 dgst_pos0 = 0;
8920 dgst_pos1 = 1;
8921 dgst_pos2 = 2;
8922 dgst_pos3 = 3;
8923 break;
8924
8925 case 8600: hash_type = HASH_TYPE_LOTUS5;
8926 salt_type = SALT_TYPE_NONE;
8927 attack_exec = ATTACK_EXEC_ON_GPU;
8928 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8929 kern_type = KERN_TYPE_LOTUS5;
8930 dgst_size = DGST_SIZE_4_4;
8931 parse_func = lotus5_parse_hash;
8932 sort_by_digest = sort_by_digest_4_4;
8933 opti_type = OPTI_TYPE_EARLY_SKIP
8934 | OPTI_TYPE_NOT_ITERATED
8935 | OPTI_TYPE_NOT_SALTED
8936 | OPTI_TYPE_RAW_HASH;
8937 dgst_pos0 = 0;
8938 dgst_pos1 = 1;
8939 dgst_pos2 = 2;
8940 dgst_pos3 = 3;
8941 break;
8942
8943 case 8700: hash_type = HASH_TYPE_LOTUS6;
8944 salt_type = SALT_TYPE_EMBEDDED;
8945 attack_exec = ATTACK_EXEC_ON_GPU;
8946 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8947 kern_type = KERN_TYPE_LOTUS6;
8948 dgst_size = DGST_SIZE_4_4;
8949 parse_func = lotus6_parse_hash;
8950 sort_by_digest = sort_by_digest_4_4;
8951 opti_type = OPTI_TYPE_EARLY_SKIP
8952 | OPTI_TYPE_NOT_ITERATED
8953 | OPTI_TYPE_RAW_HASH;
8954 dgst_pos0 = 0;
8955 dgst_pos1 = 1;
8956 dgst_pos2 = 2;
8957 dgst_pos3 = 3;
8958 break;
8959
8960 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
8961 salt_type = SALT_TYPE_EMBEDDED;
8962 attack_exec = ATTACK_EXEC_ON_CPU;
8963 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8964 kern_type = KERN_TYPE_ANDROIDFDE;
8965 dgst_size = DGST_SIZE_4_4;
8966 parse_func = androidfde_parse_hash;
8967 sort_by_digest = sort_by_digest_4_4;
8968 opti_type = OPTI_TYPE_ZERO_BYTE;
8969 dgst_pos0 = 0;
8970 dgst_pos1 = 1;
8971 dgst_pos2 = 2;
8972 dgst_pos3 = 3;
8973 break;
8974
8975 case 8900: hash_type = HASH_TYPE_SCRYPT;
8976 salt_type = SALT_TYPE_EMBEDDED;
8977 attack_exec = ATTACK_EXEC_ON_CPU;
8978 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8979 kern_type = KERN_TYPE_SCRYPT;
8980 dgst_size = DGST_SIZE_4_8;
8981 parse_func = scrypt_parse_hash;
8982 sort_by_digest = sort_by_digest_4_8;
8983 opti_type = OPTI_TYPE_ZERO_BYTE;
8984 dgst_pos0 = 0;
8985 dgst_pos1 = 1;
8986 dgst_pos2 = 2;
8987 dgst_pos3 = 3;
8988 break;
8989
8990 case 9000: hash_type = HASH_TYPE_SHA1;
8991 salt_type = SALT_TYPE_EMBEDDED;
8992 attack_exec = ATTACK_EXEC_ON_CPU;
8993 opts_type = OPTS_TYPE_PT_GENERATE_LE
8994 | OPTS_TYPE_ST_GENERATE_LE;
8995 kern_type = KERN_TYPE_PSAFE2;
8996 dgst_size = DGST_SIZE_4_5;
8997 parse_func = psafe2_parse_hash;
8998 sort_by_digest = sort_by_digest_4_5;
8999 opti_type = OPTI_TYPE_ZERO_BYTE;
9000 dgst_pos0 = 0;
9001 dgst_pos1 = 1;
9002 dgst_pos2 = 2;
9003 dgst_pos3 = 3;
9004 break;
9005
9006 case 9100: hash_type = HASH_TYPE_LOTUS8;
9007 salt_type = SALT_TYPE_EMBEDDED;
9008 attack_exec = ATTACK_EXEC_ON_CPU;
9009 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9010 kern_type = KERN_TYPE_LOTUS8;
9011 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9012 parse_func = lotus8_parse_hash;
9013 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9014 opti_type = OPTI_TYPE_ZERO_BYTE;
9015 dgst_pos0 = 0;
9016 dgst_pos1 = 1;
9017 dgst_pos2 = 2;
9018 dgst_pos3 = 3;
9019 break;
9020
9021 case 9200: hash_type = HASH_TYPE_SHA256;
9022 salt_type = SALT_TYPE_EMBEDDED;
9023 attack_exec = ATTACK_EXEC_ON_CPU;
9024 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9025 kern_type = KERN_TYPE_PBKDF2_SHA256;
9026 dgst_size = DGST_SIZE_4_32;
9027 parse_func = cisco8_parse_hash;
9028 sort_by_digest = sort_by_digest_4_32;
9029 opti_type = OPTI_TYPE_ZERO_BYTE;
9030 dgst_pos0 = 0;
9031 dgst_pos1 = 1;
9032 dgst_pos2 = 2;
9033 dgst_pos3 = 3;
9034 break;
9035
9036 case 9300: hash_type = HASH_TYPE_SCRYPT;
9037 salt_type = SALT_TYPE_EMBEDDED;
9038 attack_exec = ATTACK_EXEC_ON_CPU;
9039 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9040 kern_type = KERN_TYPE_SCRYPT;
9041 dgst_size = DGST_SIZE_4_8;
9042 parse_func = cisco9_parse_hash;
9043 sort_by_digest = sort_by_digest_4_8;
9044 opti_type = OPTI_TYPE_ZERO_BYTE;
9045 dgst_pos0 = 0;
9046 dgst_pos1 = 1;
9047 dgst_pos2 = 2;
9048 dgst_pos3 = 3;
9049 break;
9050
9051 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9052 salt_type = SALT_TYPE_EMBEDDED;
9053 attack_exec = ATTACK_EXEC_ON_CPU;
9054 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9055 kern_type = KERN_TYPE_OFFICE2007;
9056 dgst_size = DGST_SIZE_4_4;
9057 parse_func = office2007_parse_hash;
9058 sort_by_digest = sort_by_digest_4_4;
9059 opti_type = OPTI_TYPE_ZERO_BYTE;
9060 dgst_pos0 = 0;
9061 dgst_pos1 = 1;
9062 dgst_pos2 = 2;
9063 dgst_pos3 = 3;
9064 break;
9065
9066 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9067 salt_type = SALT_TYPE_EMBEDDED;
9068 attack_exec = ATTACK_EXEC_ON_CPU;
9069 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9070 kern_type = KERN_TYPE_OFFICE2010;
9071 dgst_size = DGST_SIZE_4_4;
9072 parse_func = office2010_parse_hash;
9073 sort_by_digest = sort_by_digest_4_4;
9074 opti_type = OPTI_TYPE_ZERO_BYTE;
9075 dgst_pos0 = 0;
9076 dgst_pos1 = 1;
9077 dgst_pos2 = 2;
9078 dgst_pos3 = 3;
9079 break;
9080
9081 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9082 salt_type = SALT_TYPE_EMBEDDED;
9083 attack_exec = ATTACK_EXEC_ON_CPU;
9084 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9085 kern_type = KERN_TYPE_OFFICE2013;
9086 dgst_size = DGST_SIZE_4_4;
9087 parse_func = office2013_parse_hash;
9088 sort_by_digest = sort_by_digest_4_4;
9089 opti_type = OPTI_TYPE_ZERO_BYTE;
9090 dgst_pos0 = 0;
9091 dgst_pos1 = 1;
9092 dgst_pos2 = 2;
9093 dgst_pos3 = 3;
9094 break;
9095
9096 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9097 salt_type = SALT_TYPE_EMBEDDED;
9098 attack_exec = ATTACK_EXEC_ON_GPU;
9099 opts_type = OPTS_TYPE_PT_GENERATE_LE
9100 | OPTS_TYPE_PT_ADD80
9101 | OPTS_TYPE_PT_UNICODE;
9102 kern_type = KERN_TYPE_OLDOFFICE01;
9103 dgst_size = DGST_SIZE_4_4;
9104 parse_func = oldoffice01_parse_hash;
9105 sort_by_digest = sort_by_digest_4_4;
9106 opti_type = OPTI_TYPE_ZERO_BYTE
9107 | OPTI_TYPE_PRECOMPUTE_INIT
9108 | OPTI_TYPE_NOT_ITERATED;
9109 dgst_pos0 = 0;
9110 dgst_pos1 = 1;
9111 dgst_pos2 = 2;
9112 dgst_pos3 = 3;
9113 break;
9114
9115 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9116 salt_type = SALT_TYPE_EMBEDDED;
9117 attack_exec = ATTACK_EXEC_ON_GPU;
9118 opts_type = OPTS_TYPE_PT_GENERATE_LE
9119 | OPTS_TYPE_PT_ADD80;
9120 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9121 dgst_size = DGST_SIZE_4_4;
9122 parse_func = oldoffice01cm1_parse_hash;
9123 sort_by_digest = sort_by_digest_4_4;
9124 opti_type = OPTI_TYPE_ZERO_BYTE
9125 | OPTI_TYPE_PRECOMPUTE_INIT
9126 | OPTI_TYPE_NOT_ITERATED;
9127 dgst_pos0 = 0;
9128 dgst_pos1 = 1;
9129 dgst_pos2 = 2;
9130 dgst_pos3 = 3;
9131 break;
9132
9133 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9134 salt_type = SALT_TYPE_EMBEDDED;
9135 attack_exec = ATTACK_EXEC_ON_GPU;
9136 opts_type = OPTS_TYPE_PT_GENERATE_LE
9137 | OPTS_TYPE_PT_ADD80
9138 | OPTS_TYPE_PT_UNICODE
9139 | OPTS_TYPE_PT_NEVERCRACK;
9140 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9141 dgst_size = DGST_SIZE_4_4;
9142 parse_func = oldoffice01cm2_parse_hash;
9143 sort_by_digest = sort_by_digest_4_4;
9144 opti_type = OPTI_TYPE_ZERO_BYTE
9145 | OPTI_TYPE_PRECOMPUTE_INIT
9146 | OPTI_TYPE_NOT_ITERATED;
9147 dgst_pos0 = 0;
9148 dgst_pos1 = 1;
9149 dgst_pos2 = 2;
9150 dgst_pos3 = 3;
9151 break;
9152
9153 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9154 salt_type = SALT_TYPE_EMBEDDED;
9155 attack_exec = ATTACK_EXEC_ON_GPU;
9156 opts_type = OPTS_TYPE_PT_GENERATE_BE
9157 | OPTS_TYPE_PT_ADD80
9158 | OPTS_TYPE_PT_UNICODE;
9159 kern_type = KERN_TYPE_OLDOFFICE34;
9160 dgst_size = DGST_SIZE_4_4;
9161 parse_func = oldoffice34_parse_hash;
9162 sort_by_digest = sort_by_digest_4_4;
9163 opti_type = OPTI_TYPE_ZERO_BYTE
9164 | OPTI_TYPE_PRECOMPUTE_INIT
9165 | OPTI_TYPE_NOT_ITERATED;
9166 dgst_pos0 = 0;
9167 dgst_pos1 = 1;
9168 dgst_pos2 = 2;
9169 dgst_pos3 = 3;
9170 break;
9171
9172 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9173 salt_type = SALT_TYPE_EMBEDDED;
9174 attack_exec = ATTACK_EXEC_ON_GPU;
9175 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9176 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9177 dgst_size = DGST_SIZE_4_4;
9178 parse_func = oldoffice34cm1_parse_hash;
9179 sort_by_digest = sort_by_digest_4_4;
9180 opti_type = OPTI_TYPE_ZERO_BYTE
9181 | OPTI_TYPE_PRECOMPUTE_INIT
9182 | OPTI_TYPE_NOT_ITERATED;
9183 dgst_pos0 = 0;
9184 dgst_pos1 = 1;
9185 dgst_pos2 = 2;
9186 dgst_pos3 = 3;
9187 break;
9188
9189 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9190 salt_type = SALT_TYPE_EMBEDDED;
9191 attack_exec = ATTACK_EXEC_ON_GPU;
9192 opts_type = OPTS_TYPE_PT_GENERATE_BE
9193 | OPTS_TYPE_PT_ADD80
9194 | OPTS_TYPE_PT_UNICODE
9195 | OPTS_TYPE_PT_NEVERCRACK;
9196 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9197 dgst_size = DGST_SIZE_4_4;
9198 parse_func = oldoffice34cm2_parse_hash;
9199 sort_by_digest = sort_by_digest_4_4;
9200 opti_type = OPTI_TYPE_ZERO_BYTE
9201 | OPTI_TYPE_PRECOMPUTE_INIT
9202 | OPTI_TYPE_NOT_ITERATED;
9203 dgst_pos0 = 0;
9204 dgst_pos1 = 1;
9205 dgst_pos2 = 2;
9206 dgst_pos3 = 3;
9207 break;
9208
9209 case 9900: hash_type = HASH_TYPE_MD5;
9210 salt_type = SALT_TYPE_NONE;
9211 attack_exec = ATTACK_EXEC_ON_GPU;
9212 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9213 kern_type = KERN_TYPE_RADMIN2;
9214 dgst_size = DGST_SIZE_4_4;
9215 parse_func = radmin2_parse_hash;
9216 sort_by_digest = sort_by_digest_4_4;
9217 opti_type = OPTI_TYPE_ZERO_BYTE
9218 | OPTI_TYPE_PRECOMPUTE_INIT
9219 | OPTI_TYPE_EARLY_SKIP
9220 | OPTI_TYPE_NOT_ITERATED
9221 | OPTI_TYPE_NOT_SALTED;
9222 dgst_pos0 = 0;
9223 dgst_pos1 = 3;
9224 dgst_pos2 = 2;
9225 dgst_pos3 = 1;
9226 break;
9227
9228 case 10000: hash_type = HASH_TYPE_SHA256;
9229 salt_type = SALT_TYPE_EMBEDDED;
9230 attack_exec = ATTACK_EXEC_ON_CPU;
9231 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9232 kern_type = KERN_TYPE_PBKDF2_SHA256;
9233 dgst_size = DGST_SIZE_4_32;
9234 parse_func = djangopbkdf2_parse_hash;
9235 sort_by_digest = sort_by_digest_4_32;
9236 opti_type = OPTI_TYPE_ZERO_BYTE;
9237 dgst_pos0 = 0;
9238 dgst_pos1 = 1;
9239 dgst_pos2 = 2;
9240 dgst_pos3 = 3;
9241 break;
9242
9243 case 10100: hash_type = HASH_TYPE_SIPHASH;
9244 salt_type = SALT_TYPE_EMBEDDED;
9245 attack_exec = ATTACK_EXEC_ON_GPU;
9246 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9247 kern_type = KERN_TYPE_SIPHASH;
9248 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9249 parse_func = siphash_parse_hash;
9250 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9251 opti_type = OPTI_TYPE_ZERO_BYTE
9252 | OPTI_TYPE_NOT_ITERATED
9253 | OPTI_TYPE_RAW_HASH;
9254 dgst_pos0 = 0;
9255 dgst_pos1 = 1;
9256 dgst_pos2 = 2;
9257 dgst_pos3 = 3;
9258 break;
9259
9260 case 10200: hash_type = HASH_TYPE_MD5;
9261 salt_type = SALT_TYPE_EMBEDDED;
9262 attack_exec = ATTACK_EXEC_ON_GPU;
9263 opts_type = OPTS_TYPE_PT_GENERATE_LE
9264 | OPTS_TYPE_ST_ADD80
9265 | OPTS_TYPE_ST_ADDBITS14;
9266 kern_type = KERN_TYPE_HMACMD5_PW;
9267 dgst_size = DGST_SIZE_4_4;
9268 parse_func = crammd5_parse_hash;
9269 sort_by_digest = sort_by_digest_4_4;
9270 opti_type = OPTI_TYPE_ZERO_BYTE
9271 | OPTI_TYPE_NOT_ITERATED;
9272 dgst_pos0 = 0;
9273 dgst_pos1 = 3;
9274 dgst_pos2 = 2;
9275 dgst_pos3 = 1;
9276 break;
9277
9278 case 10300: hash_type = HASH_TYPE_SHA1;
9279 salt_type = SALT_TYPE_EMBEDDED;
9280 attack_exec = ATTACK_EXEC_ON_CPU;
9281 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9282 kern_type = KERN_TYPE_SAPH_SHA1;
9283 dgst_size = DGST_SIZE_4_5;
9284 parse_func = saph_sha1_parse_hash;
9285 sort_by_digest = sort_by_digest_4_5;
9286 opti_type = OPTI_TYPE_ZERO_BYTE;
9287 dgst_pos0 = 0;
9288 dgst_pos1 = 1;
9289 dgst_pos2 = 2;
9290 dgst_pos3 = 3;
9291 break;
9292
9293 case 10400: hash_type = HASH_TYPE_PDFU16;
9294 salt_type = SALT_TYPE_EMBEDDED;
9295 attack_exec = ATTACK_EXEC_ON_GPU;
9296 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9297 kern_type = KERN_TYPE_PDF11;
9298 dgst_size = DGST_SIZE_4_4;
9299 parse_func = pdf11_parse_hash;
9300 sort_by_digest = sort_by_digest_4_4;
9301 opti_type = OPTI_TYPE_ZERO_BYTE
9302 | OPTI_TYPE_NOT_ITERATED;
9303 dgst_pos0 = 0;
9304 dgst_pos1 = 1;
9305 dgst_pos2 = 2;
9306 dgst_pos3 = 3;
9307 break;
9308
9309 case 10410: hash_type = HASH_TYPE_PDFU16;
9310 salt_type = SALT_TYPE_EMBEDDED;
9311 attack_exec = ATTACK_EXEC_ON_GPU;
9312 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9313 kern_type = KERN_TYPE_PDF11CM1;
9314 dgst_size = DGST_SIZE_4_4;
9315 parse_func = pdf11cm1_parse_hash;
9316 sort_by_digest = sort_by_digest_4_4;
9317 opti_type = OPTI_TYPE_ZERO_BYTE
9318 | OPTI_TYPE_NOT_ITERATED;
9319 dgst_pos0 = 0;
9320 dgst_pos1 = 1;
9321 dgst_pos2 = 2;
9322 dgst_pos3 = 3;
9323 break;
9324
9325 case 10420: hash_type = HASH_TYPE_PDFU16;
9326 salt_type = SALT_TYPE_EMBEDDED;
9327 attack_exec = ATTACK_EXEC_ON_GPU;
9328 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9329 kern_type = KERN_TYPE_PDF11CM2;
9330 dgst_size = DGST_SIZE_4_4;
9331 parse_func = pdf11cm2_parse_hash;
9332 sort_by_digest = sort_by_digest_4_4;
9333 opti_type = OPTI_TYPE_ZERO_BYTE
9334 | OPTI_TYPE_NOT_ITERATED;
9335 dgst_pos0 = 0;
9336 dgst_pos1 = 1;
9337 dgst_pos2 = 2;
9338 dgst_pos3 = 3;
9339 break;
9340
9341 case 10500: hash_type = HASH_TYPE_PDFU16;
9342 salt_type = SALT_TYPE_EMBEDDED;
9343 attack_exec = ATTACK_EXEC_ON_CPU;
9344 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9345 kern_type = KERN_TYPE_PDF14;
9346 dgst_size = DGST_SIZE_4_4;
9347 parse_func = pdf14_parse_hash;
9348 sort_by_digest = sort_by_digest_4_4;
9349 opti_type = OPTI_TYPE_ZERO_BYTE
9350 | OPTI_TYPE_NOT_ITERATED;
9351 dgst_pos0 = 0;
9352 dgst_pos1 = 1;
9353 dgst_pos2 = 2;
9354 dgst_pos3 = 3;
9355 break;
9356
9357 case 10600: hash_type = HASH_TYPE_SHA256;
9358 salt_type = SALT_TYPE_EMBEDDED;
9359 attack_exec = ATTACK_EXEC_ON_GPU;
9360 opts_type = OPTS_TYPE_PT_GENERATE_BE
9361 | OPTS_TYPE_ST_ADD80
9362 | OPTS_TYPE_ST_ADDBITS15
9363 | OPTS_TYPE_HASH_COPY;
9364 kern_type = KERN_TYPE_SHA256_PWSLT;
9365 dgst_size = DGST_SIZE_4_8;
9366 parse_func = pdf17l3_parse_hash;
9367 sort_by_digest = sort_by_digest_4_8;
9368 opti_type = OPTI_TYPE_ZERO_BYTE
9369 | OPTI_TYPE_PRECOMPUTE_INIT
9370 | OPTI_TYPE_PRECOMPUTE_MERKLE
9371 | OPTI_TYPE_EARLY_SKIP
9372 | OPTI_TYPE_NOT_ITERATED
9373 | OPTI_TYPE_APPENDED_SALT
9374 | OPTI_TYPE_RAW_HASH;
9375 dgst_pos0 = 3;
9376 dgst_pos1 = 7;
9377 dgst_pos2 = 2;
9378 dgst_pos3 = 6;
9379 break;
9380
9381 case 10700: hash_type = HASH_TYPE_PDFU32;
9382 salt_type = SALT_TYPE_EMBEDDED;
9383 attack_exec = ATTACK_EXEC_ON_CPU;
9384 opts_type = OPTS_TYPE_PT_GENERATE_LE
9385 | OPTS_TYPE_HASH_COPY;
9386 kern_type = KERN_TYPE_PDF17L8;
9387 dgst_size = DGST_SIZE_4_8;
9388 parse_func = pdf17l8_parse_hash;
9389 sort_by_digest = sort_by_digest_4_8;
9390 opti_type = OPTI_TYPE_ZERO_BYTE
9391 | OPTI_TYPE_NOT_ITERATED;
9392 dgst_pos0 = 0;
9393 dgst_pos1 = 1;
9394 dgst_pos2 = 2;
9395 dgst_pos3 = 3;
9396 break;
9397
9398 case 10800: hash_type = HASH_TYPE_SHA384;
9399 salt_type = SALT_TYPE_NONE;
9400 attack_exec = ATTACK_EXEC_ON_GPU;
9401 opts_type = OPTS_TYPE_PT_GENERATE_BE
9402 | OPTS_TYPE_PT_ADD80
9403 | OPTS_TYPE_PT_ADDBITS15;
9404 kern_type = KERN_TYPE_SHA384;
9405 dgst_size = DGST_SIZE_8_8;
9406 parse_func = sha384_parse_hash;
9407 sort_by_digest = sort_by_digest_8_8;
9408 opti_type = OPTI_TYPE_ZERO_BYTE
9409 | OPTI_TYPE_PRECOMPUTE_INIT
9410 | OPTI_TYPE_PRECOMPUTE_MERKLE
9411 | OPTI_TYPE_EARLY_SKIP
9412 | OPTI_TYPE_NOT_ITERATED
9413 | OPTI_TYPE_NOT_SALTED
9414 | OPTI_TYPE_RAW_HASH;
9415 dgst_pos0 = 6;
9416 dgst_pos1 = 7;
9417 dgst_pos2 = 4;
9418 dgst_pos3 = 5;
9419 break;
9420
9421 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9422 salt_type = SALT_TYPE_EMBEDDED;
9423 attack_exec = ATTACK_EXEC_ON_CPU;
9424 opts_type = OPTS_TYPE_PT_GENERATE_LE
9425 | OPTS_TYPE_ST_BASE64
9426 | OPTS_TYPE_HASH_COPY;
9427 kern_type = KERN_TYPE_PBKDF2_SHA256;
9428 dgst_size = DGST_SIZE_4_32;
9429 parse_func = pbkdf2_sha256_parse_hash;
9430 sort_by_digest = sort_by_digest_4_32;
9431 opti_type = OPTI_TYPE_ZERO_BYTE;
9432 dgst_pos0 = 0;
9433 dgst_pos1 = 1;
9434 dgst_pos2 = 2;
9435 dgst_pos3 = 3;
9436 break;
9437
9438 case 11000: hash_type = HASH_TYPE_MD5;
9439 salt_type = SALT_TYPE_INTERN;
9440 attack_exec = ATTACK_EXEC_ON_GPU;
9441 opts_type = OPTS_TYPE_PT_GENERATE_LE
9442 | OPTS_TYPE_PT_ADD80;
9443 kern_type = KERN_TYPE_PRESTASHOP;
9444 dgst_size = DGST_SIZE_4_4;
9445 parse_func = prestashop_parse_hash;
9446 sort_by_digest = sort_by_digest_4_4;
9447 opti_type = OPTI_TYPE_ZERO_BYTE
9448 | OPTI_TYPE_PRECOMPUTE_INIT
9449 | OPTI_TYPE_NOT_ITERATED
9450 | OPTI_TYPE_PREPENDED_SALT;
9451 dgst_pos0 = 0;
9452 dgst_pos1 = 3;
9453 dgst_pos2 = 2;
9454 dgst_pos3 = 1;
9455 break;
9456
9457 case 11100: hash_type = HASH_TYPE_MD5;
9458 salt_type = SALT_TYPE_EMBEDDED;
9459 attack_exec = ATTACK_EXEC_ON_GPU;
9460 opts_type = OPTS_TYPE_PT_GENERATE_LE
9461 | OPTS_TYPE_ST_ADD80;
9462 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9463 dgst_size = DGST_SIZE_4_4;
9464 parse_func = postgresql_auth_parse_hash;
9465 sort_by_digest = sort_by_digest_4_4;
9466 opti_type = OPTI_TYPE_ZERO_BYTE
9467 | OPTI_TYPE_PRECOMPUTE_INIT
9468 | OPTI_TYPE_PRECOMPUTE_MERKLE
9469 | OPTI_TYPE_EARLY_SKIP;
9470 dgst_pos0 = 0;
9471 dgst_pos1 = 3;
9472 dgst_pos2 = 2;
9473 dgst_pos3 = 1;
9474 break;
9475
9476 case 11200: hash_type = HASH_TYPE_SHA1;
9477 salt_type = SALT_TYPE_EMBEDDED;
9478 attack_exec = ATTACK_EXEC_ON_GPU;
9479 opts_type = OPTS_TYPE_PT_GENERATE_BE
9480 | OPTS_TYPE_PT_ADD80
9481 | OPTS_TYPE_ST_HEX;
9482 kern_type = KERN_TYPE_MYSQL_AUTH;
9483 dgst_size = DGST_SIZE_4_5;
9484 parse_func = mysql_auth_parse_hash;
9485 sort_by_digest = sort_by_digest_4_5;
9486 opti_type = OPTI_TYPE_ZERO_BYTE
9487 | OPTI_TYPE_EARLY_SKIP;
9488 dgst_pos0 = 3;
9489 dgst_pos1 = 4;
9490 dgst_pos2 = 2;
9491 dgst_pos3 = 1;
9492 break;
9493
9494 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9495 salt_type = SALT_TYPE_EMBEDDED;
9496 attack_exec = ATTACK_EXEC_ON_CPU;
9497 opts_type = OPTS_TYPE_PT_GENERATE_LE
9498 | OPTS_TYPE_ST_HEX
9499 | OPTS_TYPE_ST_ADD80;
9500 kern_type = KERN_TYPE_BITCOIN_WALLET;
9501 dgst_size = DGST_SIZE_4_4;
9502 parse_func = bitcoin_wallet_parse_hash;
9503 sort_by_digest = sort_by_digest_4_4;
9504 opti_type = OPTI_TYPE_ZERO_BYTE;
9505 dgst_pos0 = 0;
9506 dgst_pos1 = 1;
9507 dgst_pos2 = 2;
9508 dgst_pos3 = 3;
9509 break;
9510
9511 case 11400: hash_type = HASH_TYPE_MD5;
9512 salt_type = SALT_TYPE_EMBEDDED;
9513 attack_exec = ATTACK_EXEC_ON_GPU;
9514 opts_type = OPTS_TYPE_PT_GENERATE_LE
9515 | OPTS_TYPE_PT_ADD80
9516 | OPTS_TYPE_HASH_COPY;
9517 kern_type = KERN_TYPE_SIP_AUTH;
9518 dgst_size = DGST_SIZE_4_4;
9519 parse_func = sip_auth_parse_hash;
9520 sort_by_digest = sort_by_digest_4_4;
9521 opti_type = OPTI_TYPE_ZERO_BYTE;
9522 dgst_pos0 = 0;
9523 dgst_pos1 = 3;
9524 dgst_pos2 = 2;
9525 dgst_pos3 = 1;
9526 break;
9527
9528 case 11500: hash_type = HASH_TYPE_CRC32;
9529 salt_type = SALT_TYPE_INTERN;
9530 attack_exec = ATTACK_EXEC_ON_GPU;
9531 opts_type = OPTS_TYPE_PT_GENERATE_LE
9532 | OPTS_TYPE_ST_GENERATE_LE
9533 | OPTS_TYPE_ST_HEX;
9534 kern_type = KERN_TYPE_CRC32;
9535 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9536 parse_func = crc32_parse_hash;
9537 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9538 opti_type = OPTI_TYPE_ZERO_BYTE;
9539 dgst_pos0 = 0;
9540 dgst_pos1 = 1;
9541 dgst_pos2 = 2;
9542 dgst_pos3 = 3;
9543 break;
9544
9545 case 11600: hash_type = HASH_TYPE_AES;
9546 salt_type = SALT_TYPE_EMBEDDED;
9547 attack_exec = ATTACK_EXEC_ON_CPU;
9548 opts_type = OPTS_TYPE_PT_GENERATE_LE
9549 | OPTS_TYPE_PT_NEVERCRACK;
9550 kern_type = KERN_TYPE_SEVEN_ZIP;
9551 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9552 parse_func = seven_zip_parse_hash;
9553 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9554 opti_type = OPTI_TYPE_ZERO_BYTE;
9555 dgst_pos0 = 0;
9556 dgst_pos1 = 1;
9557 dgst_pos2 = 2;
9558 dgst_pos3 = 3;
9559 break;
9560
9561 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9562 salt_type = SALT_TYPE_NONE;
9563 attack_exec = ATTACK_EXEC_ON_GPU;
9564 opts_type = OPTS_TYPE_PT_GENERATE_LE
9565 | OPTS_TYPE_PT_ADD01;
9566 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9567 dgst_size = DGST_SIZE_4_8;
9568 parse_func = gost2012sbog_256_parse_hash;
9569 sort_by_digest = sort_by_digest_4_8;
9570 opti_type = OPTI_TYPE_ZERO_BYTE;
9571 dgst_pos0 = 0;
9572 dgst_pos1 = 1;
9573 dgst_pos2 = 2;
9574 dgst_pos3 = 3;
9575 break;
9576
9577 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9578 salt_type = SALT_TYPE_NONE;
9579 attack_exec = ATTACK_EXEC_ON_GPU;
9580 opts_type = OPTS_TYPE_PT_GENERATE_LE
9581 | OPTS_TYPE_PT_ADD01;
9582 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9583 dgst_size = DGST_SIZE_4_16;
9584 parse_func = gost2012sbog_512_parse_hash;
9585 sort_by_digest = sort_by_digest_4_16;
9586 opti_type = OPTI_TYPE_ZERO_BYTE;
9587 dgst_pos0 = 0;
9588 dgst_pos1 = 1;
9589 dgst_pos2 = 2;
9590 dgst_pos3 = 3;
9591 break;
9592
9593 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9594 salt_type = SALT_TYPE_EMBEDDED;
9595 attack_exec = ATTACK_EXEC_ON_CPU;
9596 opts_type = OPTS_TYPE_PT_GENERATE_LE
9597 | OPTS_TYPE_ST_BASE64
9598 | OPTS_TYPE_HASH_COPY;
9599 kern_type = KERN_TYPE_PBKDF2_MD5;
9600 dgst_size = DGST_SIZE_4_32;
9601 parse_func = pbkdf2_md5_parse_hash;
9602 sort_by_digest = sort_by_digest_4_32;
9603 opti_type = OPTI_TYPE_ZERO_BYTE;
9604 dgst_pos0 = 0;
9605 dgst_pos1 = 1;
9606 dgst_pos2 = 2;
9607 dgst_pos3 = 3;
9608 break;
9609
9610 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
9611 salt_type = SALT_TYPE_EMBEDDED;
9612 attack_exec = ATTACK_EXEC_ON_CPU;
9613 opts_type = OPTS_TYPE_PT_GENERATE_LE
9614 | OPTS_TYPE_ST_BASE64
9615 | OPTS_TYPE_HASH_COPY;
9616 kern_type = KERN_TYPE_PBKDF2_SHA1;
9617 dgst_size = DGST_SIZE_4_32;
9618 parse_func = pbkdf2_sha1_parse_hash;
9619 sort_by_digest = sort_by_digest_4_32;
9620 opti_type = OPTI_TYPE_ZERO_BYTE;
9621 dgst_pos0 = 0;
9622 dgst_pos1 = 1;
9623 dgst_pos2 = 2;
9624 dgst_pos3 = 3;
9625 break;
9626
9627 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
9628 salt_type = SALT_TYPE_EMBEDDED;
9629 attack_exec = ATTACK_EXEC_ON_CPU;
9630 opts_type = OPTS_TYPE_PT_GENERATE_LE
9631 | OPTS_TYPE_ST_BASE64
9632 | OPTS_TYPE_HASH_COPY;
9633 kern_type = KERN_TYPE_PBKDF2_SHA512;
9634 dgst_size = DGST_SIZE_8_16;
9635 parse_func = pbkdf2_sha512_parse_hash;
9636 sort_by_digest = sort_by_digest_8_16;
9637 opti_type = OPTI_TYPE_ZERO_BYTE;
9638 dgst_pos0 = 0;
9639 dgst_pos1 = 1;
9640 dgst_pos2 = 2;
9641 dgst_pos3 = 3;
9642 break;
9643
9644 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
9645 salt_type = SALT_TYPE_EMBEDDED;
9646 attack_exec = ATTACK_EXEC_ON_CPU;
9647 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9648 kern_type = KERN_TYPE_ECRYPTFS;
9649 dgst_size = DGST_SIZE_8_8;
9650 parse_func = ecryptfs_parse_hash;
9651 sort_by_digest = sort_by_digest_8_8;
9652 opti_type = OPTI_TYPE_ZERO_BYTE;
9653 dgst_pos0 = 0;
9654 dgst_pos1 = 1;
9655 dgst_pos2 = 2;
9656 dgst_pos3 = 3;
9657 break;
9658
9659 case 12300: hash_type = HASH_TYPE_ORACLET;
9660 salt_type = SALT_TYPE_EMBEDDED;
9661 attack_exec = ATTACK_EXEC_ON_CPU;
9662 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9663 kern_type = KERN_TYPE_ORACLET;
9664 dgst_size = DGST_SIZE_8_16;
9665 parse_func = oraclet_parse_hash;
9666 sort_by_digest = sort_by_digest_8_16;
9667 opti_type = OPTI_TYPE_ZERO_BYTE;
9668 dgst_pos0 = 0;
9669 dgst_pos1 = 1;
9670 dgst_pos2 = 2;
9671 dgst_pos3 = 3;
9672 break;
9673
9674 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
9675 salt_type = SALT_TYPE_EMBEDDED;
9676 attack_exec = ATTACK_EXEC_ON_CPU;
9677 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9678 kern_type = KERN_TYPE_BSDICRYPT;
9679 dgst_size = DGST_SIZE_4_4;
9680 parse_func = bsdicrypt_parse_hash;
9681 sort_by_digest = sort_by_digest_4_4;
9682 opti_type = OPTI_TYPE_ZERO_BYTE
9683 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9684 dgst_pos0 = 0;
9685 dgst_pos1 = 1;
9686 dgst_pos2 = 2;
9687 dgst_pos3 = 3;
9688 break;
9689
9690 case 12500: hash_type = HASH_TYPE_RAR3HP;
9691 salt_type = SALT_TYPE_EMBEDDED;
9692 attack_exec = ATTACK_EXEC_ON_CPU;
9693 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9694 kern_type = KERN_TYPE_RAR3;
9695 dgst_size = DGST_SIZE_4_4;
9696 parse_func = rar3hp_parse_hash;
9697 sort_by_digest = sort_by_digest_4_4;
9698 opti_type = OPTI_TYPE_ZERO_BYTE;
9699 dgst_pos0 = 0;
9700 dgst_pos1 = 1;
9701 dgst_pos2 = 2;
9702 dgst_pos3 = 3;
9703 break;
9704
9705 case 12600: hash_type = HASH_TYPE_SHA256;
9706 salt_type = SALT_TYPE_INTERN;
9707 attack_exec = ATTACK_EXEC_ON_GPU;
9708 opts_type = OPTS_TYPE_PT_GENERATE_BE
9709 | OPTS_TYPE_PT_ADD80;
9710 kern_type = KERN_TYPE_CF10;
9711 dgst_size = DGST_SIZE_4_8;
9712 parse_func = cf10_parse_hash;
9713 sort_by_digest = sort_by_digest_4_8;
9714 opti_type = OPTI_TYPE_ZERO_BYTE
9715 | OPTI_TYPE_PRECOMPUTE_INIT
9716 | OPTI_TYPE_EARLY_SKIP
9717 | OPTI_TYPE_NOT_ITERATED;
9718 dgst_pos0 = 3;
9719 dgst_pos1 = 7;
9720 dgst_pos2 = 2;
9721 dgst_pos3 = 6;
9722 break;
9723
9724 case 12700: hash_type = HASH_TYPE_AES;
9725 salt_type = SALT_TYPE_EMBEDDED;
9726 attack_exec = ATTACK_EXEC_ON_CPU;
9727 opts_type = OPTS_TYPE_PT_GENERATE_LE
9728 | OPTS_TYPE_HASH_COPY;
9729 kern_type = KERN_TYPE_MYWALLET;
9730 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9731 parse_func = mywallet_parse_hash;
9732 sort_by_digest = sort_by_digest_4_5;
9733 opti_type = OPTI_TYPE_ZERO_BYTE;
9734 dgst_pos0 = 0;
9735 dgst_pos1 = 1;
9736 dgst_pos2 = 2;
9737 dgst_pos3 = 3;
9738 break;
9739
9740 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
9741 salt_type = SALT_TYPE_EMBEDDED;
9742 attack_exec = ATTACK_EXEC_ON_CPU;
9743 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9744 kern_type = KERN_TYPE_MS_DRSR;
9745 dgst_size = DGST_SIZE_4_8;
9746 parse_func = ms_drsr_parse_hash;
9747 sort_by_digest = sort_by_digest_4_8;
9748 opti_type = OPTI_TYPE_ZERO_BYTE;
9749 dgst_pos0 = 0;
9750 dgst_pos1 = 1;
9751 dgst_pos2 = 2;
9752 dgst_pos3 = 3;
9753 break;
9754
9755 default: usage_mini_print (PROGNAME); return (-1);
9756 }
9757
9758 /**
9759 * transpose
9760 */
9761
9762 data.parse_func = parse_func;
9763
9764 /**
9765 * misc stuff
9766 */
9767
9768 if (hex_salt)
9769 {
9770 if (salt_type == SALT_TYPE_INTERN)
9771 {
9772 opts_type |= OPTS_TYPE_ST_HEX;
9773 }
9774 else
9775 {
9776 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
9777
9778 return (-1);
9779 }
9780 }
9781
9782 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
9783 | (salt_type == SALT_TYPE_EXTERN)
9784 | (salt_type == SALT_TYPE_EMBEDDED)
9785 | (salt_type == SALT_TYPE_VIRTUAL));
9786
9787 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
9788
9789 data.hash_type = hash_type;
9790 data.attack_mode = attack_mode;
9791 data.attack_kern = attack_kern;
9792 data.attack_exec = attack_exec;
9793 data.kern_type = kern_type;
9794 data.opts_type = opts_type;
9795 data.dgst_size = dgst_size;
9796 data.salt_type = salt_type;
9797 data.isSalted = isSalted;
9798 data.sort_by_digest = sort_by_digest;
9799 data.dgst_pos0 = dgst_pos0;
9800 data.dgst_pos1 = dgst_pos1;
9801 data.dgst_pos2 = dgst_pos2;
9802 data.dgst_pos3 = dgst_pos3;
9803
9804 esalt_size = 0;
9805
9806 switch (hash_mode)
9807 {
9808 case 2500: esalt_size = sizeof (wpa_t); break;
9809 case 5300: esalt_size = sizeof (ikepsk_t); break;
9810 case 5400: esalt_size = sizeof (ikepsk_t); break;
9811 case 5500: esalt_size = sizeof (netntlm_t); break;
9812 case 5600: esalt_size = sizeof (netntlm_t); break;
9813 case 6211:
9814 case 6212:
9815 case 6213:
9816 case 6221:
9817 case 6222:
9818 case 6223:
9819 case 6231:
9820 case 6232:
9821 case 6233:
9822 case 6241:
9823 case 6242:
9824 case 6243: esalt_size = sizeof (tc_t); break;
9825 case 6600: esalt_size = sizeof (agilekey_t); break;
9826 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
9827 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
9828 case 7300: esalt_size = sizeof (rakp_t); break;
9829 case 7500: esalt_size = sizeof (krb5pa_t); break;
9830 case 8200: esalt_size = sizeof (cloudkey_t); break;
9831 case 8800: esalt_size = sizeof (androidfde_t); break;
9832 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
9833 case 9400: esalt_size = sizeof (office2007_t); break;
9834 case 9500: esalt_size = sizeof (office2010_t); break;
9835 case 9600: esalt_size = sizeof (office2013_t); break;
9836 case 9700: esalt_size = sizeof (oldoffice01_t); break;
9837 case 9710: esalt_size = sizeof (oldoffice01_t); break;
9838 case 9720: esalt_size = sizeof (oldoffice01_t); break;
9839 case 9800: esalt_size = sizeof (oldoffice34_t); break;
9840 case 9810: esalt_size = sizeof (oldoffice34_t); break;
9841 case 9820: esalt_size = sizeof (oldoffice34_t); break;
9842 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
9843 case 10200: esalt_size = sizeof (cram_md5_t); break;
9844 case 10400: esalt_size = sizeof (pdf_t); break;
9845 case 10410: esalt_size = sizeof (pdf_t); break;
9846 case 10420: esalt_size = sizeof (pdf_t); break;
9847 case 10500: esalt_size = sizeof (pdf_t); break;
9848 case 10600: esalt_size = sizeof (pdf_t); break;
9849 case 10700: esalt_size = sizeof (pdf_t); break;
9850 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
9851 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
9852 case 11400: esalt_size = sizeof (sip_t); break;
9853 case 11600: esalt_size = sizeof (seven_zip_t); break;
9854 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
9855 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
9856 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
9857 }
9858
9859 data.esalt_size = esalt_size;
9860
9861 /**
9862 * choose dictionary parser
9863 */
9864
9865 if (hash_type == HASH_TYPE_LM)
9866 {
9867 get_next_word_func = get_next_word_lm;
9868 }
9869 else if (opts_type & OPTS_TYPE_PT_UPPER)
9870 {
9871 get_next_word_func = get_next_word_uc;
9872 }
9873 else
9874 {
9875 get_next_word_func = get_next_word_std;
9876 }
9877
9878 /**
9879 * dictstat
9880 */
9881
9882 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
9883
9884 #ifdef _POSIX
9885 size_t dictstat_nmemb = 0;
9886 #endif
9887
9888 #ifdef _WIN
9889 uint dictstat_nmemb = 0;
9890 #endif
9891
9892 char dictstat[256];
9893
9894 FILE *dictstat_fp = NULL;
9895
9896 if (keyspace == 0)
9897 {
9898 memset (dictstat, 0, sizeof (dictstat));
9899
9900 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s.dictstat", install_dir, PROGNAME);
9901
9902 dictstat_fp = fopen (dictstat, "rb");
9903
9904 if (dictstat_fp)
9905 {
9906 #ifdef _POSIX
9907 struct stat tmpstat;
9908
9909 fstat (fileno (dictstat_fp), &tmpstat);
9910 #endif
9911
9912 #ifdef _WIN
9913 struct stat64 tmpstat;
9914
9915 _fstat64 (fileno (dictstat_fp), &tmpstat);
9916 #endif
9917
9918 if (tmpstat.st_mtime < COMPTIME)
9919 {
9920 /* with v0.15 the format changed so we have to ensure user is using a good version
9921 since there is no version-header in the dictstat file */
9922
9923 fclose (dictstat_fp);
9924
9925 unlink (dictstat);
9926 }
9927 else
9928 {
9929 while (!feof (dictstat_fp))
9930 {
9931 dictstat_t d;
9932
9933 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
9934
9935 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
9936
9937 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
9938 {
9939 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
9940
9941 return -1;
9942 }
9943 }
9944
9945 fclose (dictstat_fp);
9946 }
9947 }
9948 }
9949
9950 /**
9951 * potfile
9952 */
9953
9954 char potfile[256];
9955
9956 memset (potfile, 0, sizeof (potfile));
9957
9958 snprintf (potfile, sizeof (potfile) - 1, "%s.pot", session);
9959
9960 data.pot_fp = NULL;
9961
9962 FILE *out_fp = NULL;
9963 FILE *pot_fp = NULL;
9964
9965 if (show == 1 || left == 1)
9966 {
9967 pot_fp = fopen (potfile, "rb");
9968
9969 if (pot_fp == NULL)
9970 {
9971 log_error ("ERROR: %s: %s", potfile, strerror (errno));
9972
9973 return (-1);
9974 }
9975
9976 if (outfile != NULL)
9977 {
9978 if ((out_fp = fopen (outfile, "ab")) == NULL)
9979 {
9980 log_error ("ERROR: %s: %s", outfile, strerror (errno));
9981
9982 fclose (pot_fp);
9983
9984 return (-1);
9985 }
9986 }
9987 else
9988 {
9989 out_fp = stdout;
9990 }
9991 }
9992 else
9993 {
9994 if (potfile_disable == 0)
9995 {
9996 pot_fp = fopen (potfile, "ab");
9997
9998 if (pot_fp == NULL)
9999 {
10000 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10001
10002 return (-1);
10003 }
10004
10005 data.pot_fp = pot_fp;
10006 }
10007 }
10008
10009 pot_t *pot = NULL;
10010
10011 uint pot_cnt = 0;
10012 uint pot_avail = 0;
10013
10014 if (show == 1 || left == 1)
10015 {
10016 SUPPRESS_OUTPUT = 1;
10017
10018 pot_avail = count_lines (pot_fp);
10019
10020 rewind (pot_fp);
10021
10022 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10023
10024 uint pot_hashes_avail = 0;
10025
10026 uint line_num = 0;
10027
10028 while (!feof (pot_fp))
10029 {
10030 line_num++;
10031
10032 char line_buf[BUFSIZ];
10033
10034 int line_len = fgetl (pot_fp, line_buf);
10035
10036 if (line_len == 0) continue;
10037
10038 char *plain_buf = line_buf + line_len;
10039
10040 pot_t *pot_ptr = &pot[pot_cnt];
10041
10042 hash_t *hashes_buf = &pot_ptr->hash;
10043
10044 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10045 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10046
10047 if (pot_cnt == pot_hashes_avail)
10048 {
10049 uint pos = 0;
10050
10051 for (pos = 0; pos < INCR_POT; pos++)
10052 {
10053 if ((pot_cnt + pos) >= pot_avail) break;
10054
10055 pot_t *tmp_pot = &pot[pot_cnt + pos];
10056
10057 hash_t *tmp_hash = &tmp_pot->hash;
10058
10059 tmp_hash->digest = mymalloc (dgst_size);
10060
10061 if (isSalted)
10062 {
10063 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10064 }
10065
10066 if (esalt_size)
10067 {
10068 tmp_hash->esalt = mymalloc (esalt_size);
10069 }
10070
10071 pot_hashes_avail++;
10072 }
10073 }
10074
10075 int plain_len = 0;
10076
10077 int parser_status;
10078
10079 int iter = MAX_CUT_TRIES;
10080
10081 do
10082 {
10083 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10084 {
10085 if (line_buf[i] == ':')
10086 {
10087 line_len--;
10088
10089 break;
10090 }
10091 }
10092
10093 if (data.hash_mode != 2500)
10094 {
10095 parser_status = parse_func (line_buf, line_len, hashes_buf);
10096 }
10097 else
10098 {
10099 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10100
10101 if (line_len > max_salt_size)
10102 {
10103 parser_status = PARSER_GLOBAL_LENGTH;
10104 }
10105 else
10106 {
10107 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10108
10109 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10110
10111 hashes_buf->salt->salt_len = line_len;
10112
10113 parser_status = PARSER_OK;
10114 }
10115 }
10116
10117 // if NOT parsed without error, we add the ":" to the plain
10118
10119 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10120 {
10121 plain_len++;
10122 plain_buf--;
10123 }
10124
10125 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10126
10127 if (parser_status < PARSER_GLOBAL_ZERO)
10128 {
10129 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10130
10131 continue;
10132 }
10133
10134 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10135
10136 pot_ptr->plain_len = plain_len;
10137
10138 pot_cnt++;
10139 }
10140
10141 fclose (pot_fp);
10142
10143 SUPPRESS_OUTPUT = 0;
10144
10145 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10146 }
10147
10148 /**
10149 * gpu accel and loops auto adjustment
10150 */
10151
10152 if (gpu_accel_chgd == 0) gpu_accel = set_gpu_accel (hash_mode);
10153 if (gpu_loops_chgd == 0) gpu_loops = set_gpu_loops (hash_mode);
10154
10155 if (workload_profile == 1)
10156 {
10157 gpu_loops /= 8;
10158 gpu_accel /= 4;
10159
10160 if (gpu_loops == 0) gpu_loops = 8;
10161 if (gpu_accel == 0) gpu_accel = 2;
10162 }
10163 else if (workload_profile == 3)
10164 {
10165 gpu_loops *= 8;
10166 gpu_accel *= 4;
10167
10168 if (gpu_loops > 1024) gpu_loops = 1024;
10169 if (gpu_accel > 256) gpu_accel = 256; // causes memory problems otherwise
10170 }
10171
10172 // those hashes *must* run at a specific gpu_loops count because of some optimization inside the kernel
10173
10174 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
10175 {
10176 gpu_loops = 1024;
10177 }
10178
10179 if (hash_mode == 12500)
10180 {
10181 gpu_loops = ROUNDS_RAR3 / 16;
10182 }
10183
10184 data.gpu_accel = gpu_accel;
10185 data.gpu_loops = gpu_loops;
10186
10187 /**
10188 * word len
10189 */
10190
10191 uint pw_min = PW_MIN;
10192 uint pw_max = PW_MAX;
10193
10194 switch (hash_mode)
10195 {
10196 case 400: if (pw_max > 40) pw_max = 40;
10197 break;
10198 case 500: if (pw_max > 16) pw_max = 16;
10199 break;
10200 case 1500: if (pw_max > 8) pw_max = 8;
10201 break;
10202 case 1600: if (pw_max > 16) pw_max = 16;
10203 break;
10204 case 1800: if (pw_max > 16) pw_max = 16;
10205 break;
10206 case 2100: if (pw_max > 16) pw_max = 16;
10207 break;
10208 case 2500: if (pw_min < 8) pw_min = 8;
10209 break;
10210 case 3000: if (pw_max > 7) pw_max = 7;
10211 break;
10212 case 5200: if (pw_max > 24) pw_max = 24;
10213 break;
10214 case 5800: if (pw_max > 16) pw_max = 16;
10215 break;
10216 case 6300: if (pw_max > 16) pw_max = 16;
10217 break;
10218 case 7400: if (pw_max > 16) pw_max = 16;
10219 break;
10220 case 7900: if (pw_max > 48) pw_max = 48;
10221 break;
10222 case 8500: if (pw_max > 8) pw_max = 8;
10223 break;
10224 case 8600: if (pw_max > 16) pw_max = 16;
10225 break;
10226 case 9710: pw_min = 5;
10227 pw_max = 5;
10228 break;
10229 case 9810: pw_min = 5;
10230 pw_max = 5;
10231 break;
10232 case 10410: pw_min = 5;
10233 pw_max = 5;
10234 break;
10235 case 10300: if (pw_max < 3) pw_min = 3;
10236 if (pw_max > 40) pw_max = 40;
10237 break;
10238 case 10500: if (pw_max < 3) pw_min = 3;
10239 if (pw_max > 40) pw_max = 40;
10240 break;
10241 case 10700: if (pw_max > 16) pw_max = 16;
10242 break;
10243 case 11300: if (pw_max > 40) pw_max = 40;
10244 break;
10245 case 12500: if (pw_max > 20) pw_max = 20;
10246 break;
10247 case 12800: if (pw_max > 24) pw_max = 24;
10248 break;
10249 }
10250
10251 if (attack_exec == ATTACK_EXEC_ON_GPU)
10252 {
10253 switch (attack_kern)
10254 {
10255 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10256 break;
10257 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10258 break;
10259 }
10260 }
10261
10262 /**
10263 * charsets : keep them together for more easy maintainnce
10264 */
10265
10266 cs_t mp_sys[6];
10267 cs_t mp_usr[4];
10268
10269 memset (mp_sys, 0, sizeof (mp_sys));
10270 memset (mp_usr, 0, sizeof (mp_usr));
10271
10272 mp_setup_sys (mp_sys);
10273
10274 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10275 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10276 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10277 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10278
10279 /**
10280 * load hashes, part I: find input mode, count hashes
10281 */
10282
10283 uint hashlist_mode = 0;
10284 uint hashlist_format = HLFMT_HASHCAT;
10285
10286 uint hashes_avail = 0;
10287
10288 if (benchmark == 0)
10289 {
10290 struct stat f;
10291
10292 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10293
10294 if ((hash_mode == 2500) ||
10295 (hash_mode == 5200) ||
10296 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10297 (hash_mode == 9000))
10298 {
10299 hashlist_mode = HL_MODE_ARG;
10300
10301 char *hashfile = myargv[optind];
10302
10303 data.hashfile = hashfile;
10304
10305 logfile_top_var_string ("target", hashfile);
10306 }
10307
10308 if (hashlist_mode == HL_MODE_ARG)
10309 {
10310 if (hash_mode == 2500)
10311 {
10312 struct stat st;
10313
10314 if (stat (data.hashfile, &st) == -1)
10315 {
10316 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10317
10318 return (-1);
10319 }
10320
10321 hashes_avail = st.st_size / sizeof (hccap_t);
10322 }
10323 else
10324 {
10325 hashes_avail = 1;
10326 }
10327 }
10328 else if (hashlist_mode == HL_MODE_FILE)
10329 {
10330 char *hashfile = myargv[optind];
10331
10332 data.hashfile = hashfile;
10333
10334 logfile_top_var_string ("target", hashfile);
10335
10336 FILE *fp = NULL;
10337
10338 if ((fp = fopen (hashfile, "rb")) == NULL)
10339 {
10340 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10341
10342 return (-1);
10343 }
10344
10345 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10346
10347 hashes_avail = count_lines (fp);
10348
10349 rewind (fp);
10350
10351 if (hashes_avail == 0)
10352 {
10353 log_error ("ERROR: hashfile is empty or corrupt");
10354
10355 fclose (fp);
10356
10357 return (-1);
10358 }
10359
10360 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10361
10362 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10363 {
10364 log_error ("ERROR: remove not supported in native hashfile-format mode");
10365
10366 fclose (fp);
10367
10368 return (-1);
10369 }
10370
10371 fclose (fp);
10372 }
10373 }
10374 else
10375 {
10376 hashlist_mode = HL_MODE_ARG;
10377
10378 hashes_avail = 1;
10379 }
10380
10381 if (hash_mode == 3000) hashes_avail *= 2;
10382
10383 data.hashlist_mode = hashlist_mode;
10384 data.hashlist_format = hashlist_format;
10385
10386 logfile_top_uint (hashlist_mode);
10387 logfile_top_uint (hashlist_format);
10388
10389 /**
10390 * load hashes, part II: allocate required memory, set pointers
10391 */
10392
10393 hash_t *hashes_buf = NULL;
10394 void *digests_buf = NULL;
10395 salt_t *salts_buf = NULL;
10396 void *esalts_buf = NULL;
10397
10398 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10399
10400 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10401
10402 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10403 {
10404 uint32_t hash_pos;
10405
10406 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10407 {
10408 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10409
10410 hashes_buf[hash_pos].hash_info = hash_info;
10411
10412 if (username && (remove || show || left))
10413 {
10414 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10415 }
10416
10417 if (benchmark)
10418 {
10419 hash_info->orighash = (char *) mymalloc (256);
10420 }
10421 }
10422 }
10423
10424 if (isSalted)
10425 {
10426 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10427
10428 if (esalt_size)
10429 {
10430 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10431 }
10432 }
10433 else
10434 {
10435 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10436 }
10437
10438 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10439 {
10440 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10441
10442 if (isSalted)
10443 {
10444 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10445
10446 if (esalt_size)
10447 {
10448 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10449 }
10450 }
10451 else
10452 {
10453 hashes_buf[hash_pos].salt = &salts_buf[0];
10454 }
10455 }
10456
10457 /**
10458 * load hashes, part III: parse hashes or generate them if benchmark
10459 */
10460
10461 uint hashes_cnt = 0;
10462
10463 if (benchmark == 0)
10464 {
10465 if (keyspace == 1)
10466 {
10467 // useless to read hash file for keyspace, cheat a little bit w/ optind
10468 }
10469 else if (hashes_avail == 0)
10470 {
10471 }
10472 else if (hashlist_mode == HL_MODE_ARG)
10473 {
10474 char *input_buf = myargv[optind];
10475
10476 uint input_len = strlen (input_buf);
10477
10478 logfile_top_var_string ("target", input_buf);
10479
10480 char *hash_buf = NULL;
10481 int hash_len = 0;
10482
10483 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10484
10485 if (hash_len)
10486 {
10487 if (opts_type & OPTS_TYPE_HASH_COPY)
10488 {
10489 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10490
10491 hash_info_tmp->orighash = mystrdup (hash_buf);
10492 }
10493
10494 if (isSalted)
10495 {
10496 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10497 }
10498
10499 int parser_status = PARSER_OK;
10500
10501 if (hash_mode == 2500)
10502 {
10503 if (hash_len == 0)
10504 {
10505 log_error ("ERROR: hccap file not specified");
10506
10507 return (-1);
10508 }
10509
10510 hashlist_mode = HL_MODE_FILE;
10511
10512 data.hashlist_mode = hashlist_mode;
10513
10514 FILE *fp = fopen (hash_buf, "rb");
10515
10516 if (fp == NULL)
10517 {
10518 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10519
10520 return (-1);
10521 }
10522
10523 if (hashes_avail < 1)
10524 {
10525 log_error ("ERROR: hccap file is empty or corrupt");
10526
10527 fclose (fp);
10528
10529 return (-1);
10530 }
10531
10532 uint hccap_size = sizeof (hccap_t);
10533
10534 char in[hccap_size];
10535
10536 while (!feof (fp))
10537 {
10538 int n = fread (&in, hccap_size, 1, fp);
10539
10540 if (n != 1)
10541 {
10542 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
10543
10544 break;
10545 }
10546
10547 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
10548
10549 if (parser_status != PARSER_OK)
10550 {
10551 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
10552
10553 continue;
10554 }
10555
10556 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
10557
10558 if ((show == 1) || (left == 1))
10559 {
10560 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
10561
10562 char *salt_ptr = (char *) tmp_salt->salt_buf;
10563
10564 int cur_pos = tmp_salt->salt_len;
10565 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10566
10567 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
10568
10569 unsigned char *pke_ptr = (unsigned char *) wpa->pke;
10570
10571 // do the appending task
10572
10573 snprintf (salt_ptr + cur_pos,
10574 rem_len,
10575 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
10576 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
10577 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
10578
10579
10580 // memset () the remaining part of the salt
10581
10582 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
10583 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10584
10585 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
10586
10587 tmp_salt->salt_len += 1 + 12 + 1 + 12;
10588 }
10589
10590 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);
10591 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);
10592
10593 hashes_cnt++;
10594 }
10595
10596 fclose (fp);
10597 }
10598 else if (hash_mode == 3000)
10599 {
10600 if (hash_len == 32)
10601 {
10602 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10603
10604 hash_t *lm_hash_left = NULL;
10605
10606 if (parser_status == PARSER_OK)
10607 {
10608 lm_hash_left = &hashes_buf[hashes_cnt];
10609
10610 hashes_cnt++;
10611 }
10612 else
10613 {
10614 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10615 }
10616
10617
10618 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10619
10620 hash_t *lm_hash_right = NULL;
10621
10622 if (parser_status == PARSER_OK)
10623 {
10624 lm_hash_right = &hashes_buf[hashes_cnt];
10625
10626 hashes_cnt++;
10627 }
10628 else
10629 {
10630 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10631 }
10632
10633 // show / left
10634
10635 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
10636 {
10637 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);
10638 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);
10639 }
10640 }
10641 else
10642 {
10643 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10644
10645 if (parser_status == PARSER_OK)
10646 {
10647 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10648 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10649 }
10650
10651 if (parser_status == PARSER_OK)
10652 {
10653 hashes_cnt++;
10654 }
10655 else
10656 {
10657 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10658 }
10659 }
10660 }
10661 else
10662 {
10663 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10664
10665 if (parser_status == PARSER_OK)
10666 {
10667 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10668 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10669 }
10670
10671 if (parser_status == PARSER_OK)
10672 {
10673 hashes_cnt++;
10674 }
10675 else
10676 {
10677 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10678 }
10679 }
10680 }
10681 }
10682 else if (hashlist_mode == HL_MODE_FILE)
10683 {
10684 char *hashfile = data.hashfile;
10685
10686 FILE *fp;
10687
10688 if ((fp = fopen (hashfile, "rb")) == NULL)
10689 {
10690 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10691
10692 return (-1);
10693 }
10694
10695 uint line_num = 0;
10696
10697 while (!feof (fp))
10698 {
10699 line_num++;
10700
10701 char line_buf[BUFSIZ];
10702
10703 int line_len = fgetl (fp, line_buf);
10704
10705 if (line_len == 0) continue;
10706
10707 char *hash_buf = NULL;
10708 int hash_len = 0;
10709
10710 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
10711
10712 if (username)
10713 {
10714 char *user_buf = NULL;
10715 int user_len = 0;
10716
10717 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
10718
10719 if (remove || show)
10720 {
10721 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
10722
10723 *user = (user_t *) malloc (sizeof (user_t));
10724
10725 user_t *user_ptr = *user;
10726
10727 if (user_buf != NULL)
10728 {
10729 user_ptr->user_name = mystrdup (user_buf);
10730 }
10731 else
10732 {
10733 user_ptr->user_name = mystrdup ("");
10734 }
10735
10736 user_ptr->user_len = user_len;
10737 }
10738 }
10739
10740 if (opts_type & OPTS_TYPE_HASH_COPY)
10741 {
10742 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10743
10744 hash_info_tmp->orighash = mystrdup (hash_buf);
10745 }
10746
10747 if (isSalted)
10748 {
10749 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
10750 }
10751
10752 if (hash_mode == 3000)
10753 {
10754 if (hash_len == 32)
10755 {
10756 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10757
10758 if (parser_status < PARSER_GLOBAL_ZERO)
10759 {
10760 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10761
10762 continue;
10763 }
10764
10765 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
10766
10767 hashes_cnt++;
10768
10769 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10770
10771 if (parser_status < PARSER_GLOBAL_ZERO)
10772 {
10773 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10774
10775 continue;
10776 }
10777
10778 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
10779
10780 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);
10781
10782 hashes_cnt++;
10783
10784 // show / left
10785
10786 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);
10787 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);
10788 }
10789 else
10790 {
10791 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10792
10793 if (parser_status < PARSER_GLOBAL_ZERO)
10794 {
10795 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10796
10797 continue;
10798 }
10799
10800 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);
10801
10802 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10803 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10804
10805 hashes_cnt++;
10806 }
10807 }
10808 else
10809 {
10810 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10811
10812 if (parser_status < PARSER_GLOBAL_ZERO)
10813 {
10814 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10815
10816 continue;
10817 }
10818
10819 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);
10820
10821 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10822 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10823
10824 hashes_cnt++;
10825 }
10826 }
10827
10828 fclose (fp);
10829
10830 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
10831
10832 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
10833 }
10834 }
10835 else
10836 {
10837 if (isSalted)
10838 {
10839 hashes_buf[0].salt->salt_len = 8;
10840
10841 // special salt handling
10842
10843 switch (hash_mode)
10844 {
10845 case 1500: hashes_buf[0].salt->salt_len = 2;
10846 break;
10847 case 1731: hashes_buf[0].salt->salt_len = 4;
10848 break;
10849 case 2410: hashes_buf[0].salt->salt_len = 4;
10850 break;
10851 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
10852 break;
10853 case 3100: hashes_buf[0].salt->salt_len = 1;
10854 break;
10855 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
10856 break;
10857 case 5800: hashes_buf[0].salt->salt_len = 16;
10858 break;
10859 case 6800: hashes_buf[0].salt->salt_len = 32;
10860 break;
10861 case 8400: hashes_buf[0].salt->salt_len = 40;
10862 break;
10863 case 8800: hashes_buf[0].salt->salt_len = 16;
10864 break;
10865 case 8900: hashes_buf[0].salt->salt_len = 16;
10866 hashes_buf[0].salt->scrypt_N = 1024;
10867 hashes_buf[0].salt->scrypt_r = 1;
10868 hashes_buf[0].salt->scrypt_p = 1;
10869 break;
10870 case 9100: hashes_buf[0].salt->salt_len = 16;
10871 break;
10872 case 9300: hashes_buf[0].salt->salt_len = 14;
10873 hashes_buf[0].salt->scrypt_N = 16384;
10874 hashes_buf[0].salt->scrypt_r = 1;
10875 hashes_buf[0].salt->scrypt_p = 1;
10876 break;
10877 case 9400: hashes_buf[0].salt->salt_len = 16;
10878 break;
10879 case 9500: hashes_buf[0].salt->salt_len = 16;
10880 break;
10881 case 9600: hashes_buf[0].salt->salt_len = 16;
10882 break;
10883 case 9700: hashes_buf[0].salt->salt_len = 16;
10884 break;
10885 case 9710: hashes_buf[0].salt->salt_len = 16;
10886 break;
10887 case 9720: hashes_buf[0].salt->salt_len = 16;
10888 break;
10889 case 9800: hashes_buf[0].salt->salt_len = 16;
10890 break;
10891 case 9810: hashes_buf[0].salt->salt_len = 16;
10892 break;
10893 case 9820: hashes_buf[0].salt->salt_len = 16;
10894 break;
10895 case 10300: hashes_buf[0].salt->salt_len = 12;
10896 break;
10897 case 11500: hashes_buf[0].salt->salt_len = 4;
10898 break;
10899 case 11600: hashes_buf[0].salt->salt_len = 4;
10900 break;
10901 case 12400: hashes_buf[0].salt->salt_len = 4;
10902 break;
10903 case 12500: hashes_buf[0].salt->salt_len = 8;
10904 break;
10905 case 12600: hashes_buf[0].salt->salt_len = 64;
10906 break;
10907 }
10908
10909 // special esalt handling
10910
10911 switch (hash_mode)
10912 {
10913 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
10914 break;
10915 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
10916 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
10917 break;
10918 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
10919 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
10920 break;
10921 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
10922 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
10923 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
10924 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
10925 break;
10926 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
10927 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
10928 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
10929 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
10930 break;
10931 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
10932 break;
10933 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10934 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
10935 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
10936 break;
10937 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10938 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
10939 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
10940 break;
10941 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10942 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
10943 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
10944 break;
10945 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10946 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
10947 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
10948 break;
10949 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10950 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
10951 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
10952 break;
10953 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10954 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
10955 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
10956 break;
10957 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
10958 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
10959 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
10960 break;
10961 }
10962 }
10963
10964 // set hashfile
10965
10966 switch (hash_mode)
10967 {
10968 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
10969 break;
10970 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
10971 break;
10972 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
10973 break;
10974 case 6211:
10975 case 6212:
10976 case 6213:
10977 case 6221:
10978 case 6222:
10979 case 6223:
10980 case 6231:
10981 case 6232:
10982 case 6233:
10983 case 6241:
10984 case 6242:
10985 case 6243: data.hashfile = mystrdup ("hashcat.tc");
10986 break;
10987 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
10988 break;
10989 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
10990 break;
10991 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
10992 break;
10993 }
10994
10995 // set default iterations
10996
10997 switch (hash_mode)
10998 {
10999 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11000 break;
11001 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11002 break;
11003 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11004 break;
11005 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11006 break;
11007 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11008 break;
11009 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11010 break;
11011 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11012 break;
11013 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11014 break;
11015 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11016 break;
11017 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11018 break;
11019 case 6211:
11020 case 6212:
11021 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11022 break;
11023 case 6221:
11024 case 6222:
11025 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11026 break;
11027 case 6231:
11028 case 6232:
11029 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11030 break;
11031 case 6241:
11032 case 6242:
11033 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11034 break;
11035 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11036 break;
11037 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11038 break;
11039 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11040 break;
11041 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11042 break;
11043 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11044 break;
11045 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11046 break;
11047 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11048 break;
11049 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11050 break;
11051 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11052 break;
11053 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11054 break;
11055 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11056 break;
11057 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11058 break;
11059 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11060 break;
11061 case 8900: hashes_buf[0].salt->salt_iter = 1;
11062 break;
11063 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11064 break;
11065 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11066 break;
11067 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11068 break;
11069 case 9300: hashes_buf[0].salt->salt_iter = 1;
11070 break;
11071 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11072 break;
11073 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11074 break;
11075 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11076 break;
11077 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11078 break;
11079 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11080 break;
11081 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11082 break;
11083 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11084 break;
11085 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11086 break;
11087 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11088 break;
11089 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11090 break;
11091 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11092 break;
11093 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11094 break;
11095 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11096 break;
11097 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11098 break;
11099 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11100 break;
11101 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11102 break;
11103 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11104 break;
11105 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11106 break;
11107 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11108 break;
11109 }
11110
11111 // set special tuning for benchmark-mode 1
11112
11113 if (benchmark_mode == 1)
11114 {
11115 gpu_loops *= 8;
11116 gpu_accel *= 4;
11117
11118 switch (hash_mode)
11119 {
11120 case 400: gpu_loops = ROUNDS_PHPASS;
11121 gpu_accel = 32;
11122 break;
11123 case 500: gpu_loops = ROUNDS_MD5CRYPT;
11124 gpu_accel = 32;
11125 break;
11126 case 501: gpu_loops = ROUNDS_MD5CRYPT;
11127 gpu_accel = 32;
11128 break;
11129 case 1600: gpu_loops = ROUNDS_MD5CRYPT;
11130 gpu_accel = 32;
11131 break;
11132 case 1800: gpu_loops = ROUNDS_SHA512CRYPT;
11133 gpu_accel = 16;
11134 break;
11135 case 2100: gpu_loops = ROUNDS_DCC2;
11136 gpu_accel = 16;
11137 break;
11138 case 2500: gpu_loops = ROUNDS_WPA2;
11139 gpu_accel = 32;
11140 break;
11141 case 3200: gpu_loops = ROUNDS_BCRYPT;
11142 gpu_accel = 8;
11143 break;
11144 case 5200: gpu_loops = ROUNDS_PSAFE3;
11145 gpu_accel = 16;
11146 break;
11147 case 5800: gpu_loops = ROUNDS_ANDROIDPIN;
11148 gpu_accel = 16;
11149 break;
11150 case 6211: gpu_loops = ROUNDS_TRUECRYPT_2K;
11151 gpu_accel = 64;
11152 break;
11153 case 6212: gpu_loops = ROUNDS_TRUECRYPT_2K;
11154 gpu_accel = 32;
11155 break;
11156 case 6213: gpu_loops = ROUNDS_TRUECRYPT_2K;
11157 gpu_accel = 32;
11158 break;
11159 case 6221: gpu_loops = ROUNDS_TRUECRYPT_1K;
11160 gpu_accel = 8;
11161 break;
11162 case 6222: gpu_loops = ROUNDS_TRUECRYPT_1K;
11163 gpu_accel = 8;
11164 break;
11165 case 6223: gpu_loops = ROUNDS_TRUECRYPT_1K;
11166 gpu_accel = 8;
11167 break;
11168 case 6231: gpu_loops = ROUNDS_TRUECRYPT_1K;
11169 gpu_accel = 8;
11170 break;
11171 case 6232: gpu_loops = ROUNDS_TRUECRYPT_1K;
11172 gpu_accel = 8;
11173 break;
11174 case 6233: gpu_loops = ROUNDS_TRUECRYPT_1K;
11175 gpu_accel = 8;
11176 break;
11177 case 6241: gpu_loops = ROUNDS_TRUECRYPT_1K;
11178 gpu_accel = 128;
11179 break;
11180 case 6242: gpu_loops = ROUNDS_TRUECRYPT_1K;
11181 gpu_accel = 64;
11182 break;
11183 case 6243: gpu_loops = ROUNDS_TRUECRYPT_1K;
11184 gpu_accel = 64;
11185 break;
11186 case 6300: gpu_loops = ROUNDS_MD5CRYPT;
11187 gpu_accel = 32;
11188 break;
11189 case 6700: gpu_loops = ROUNDS_SHA1AIX;
11190 gpu_accel = 128;
11191 break;
11192 case 6400: gpu_loops = ROUNDS_SHA256AIX;
11193 gpu_accel = 128;
11194 break;
11195 case 6500: gpu_loops = ROUNDS_SHA512AIX;
11196 gpu_accel = 32;
11197 break;
11198 case 6600: gpu_loops = ROUNDS_AGILEKEY;
11199 gpu_accel = 64;
11200 break;
11201 case 6800: gpu_loops = ROUNDS_LASTPASS;
11202 gpu_accel = 64;
11203 break;
11204 case 7100: gpu_loops = ROUNDS_SHA512OSX;
11205 gpu_accel = 8;
11206 break;
11207 case 7200: gpu_loops = ROUNDS_GRUB;
11208 gpu_accel = 16;
11209 break;
11210 case 7400: gpu_loops = ROUNDS_SHA256CRYPT;
11211 gpu_accel = 8;
11212 break;
11213 case 7900: gpu_loops = ROUNDS_DRUPAL7;
11214 gpu_accel = 8;
11215 break;
11216 case 8200: gpu_loops = ROUNDS_CLOUDKEY;
11217 gpu_accel = 8;
11218 break;
11219 case 8800: gpu_loops = ROUNDS_ANDROIDFDE;
11220 gpu_accel = 32;
11221 break;
11222 case 8900: gpu_loops = 1;
11223 gpu_accel = 64;
11224 break;
11225 case 9000: gpu_loops = ROUNDS_PSAFE2;
11226 gpu_accel = 16;
11227 break;
11228 case 9100: gpu_loops = ROUNDS_LOTUS8;
11229 gpu_accel = 64;
11230 break;
11231 case 9200: gpu_loops = ROUNDS_CISCO8;
11232 gpu_accel = 8;
11233 break;
11234 case 9300: gpu_loops = 1;
11235 gpu_accel = 8;
11236 break;
11237 case 9400: gpu_loops = ROUNDS_OFFICE2007;
11238 gpu_accel = 32;
11239 break;
11240 case 9500: gpu_loops = ROUNDS_OFFICE2010;
11241 gpu_accel = 32;
11242 break;
11243 case 9600: gpu_loops = ROUNDS_OFFICE2013;
11244 gpu_accel = 8;
11245 break;
11246 case 10000: gpu_loops = ROUNDS_DJANGOPBKDF2;
11247 gpu_accel = 8;
11248 break;
11249 case 10300: gpu_loops = ROUNDS_SAPH_SHA1;
11250 gpu_accel = 16;
11251 break;
11252 case 10500: gpu_loops = ROUNDS_PDF14;
11253 gpu_accel = 256;
11254 break;
11255 case 10700: gpu_loops = ROUNDS_PDF17L8;
11256 gpu_accel = 8;
11257 break;
11258 case 10900: gpu_loops = ROUNDS_PBKDF2_SHA256;
11259 gpu_accel = 8;
11260 break;
11261 case 11300: gpu_loops = ROUNDS_BITCOIN_WALLET;
11262 gpu_accel = 8;
11263 break;
11264 case 11600: gpu_loops = ROUNDS_SEVEN_ZIP;
11265 gpu_accel = 8;
11266 break;
11267 case 11900: gpu_loops = ROUNDS_PBKDF2_MD5;
11268 gpu_accel = 8;
11269 break;
11270 case 12000: gpu_loops = ROUNDS_PBKDF2_SHA1;
11271 gpu_accel = 8;
11272 break;
11273 case 12100: gpu_loops = ROUNDS_PBKDF2_SHA512;
11274 gpu_accel = 8;
11275 break;
11276 case 12200: gpu_loops = ROUNDS_ECRYPTFS;
11277 gpu_accel = 8;
11278 break;
11279 case 12300: gpu_loops = ROUNDS_ORACLET;
11280 gpu_accel = 8;
11281 break;
11282 case 12500: gpu_loops = ROUNDS_RAR3;
11283 gpu_accel = 32;
11284 break;
11285 case 12700: gpu_loops = ROUNDS_MYWALLET;
11286 gpu_accel = 512;
11287 break;
11288 case 12800: gpu_loops = ROUNDS_MS_DRSR;
11289 gpu_accel = 512;
11290 break;
11291 }
11292
11293 // some algorithm collide too fast, make that impossible
11294
11295 switch (hash_mode)
11296 {
11297 case 11500: ((uint *) digests_buf)[1] = 1;
11298 break;
11299 }
11300
11301 if (gpu_loops > 1024) gpu_loops = 1024;
11302 if (gpu_accel > 256) gpu_accel = 256; // causes memory problems otherwise
11303 }
11304
11305 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
11306 {
11307 gpu_loops = 1024;
11308 }
11309
11310 if (hash_mode == 12500)
11311 {
11312 gpu_loops = ROUNDS_RAR3 / 16;
11313 }
11314
11315 data.gpu_accel = gpu_accel;
11316 data.gpu_loops = gpu_loops;
11317
11318 hashes_cnt = 1;
11319 }
11320
11321 if (show == 1 || left == 1)
11322 {
11323 for (uint i = 0; i < pot_cnt; i++)
11324 {
11325 pot_t *pot_ptr = &pot[i];
11326
11327 hash_t *hashes_buf = &pot_ptr->hash;
11328
11329 local_free (hashes_buf->digest);
11330
11331 if (isSalted)
11332 {
11333 local_free (hashes_buf->salt);
11334 }
11335 }
11336
11337 local_free (pot);
11338
11339 if (data.quiet == 0) log_info_nn ("");
11340
11341 return (0);
11342 }
11343
11344 if (keyspace == 0)
11345 {
11346 if (hashes_cnt == 0)
11347 {
11348 log_error ("ERROR: No hashes loaded");
11349
11350 return (-1);
11351 }
11352 }
11353
11354 /**
11355 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11356 */
11357
11358 if (data.outfile != NULL)
11359 {
11360 if (data.hashfile != NULL)
11361 {
11362 #ifdef _POSIX
11363 struct stat tmpstat_outfile;
11364 struct stat tmpstat_hashfile;
11365 #endif
11366
11367 #ifdef _WIN
11368 struct stat64 tmpstat_outfile;
11369 struct stat64 tmpstat_hashfile;
11370 #endif
11371
11372 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11373
11374 if (tmp_outfile_fp)
11375 {
11376 #ifdef _POSIX
11377 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11378 #endif
11379
11380 #ifdef _WIN
11381 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11382 #endif
11383
11384 fclose (tmp_outfile_fp);
11385 }
11386
11387 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11388
11389 if (tmp_hashfile_fp)
11390 {
11391 #ifdef _POSIX
11392 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11393 #endif
11394
11395 #ifdef _WIN
11396 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11397 #endif
11398
11399 fclose (tmp_hashfile_fp);
11400 }
11401
11402 if (tmp_outfile_fp && tmp_outfile_fp)
11403 {
11404 tmpstat_outfile.st_mode = 0;
11405 tmpstat_outfile.st_nlink = 0;
11406 tmpstat_outfile.st_uid = 0;
11407 tmpstat_outfile.st_gid = 0;
11408 tmpstat_outfile.st_rdev = 0;
11409 tmpstat_outfile.st_atime = 0;
11410
11411 tmpstat_hashfile.st_mode = 0;
11412 tmpstat_hashfile.st_nlink = 0;
11413 tmpstat_hashfile.st_uid = 0;
11414 tmpstat_hashfile.st_gid = 0;
11415 tmpstat_hashfile.st_rdev = 0;
11416 tmpstat_hashfile.st_atime = 0;
11417
11418 #ifdef _POSIX
11419 tmpstat_outfile.st_blksize = 0;
11420 tmpstat_outfile.st_blocks = 0;
11421
11422 tmpstat_hashfile.st_blksize = 0;
11423 tmpstat_hashfile.st_blocks = 0;
11424 #endif
11425
11426 #ifdef _POSIX
11427 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11428 {
11429 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11430
11431 return (-1);
11432 }
11433 #endif
11434
11435 #ifdef _WIN
11436 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11437 {
11438 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11439
11440 return (-1);
11441 }
11442 #endif
11443 }
11444 }
11445 }
11446
11447 /**
11448 * Remove duplicates
11449 */
11450
11451 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11452
11453 if (isSalted)
11454 {
11455 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11456 }
11457 else
11458 {
11459 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11460 }
11461
11462 uint hashes_cnt_orig = hashes_cnt;
11463
11464 hashes_cnt = 1;
11465
11466 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11467 {
11468 if (isSalted)
11469 {
11470 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11471 {
11472 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11473 }
11474 }
11475 else
11476 {
11477 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11478 }
11479
11480 if (hashes_pos > hashes_cnt)
11481 {
11482 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11483 }
11484
11485 hashes_cnt++;
11486 }
11487
11488 /**
11489 * Potfile removes
11490 */
11491
11492 uint potfile_remove_cracks = 0;
11493
11494 if (potfile_disable == 0)
11495 {
11496 hash_t hash_buf;
11497
11498 hash_buf.digest = mymalloc (dgst_size);
11499 hash_buf.salt = NULL;
11500 hash_buf.esalt = NULL;
11501 hash_buf.hash_info = NULL;
11502 hash_buf.cracked = 0;
11503
11504 if (isSalted)
11505 {
11506 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11507 }
11508
11509 if (esalt_size)
11510 {
11511 hash_buf.esalt = mymalloc (esalt_size);
11512 }
11513
11514 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11515
11516 // no solution for these special hash types (for instane because they use hashfile in output etc)
11517 if ((hash_mode != 5200) &&
11518 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11519 (hash_mode != 9000))
11520 {
11521 FILE *fp = fopen (potfile, "rb");
11522
11523 if (fp != NULL)
11524 {
11525 while (!feof (fp))
11526 {
11527 char line_buf[BUFSIZ];
11528
11529 memset (line_buf, 0, BUFSIZ);
11530
11531 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11532
11533 if (ptr == NULL) break;
11534
11535 int line_len = strlen (line_buf);
11536
11537 if (line_len == 0) continue;
11538
11539 int iter = MAX_CUT_TRIES;
11540
11541 for (int i = line_len - 1; i && iter; i--, line_len--)
11542 {
11543 if (line_buf[i] != ':') continue;
11544
11545 if (isSalted)
11546 {
11547 memset (hash_buf.salt, 0, sizeof (salt_t));
11548 }
11549
11550 hash_t *found = NULL;
11551
11552 if (hash_mode == 6800)
11553 {
11554 if (i < 48) // 48 = 12 * uint in salt_buf[]
11555 {
11556 // manipulate salt_buf
11557 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11558
11559 hash_buf.salt->salt_len = i;
11560
11561 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11562 }
11563 }
11564 else if (hash_mode == 2500)
11565 {
11566 if (i < 48) // 48 = 12 * uint in salt_buf[]
11567 {
11568 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11569 // manipulate salt_buf
11570
11571 // to be safe work with a copy (because of line_len loop, i etc)
11572
11573 char line_buf_cpy[BUFSIZ];
11574 memset (line_buf_cpy, 0, BUFSIZ);
11575
11576 memset (line_buf_cpy, 0, sizeof (line_buf_cpy));
11577
11578 memcpy (line_buf_cpy, line_buf, i);
11579
11580 char *mac2_pos = strrchr (line_buf_cpy, ':');
11581
11582 if (mac2_pos == NULL) continue;
11583
11584 mac2_pos[0] = 0;
11585 mac2_pos++;
11586
11587 if (strlen (mac2_pos) != 12) continue;
11588
11589 char *mac1_pos = strrchr (line_buf_cpy, ':');
11590
11591 if (mac1_pos == NULL) continue;
11592
11593 mac1_pos[0] = 0;
11594 mac1_pos++;
11595
11596 if (strlen (mac1_pos) != 12) continue;
11597
11598 uint essid_length = mac1_pos - line_buf_cpy - 1;
11599
11600 // here we need the ESSID
11601 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11602
11603 hash_buf.salt->salt_len = essid_length;
11604
11605 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11606
11607 if (found)
11608 {
11609 wpa_t *wpa = (wpa_t *) found->esalt;
11610
11611 uint pke[25];
11612
11613 char *pke_ptr = (char *) pke;
11614
11615 for (uint i = 0; i < 25; i++)
11616 {
11617 pke[i] = byte_swap_32 (wpa->pke[i]);
11618 }
11619
11620 unsigned char mac1[6];
11621 unsigned char mac2[6];
11622
11623 memcpy (mac1, pke_ptr + 23, 6);
11624 memcpy (mac2, pke_ptr + 29, 6);
11625
11626 // compare hex string(s) vs binary MAC address(es)
11627
11628 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11629 {
11630 if (mac1[i] != (unsigned char) hex_to_char (&mac1_pos[j]))
11631 {
11632 found = NULL;
11633 break;
11634 }
11635 }
11636
11637 // early skip ;)
11638 if (!found) continue;
11639
11640 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11641 {
11642 if (mac2[i] != (unsigned char) hex_to_char (&mac2_pos[j]))
11643 {
11644 found = NULL;
11645 break;
11646 }
11647 }
11648 }
11649 }
11650 }
11651 else
11652 {
11653 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11654
11655 if (parser_status == PARSER_OK)
11656 {
11657 if (isSalted)
11658 {
11659 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11660 }
11661 else
11662 {
11663 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11664 }
11665 }
11666 }
11667
11668 if (found == NULL) continue;
11669
11670 if (!found->cracked) potfile_remove_cracks++;
11671
11672 found->cracked = 1;
11673
11674 if (found) break;
11675
11676 iter--;
11677 }
11678 }
11679
11680 fclose (fp);
11681 }
11682 }
11683
11684 if (esalt_size)
11685 {
11686 local_free (hash_buf.esalt);
11687 }
11688
11689 if (isSalted)
11690 {
11691 local_free (hash_buf.salt);
11692 }
11693
11694 local_free (hash_buf.digest);
11695 }
11696
11697 /**
11698 * Now generate all the buffers required for later
11699 */
11700
11701 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11702
11703 salt_t *salts_buf_new = NULL;
11704 void *esalts_buf_new = NULL;
11705
11706 if (isSalted)
11707 {
11708 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11709
11710 if (esalt_size)
11711 {
11712 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
11713 }
11714 }
11715 else
11716 {
11717 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
11718 }
11719
11720 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
11721
11722 uint digests_cnt = hashes_cnt;
11723 uint digests_done = 0;
11724
11725 uint size_digests = digests_cnt * dgst_size;
11726 uint size_shown = digests_cnt * sizeof (uint);
11727
11728 uint *digests_shown = (uint *) mymalloc (size_shown);
11729 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
11730
11731 uint salts_cnt = 0;
11732 uint salts_done = 0;
11733
11734 hashinfo_t **hash_info = NULL;
11735
11736 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11737 {
11738 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
11739
11740 if (username && (remove || show))
11741 {
11742 uint user_pos;
11743
11744 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
11745 {
11746 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
11747
11748 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
11749 }
11750 }
11751 }
11752
11753 uint *salts_shown = (uint *) mymalloc (size_shown);
11754
11755 salt_t *salt_buf;
11756
11757 {
11758 // copied from inner loop
11759
11760 salt_buf = &salts_buf_new[salts_cnt];
11761
11762 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
11763
11764 if (esalt_size)
11765 {
11766 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
11767 }
11768
11769 salt_buf->digests_cnt = 0;
11770 salt_buf->digests_done = 0;
11771 salt_buf->digests_offset = 0;
11772
11773 salts_cnt++;
11774 }
11775
11776 if (hashes_buf[0].cracked == 1)
11777 {
11778 digests_shown[0] = 1;
11779
11780 digests_done++;
11781
11782 salt_buf->digests_done++;
11783 }
11784
11785 salt_buf->digests_cnt++;
11786
11787 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
11788
11789 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11790 {
11791 hash_info[0] = hashes_buf[0].hash_info;
11792 }
11793
11794 // copy from inner loop
11795
11796 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
11797 {
11798 if (isSalted)
11799 {
11800 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
11801 {
11802 salt_buf = &salts_buf_new[salts_cnt];
11803
11804 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
11805
11806 if (esalt_size)
11807 {
11808 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
11809 }
11810
11811 salt_buf->digests_cnt = 0;
11812 salt_buf->digests_done = 0;
11813 salt_buf->digests_offset = hashes_pos;
11814
11815 salts_cnt++;
11816 }
11817 }
11818
11819 if (hashes_buf[hashes_pos].cracked == 1)
11820 {
11821 digests_shown[hashes_pos] = 1;
11822
11823 digests_done++;
11824
11825 salt_buf->digests_done++;
11826 }
11827
11828 salt_buf->digests_cnt++;
11829
11830 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
11831
11832 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11833 {
11834 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
11835 }
11836 }
11837
11838 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
11839 {
11840 salt_t *salt_buf = &salts_buf_new[salt_pos];
11841
11842 if (salt_buf->digests_done == salt_buf->digests_cnt)
11843 {
11844 salts_shown[salt_pos] = 1;
11845
11846 salts_done++;
11847 }
11848
11849 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
11850 }
11851
11852 local_free (digests_buf);
11853 local_free (salts_buf);
11854 local_free (esalts_buf);
11855
11856 digests_buf = digests_buf_new;
11857 salts_buf = salts_buf_new;
11858 esalts_buf = esalts_buf_new;
11859
11860 local_free (hashes_buf);
11861
11862 /**
11863 * special modification not set from parser
11864 */
11865
11866 switch (hash_mode)
11867 {
11868 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
11869 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
11870 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
11871 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
11872 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
11873 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
11874 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
11875 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
11876 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
11877 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
11878 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
11879 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
11880 }
11881
11882 if (truecrypt_keyfiles)
11883 {
11884 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
11885
11886 char *keyfiles = strdup (truecrypt_keyfiles);
11887
11888 char *keyfile = strtok (keyfiles, ",");
11889
11890 do
11891 {
11892 truecrypt_crc32 (keyfile, (unsigned char *) keyfile_buf);
11893
11894 } while ((keyfile = strtok (NULL, ",")) != NULL);
11895
11896 free (keyfiles);
11897 }
11898
11899 data.digests_cnt = digests_cnt;
11900 data.digests_done = digests_done;
11901 data.digests_buf = digests_buf;
11902 data.digests_shown = digests_shown;
11903 data.digests_shown_tmp = digests_shown_tmp;
11904
11905 data.salts_cnt = salts_cnt;
11906 data.salts_done = salts_done;
11907 data.salts_buf = salts_buf;
11908 data.salts_shown = salts_shown;
11909
11910 data.esalts_buf = esalts_buf;
11911 data.hash_info = hash_info;
11912
11913 /**
11914 * Automatic Optimizers
11915 */
11916
11917 if (salts_cnt == 1)
11918 opti_type |= OPTI_TYPE_SINGLE_SALT;
11919
11920 if (digests_cnt == 1)
11921 opti_type |= OPTI_TYPE_SINGLE_HASH;
11922
11923 if (attack_exec == ATTACK_EXEC_ON_GPU)
11924 opti_type |= OPTI_TYPE_NOT_ITERATED;
11925
11926 if (attack_mode == ATTACK_MODE_BF)
11927 opti_type |= OPTI_TYPE_BRUTE_FORCE;
11928
11929 data.opti_type = opti_type;
11930
11931 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
11932 {
11933 if (opti_type & OPTI_TYPE_SINGLE_HASH)
11934 {
11935 if (opti_type & OPTI_TYPE_APPENDED_SALT)
11936 {
11937 if (opts_type & OPTS_TYPE_ST_ADD80)
11938 {
11939 opts_type &= ~OPTS_TYPE_ST_ADD80;
11940 opts_type |= OPTS_TYPE_PT_ADD80;
11941 }
11942
11943 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
11944 {
11945 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
11946 opts_type |= OPTS_TYPE_PT_ADDBITS14;
11947 }
11948
11949 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
11950 {
11951 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
11952 opts_type |= OPTS_TYPE_PT_ADDBITS15;
11953 }
11954 }
11955 }
11956 }
11957
11958 /**
11959 * Some algorithm, like descrypt, can benefit from JIT compilation
11960 */
11961
11962 uint force_jit_compilation = 0;
11963
11964 if (hash_mode == 8900)
11965 {
11966 force_jit_compilation = 8900;
11967 }
11968 else if (hash_mode == 9300)
11969 {
11970 force_jit_compilation = 8900;
11971 }
11972 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
11973 {
11974 force_jit_compilation = 1500;
11975 }
11976
11977 /**
11978 * generate bitmap tables
11979 */
11980
11981 const uint bitmap_shift1 = 5;
11982 const uint bitmap_shift2 = 13;
11983
11984 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
11985
11986 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
11987 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
11988 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
11989 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
11990 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
11991 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
11992 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
11993 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
11994
11995 uint bitmap_bits;
11996 uint bitmap_nums;
11997 uint bitmap_mask;
11998 uint bitmap_size;
11999
12000 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12001 {
12002 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12003
12004 bitmap_nums = 1 << bitmap_bits;
12005
12006 bitmap_mask = bitmap_nums - 1;
12007
12008 bitmap_size = bitmap_nums * sizeof (uint);
12009
12010 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12011
12012 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;
12013 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;
12014
12015 break;
12016 }
12017
12018 bitmap_nums = 1 << bitmap_bits;
12019
12020 bitmap_mask = bitmap_nums - 1;
12021
12022 bitmap_size = bitmap_nums * sizeof (uint);
12023
12024 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);
12025 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);
12026
12027 /**
12028 * prepare quick rule
12029 */
12030
12031 data.rule_buf_l = rule_buf_l;
12032 data.rule_buf_r = rule_buf_r;
12033
12034 int rule_len_l = (int) strlen (rule_buf_l);
12035 int rule_len_r = (int) strlen (rule_buf_r);
12036
12037 data.rule_len_l = rule_len_l;
12038 data.rule_len_r = rule_len_r;
12039
12040 /**
12041 * load rules
12042 */
12043
12044 uint *all_gpu_rules_cnt = NULL;
12045
12046 gpu_rule_t **all_gpu_rules_buf = NULL;
12047
12048 if (rp_files_cnt)
12049 {
12050 all_gpu_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12051
12052 all_gpu_rules_buf = (gpu_rule_t **) mycalloc (rp_files_cnt, sizeof (gpu_rule_t *));
12053 }
12054
12055 char rule_buf[BUFSIZ];
12056
12057 int rule_len = 0;
12058
12059 for (uint i = 0; i < rp_files_cnt; i++)
12060 {
12061 uint gpu_rules_avail = 0;
12062
12063 uint gpu_rules_cnt = 0;
12064
12065 gpu_rule_t *gpu_rules_buf = NULL;
12066
12067 char *rp_file = rp_files[i];
12068
12069 char in[BLOCK_SIZE];
12070 char out[BLOCK_SIZE];
12071
12072 FILE *fp = NULL;
12073
12074 uint rule_line = 0;
12075
12076 if ((fp = fopen (rp_file, "rb")) == NULL)
12077 {
12078 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12079
12080 return (-1);
12081 }
12082
12083 while (!feof (fp))
12084 {
12085 memset (rule_buf, 0, BUFSIZ);
12086
12087 rule_len = fgetl (fp, rule_buf);
12088
12089 rule_line++;
12090
12091 if (rule_len == 0) continue;
12092
12093 if (rule_buf[0] == '#') continue;
12094
12095 if (gpu_rules_avail == gpu_rules_cnt)
12096 {
12097 gpu_rules_buf = (gpu_rule_t *) myrealloc (gpu_rules_buf, gpu_rules_avail * sizeof (gpu_rule_t), INCR_RULES * sizeof (gpu_rule_t));
12098
12099 gpu_rules_avail += INCR_RULES;
12100 }
12101
12102 memset (in, 0, BLOCK_SIZE);
12103 memset (out, 0, BLOCK_SIZE);
12104
12105 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12106
12107 if (result == -1)
12108 {
12109 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12110
12111 continue;
12112 }
12113
12114 if (cpu_rule_to_gpu_rule (rule_buf, rule_len, &gpu_rules_buf[gpu_rules_cnt]) == -1)
12115 {
12116 log_info ("WARNING: Cannot convert rule for use on GPU in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12117
12118 memset (&gpu_rules_buf[gpu_rules_cnt], 0, sizeof (gpu_rule_t)); // needs to be cleared otherwise we could have some remaining data
12119
12120 continue;
12121 }
12122
12123 /* its so slow
12124 if (rulefind (&gpu_rules_buf[gpu_rules_cnt], gpu_rules_buf, gpu_rules_cnt, sizeof (gpu_rule_t), sort_by_gpu_rule))
12125 {
12126 log_info ("Duplicate rule for use on GPU in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12127
12128 continue;
12129 }
12130 */
12131
12132 gpu_rules_cnt++;
12133 }
12134
12135 fclose (fp);
12136
12137 all_gpu_rules_cnt[i] = gpu_rules_cnt;
12138
12139 all_gpu_rules_buf[i] = gpu_rules_buf;
12140 }
12141
12142 /**
12143 * merge rules or automatic rule generator
12144 */
12145
12146 uint gpu_rules_cnt = 0;
12147
12148 gpu_rule_t *gpu_rules_buf = NULL;
12149
12150 if (attack_mode == ATTACK_MODE_STRAIGHT)
12151 {
12152 if (rp_files_cnt)
12153 {
12154 gpu_rules_cnt = 1;
12155
12156 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12157
12158 repeats[0] = gpu_rules_cnt;
12159
12160 for (uint i = 0; i < rp_files_cnt; i++)
12161 {
12162 gpu_rules_cnt *= all_gpu_rules_cnt[i];
12163
12164 repeats[i + 1] = gpu_rules_cnt;
12165 }
12166
12167 gpu_rules_buf = (gpu_rule_t *) mycalloc (gpu_rules_cnt, sizeof (gpu_rule_t));
12168
12169 memset (gpu_rules_buf, 0, gpu_rules_cnt * sizeof (gpu_rule_t));
12170
12171 for (uint i = 0; i < gpu_rules_cnt; i++)
12172 {
12173 uint out_pos = 0;
12174
12175 gpu_rule_t *out = &gpu_rules_buf[i];
12176
12177 for (uint j = 0; j < rp_files_cnt; j++)
12178 {
12179 uint in_off = (i / repeats[j]) % all_gpu_rules_cnt[j];
12180 uint in_pos;
12181
12182 gpu_rule_t *in = &all_gpu_rules_buf[j][in_off];
12183
12184 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12185 {
12186 if (out_pos == RULES_MAX - 1)
12187 {
12188 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12189
12190 break;
12191 }
12192
12193 out->cmds[out_pos] = in->cmds[in_pos];
12194 }
12195 }
12196 }
12197
12198 local_free (repeats);
12199 }
12200 else if (rp_gen)
12201 {
12202 uint gpu_rules_avail = 0;
12203
12204 while (gpu_rules_cnt < rp_gen)
12205 {
12206 if (gpu_rules_avail == gpu_rules_cnt)
12207 {
12208 gpu_rules_buf = (gpu_rule_t *) myrealloc (gpu_rules_buf, gpu_rules_avail * sizeof (gpu_rule_t), INCR_RULES * sizeof (gpu_rule_t));
12209
12210 gpu_rules_avail += INCR_RULES;
12211 }
12212
12213 memset (rule_buf, 0, BLOCK_SIZE);
12214
12215 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12216
12217 if (cpu_rule_to_gpu_rule (rule_buf, rule_len, &gpu_rules_buf[gpu_rules_cnt]) == -1) continue;
12218
12219 gpu_rules_cnt++;
12220 }
12221 }
12222 }
12223
12224 /**
12225 * generate NOP rules
12226 */
12227
12228 if (gpu_rules_cnt == 0)
12229 {
12230 gpu_rules_buf = (gpu_rule_t *) mymalloc (sizeof (gpu_rule_t));
12231
12232 gpu_rules_buf[gpu_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12233
12234 gpu_rules_cnt++;
12235 }
12236
12237 data.gpu_rules_cnt = gpu_rules_cnt;
12238 data.gpu_rules_buf = gpu_rules_buf;
12239
12240 /**
12241 * platform
12242 */
12243
12244 cl_platform_id CL_platforms[CL_PLATFORMS_MAX];
12245
12246 uint CL_platforms_cnt = 0;
12247
12248 hc_clGetPlatformIDs (CL_PLATFORMS_MAX, CL_platforms, &CL_platforms_cnt);
12249
12250 if (CL_platforms_cnt == 0)
12251 {
12252 log_error ("ERROR: No OpenCL compatible platform found");
12253
12254 return (-1);
12255 }
12256
12257 if (CL_platforms_cnt > 1)
12258 {
12259 log_error ("ERROR: Too many OpenCL compatible platforms found");
12260
12261 return (-1);
12262 }
12263
12264 cl_platform_id CL_platform = CL_platforms[0];
12265
12266 char CL_platform_vendor[INFOSZ];
12267
12268 memset (CL_platform_vendor, 0, sizeof (CL_platform_vendor));
12269
12270 hc_clGetPlatformInfo (CL_platform, CL_PLATFORM_VENDOR, sizeof (CL_platform_vendor), CL_platform_vendor, NULL);
12271
12272 uint vendor_id;
12273
12274 if (strcmp (CL_platform_vendor, CL_VENDOR_AMD) == 0)
12275 {
12276 vendor_id = VENDOR_ID_AMD;
12277 }
12278 else if (strcmp (CL_platform_vendor, CL_VENDOR_NV) == 0)
12279 {
12280 vendor_id = VENDOR_ID_NV;
12281
12282 // make sure that we do not directly control the fan for NVidia
12283
12284 gpu_temp_retain = 0;
12285 data.gpu_temp_retain = gpu_temp_retain;
12286 }
12287 else
12288 {
12289 vendor_id = VENDOR_ID_UNKNOWN;
12290 }
12291
12292 if (vendor_id == VENDOR_ID_UNKNOWN)
12293 {
12294 log_error ("Warning: unknown OpenCL vendor '%s' detected", CL_platform_vendor);
12295
12296 gpu_temp_disable = 1;
12297 }
12298
12299 data.vendor_id = vendor_id;
12300
12301 /**
12302 * devices
12303 */
12304
12305 cl_device_id devices_all[DEVICES_MAX];
12306 cl_device_id devices[DEVICES_MAX];
12307
12308 uint devices_all_cnt = 0;
12309
12310 hc_clGetDeviceIDs (CL_platform, CL_DEVICE_TYPE_GPU, DEVICES_MAX, devices_all, (uint *) &devices_all_cnt);
12311
12312 int hm_adapters_all = devices_all_cnt;
12313
12314 hm_attrs_t hm_adapter_all[DEVICES_MAX];
12315
12316 memset (hm_adapter_all, 0, sizeof (hm_adapter_all));
12317
12318 if (gpu_temp_disable == 0)
12319 {
12320 if (vendor_id == VENDOR_ID_NV)
12321 {
12322 #ifdef LINUX
12323 HM_LIB hm_dll = hm_init ();
12324
12325 data.hm_dll = hm_dll;
12326
12327 if (hc_NVML_nvmlInit (hm_dll) == NVML_SUCCESS)
12328 {
12329 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX];
12330
12331 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12332
12333 int tmp_out = 0;
12334
12335 for (int i = 0; i < tmp_in; i++)
12336 {
12337 hm_adapter_all[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12338 }
12339
12340 hm_adapters_all = tmp_out;
12341
12342 for (int i = 0; i < tmp_out; i++)
12343 {
12344 unsigned int speed;
12345
12346 if (hc_NVML_nvmlDeviceGetFanSpeed (hm_dll, 1, hm_adapter_all[i].adapter_index.nv, &speed) != NVML_ERROR_NOT_SUPPORTED) hm_adapter_all[i].fan_supported = 1;
12347 }
12348 }
12349 #endif
12350
12351 #ifdef WIN
12352 if (NvAPI_Initialize () == NVAPI_OK)
12353 {
12354 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX];
12355
12356 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12357
12358 int tmp_out = 0;
12359
12360 for (int i = 0; i < tmp_in; i++)
12361 {
12362 hm_adapter_all[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12363 }
12364
12365 hm_adapters_all = tmp_out;
12366
12367 for (int i = 0; i < tmp_out; i++)
12368 {
12369 NvU32 speed;
12370
12371 if (NvAPI_GPU_GetTachReading (hm_adapter_all[i].adapter_index.nv, &speed) != NVAPI_NOT_SUPPORTED) hm_adapter_all[i].fan_supported = 1;
12372 }
12373 }
12374 #endif
12375 }
12376
12377 if (vendor_id == VENDOR_ID_AMD)
12378 {
12379 HM_LIB hm_dll = hm_init ();
12380
12381 data.hm_dll = hm_dll;
12382
12383 if (hc_ADL_Main_Control_Create (hm_dll, ADL_Main_Memory_Alloc, 0) == ADL_OK)
12384 {
12385 // total number of adapters
12386
12387 int hm_adapters_num;
12388
12389 if (get_adapters_num_amd (hm_dll, &hm_adapters_num) != 0) return (-1);
12390
12391 // adapter info
12392
12393 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (hm_dll, hm_adapters_num);
12394
12395 if (lpAdapterInfo == NULL) return (-1);
12396
12397 // get a list (of ids of) valid/usable adapters
12398
12399 int num_adl_adapters = 0;
12400
12401 uint32_t *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
12402
12403 if (num_adl_adapters > 0)
12404 {
12405 hc_thread_mutex_lock (mux_adl);
12406
12407 // hm_get_opencl_busid_devid (hm_adapter_all, devices_all_cnt, devices_all);
12408
12409 hm_get_adapter_index_amd (hm_adapter_all, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12410
12411 hm_get_overdrive_version (hm_dll, hm_adapter_all, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12412 hm_check_fanspeed_control (hm_dll, hm_adapter_all, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12413
12414 hc_thread_mutex_unlock (mux_adl);
12415 }
12416
12417 hm_adapters_all = num_adl_adapters;
12418
12419 myfree (valid_adl_device_list);
12420 myfree (lpAdapterInfo);
12421 }
12422 }
12423 }
12424
12425 if (hm_adapters_all == 0)
12426 {
12427 gpu_temp_disable = 1;
12428 }
12429
12430 if (gpu_temp_disable == 1)
12431 {
12432 gpu_temp_abort = 0;
12433 gpu_temp_retain = 0;
12434 }
12435
12436 /**
12437 * enable custom signal handler(s)
12438 */
12439
12440 if (benchmark == 0)
12441 {
12442 hc_signal (sigHandler_default);
12443 }
12444 else
12445 {
12446 hc_signal (sigHandler_benchmark);
12447 }
12448
12449 /**
12450 * devices mask and properties
12451 */
12452
12453 uint devices_cnt = 0;
12454
12455 for (uint device_all_id = 0; device_all_id < devices_all_cnt; device_all_id++)
12456 {
12457 if (gpu_devicemask)
12458 {
12459 uint device_all_id_mask = 1 << device_all_id;
12460
12461 if ((device_all_id_mask & gpu_devicemask) != device_all_id_mask)
12462 {
12463 if (quiet == 0 && algorithm_pos == 0) log_info ("Device #%d: skipped by user", device_all_id_mask + 1);
12464
12465 continue;
12466 }
12467 }
12468
12469 const uint device_id = devices_cnt;
12470
12471 devices[device_id] = devices_all[device_all_id];
12472
12473 memcpy (&data.hm_device[device_id], &hm_adapter_all[device_all_id], sizeof (hm_attrs_t));
12474
12475 char device_name[INFOSZ];
12476
12477 memset (device_name, 0, sizeof (device_name));
12478
12479 cl_ulong global_mem_size;
12480 cl_uint max_clock_frequency;
12481 cl_uint max_compute_units;
12482
12483 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_NAME, sizeof (device_name), &device_name, NULL);
12484 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (global_mem_size), &global_mem_size, NULL);
12485 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (max_clock_frequency), &max_clock_frequency, NULL);
12486 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (max_compute_units), &max_compute_units, NULL);
12487
12488 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12489 {
12490 log_info ("Device #%u: %s, %luMB, %dMhz, %uMCU",
12491 device_all_id + 1,
12492 device_name,
12493 (unsigned int) (global_mem_size / 1024 / 1024),
12494 (unsigned int) (max_clock_frequency),
12495 (unsigned int) max_compute_units);
12496 }
12497
12498 devices_cnt++;
12499 }
12500
12501 if (devices_cnt == 0)
12502 {
12503 log_error ("ERROR: No devices left that matches your specification.");
12504
12505 return (-1);
12506 }
12507
12508 data.devices_cnt = devices_cnt;
12509
12510 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12511 {
12512 log_info ("");
12513 }
12514
12515 /**
12516 * inform the user
12517 */
12518
12519 // gpu temp sanity check
12520
12521 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
12522 {
12523 if (gpu_temp_abort < gpu_temp_retain)
12524 {
12525 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
12526
12527 return (-1);
12528 }
12529 }
12530
12531 data.gpu_temp_disable = gpu_temp_disable;
12532 data.gpu_temp_abort = gpu_temp_abort;
12533 data.gpu_temp_retain = gpu_temp_retain;
12534
12535 if (data.quiet == 0)
12536 {
12537 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
12538
12539 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);
12540
12541 if (attack_mode == ATTACK_MODE_STRAIGHT)
12542 {
12543 log_info ("Rules: %u", gpu_rules_cnt);
12544 }
12545
12546 if (opti_type)
12547 {
12548 log_info ("Applicable Optimizers:");
12549
12550 for (uint i = 0; i < 32; i++)
12551 {
12552 const uint opti_bit = 1 << i;
12553
12554 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
12555 }
12556 }
12557
12558 /**
12559 * Watchdog and Temperature balance
12560 */
12561
12562 if (gpu_temp_abort == 0)
12563 {
12564 log_info ("Watchdog: Temperature abort trigger disabled");
12565 }
12566 else
12567 {
12568 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
12569 }
12570
12571 if (gpu_temp_retain == 0)
12572 {
12573 log_info ("Watchdog: Temperature retain trigger disabled");
12574 }
12575 else
12576 {
12577 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
12578 }
12579 }
12580
12581 /**
12582 * devices init
12583 */
12584
12585 int *temp_retain_fanspeed_value = (int *) mycalloc (devices_cnt, sizeof (int));
12586
12587 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (devices_cnt, sizeof (ADLOD6MemClockState));
12588
12589 int *od_power_control_status = (int *) mycalloc (devices_cnt, sizeof (int));
12590
12591 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (devices_cnt, sizeof (hc_device_param_t));
12592
12593 data.devices_param = devices_param;
12594
12595 for (uint device_id = 0; device_id < devices_cnt; device_id++)
12596 {
12597 hc_device_param_t *device_param = &data.devices_param[device_id];
12598
12599 cl_device_id device = devices[device_id];
12600
12601 device_param->device = device;
12602
12603 cl_uint max_compute_units = 0;
12604
12605 hc_clGetDeviceInfo (device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (max_compute_units), &max_compute_units, NULL);
12606
12607 device_param->gpu_processors = max_compute_units;
12608
12609 cl_ulong max_mem_alloc_size = 0;
12610
12611 hc_clGetDeviceInfo (device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (max_mem_alloc_size), &max_mem_alloc_size, NULL);
12612
12613 device_param->gpu_maxmem_alloc = max_mem_alloc_size;
12614
12615 char tmp[INFOSZ], t1[64];
12616
12617 memset (tmp, 0, sizeof (tmp));
12618
12619 hc_clGetDeviceInfo (device, CL_DEVICE_NAME, sizeof (tmp), &tmp, NULL);
12620
12621 device_param->device_name = mystrdup (tmp);
12622
12623 memset (tmp, 0, sizeof (tmp));
12624
12625 hc_clGetDeviceInfo (device, CL_DEVICE_VERSION, sizeof (tmp), &tmp, NULL);
12626
12627 memset (t1, 0, sizeof (t1));
12628
12629 sscanf (tmp, "%*16s %*16s %*16s (%[^)]16s)", t1);
12630
12631 device_param->device_version = mystrdup (t1);
12632
12633 memset (tmp, 0, sizeof (tmp));
12634
12635 hc_clGetDeviceInfo (device, CL_DRIVER_VERSION, sizeof (tmp), &tmp, NULL);
12636
12637 device_param->driver_version = mystrdup (tmp);
12638
12639 if (vendor_id == VENDOR_ID_NV)
12640 {
12641 cl_uint sm_minor = 0;
12642 cl_uint sm_major = 0;
12643
12644 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12645 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12646
12647 hc_clGetDeviceInfo (device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12648 hc_clGetDeviceInfo (device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12649
12650 device_param->sm_minor = sm_minor;
12651 device_param->sm_major = sm_major;
12652 }
12653
12654 /**
12655 * catalyst driver check
12656 */
12657
12658 if (vendor_id == VENDOR_ID_AMD)
12659 {
12660 int catalyst_check = (force == 1) ? 0 : 1;
12661
12662 int catalyst_warn = 0;
12663
12664 int catalyst_broken = 0;
12665
12666 if (catalyst_check == 1)
12667 {
12668 catalyst_warn = 1;
12669
12670 // v14.9 and higher
12671 if ((atoi (device_param->device_version) >= 1573)
12672 && (atoi (device_param->driver_version) >= 1573))
12673 {
12674 catalyst_warn = 0;
12675 }
12676
12677 /*
12678 // v14.9
12679 if ((strstr (device_param->device_version, "1573.") != NULL)
12680 && (strstr (device_param->driver_version, "1573.") != NULL))
12681 {
12682 catalyst_warn = 0;
12683 }
12684
12685 // v14.12 -- version overlaps with v15.4 beta
12686 if ((strstr (device_param->device_version, "1642.") != NULL)
12687 && (strstr (device_param->driver_version, "1642.") != NULL))
12688 {
12689 catalyst_broken = 1;
12690 }
12691
12692 // v15.4 (Beta, Windows only release)
12693 if ((strstr (device_param->device_version, "1642.") != NULL)
12694 && (strstr (device_param->driver_version, "1642.") != NULL))
12695 {
12696 catalyst_warn = 0;
12697 }
12698
12699 // v15.5 (Release, Linux)
12700 if ((strstr (device_param->device_version, "1702.") != NULL)
12701 && (strstr (device_param->driver_version, "1702.") != NULL))
12702 {
12703 catalyst_warn = 0;
12704 }
12705
12706 // v15.3 (Beta, Ubuntu repository release)
12707 if ((strstr (device_param->device_version, "1729.") != NULL)
12708 && (strstr (device_param->driver_version, "1729.") != NULL))
12709 {
12710 catalyst_warn = 0;
12711 }
12712 */
12713
12714 catalyst_check = 0;
12715 }
12716
12717 if (catalyst_broken == 1)
12718 {
12719 log_error ("");
12720 log_error ("ATTENTION! The installed GPU driver in your system is known to be broken!");
12721 log_error ("It will pass over cracked hashes and does not report them as cracked");
12722 log_error ("You are STRONGLY encouraged not to use it");
12723 log_error ("You can use --force to override this but do not post error reports if you do so");
12724
12725 return (-1);
12726 }
12727
12728 if (catalyst_warn == 1)
12729 {
12730 log_error ("");
12731 log_error ("ATTENTION! Unsupported or incorrect installed GPU driver detected!");
12732 log_error ("You are STRONGLY encouraged to use the official supported GPU driver for good reasons");
12733 log_error ("See oclHashcat's homepage for official supported GPU drivers");
12734 #ifdef _WIN
12735 log_error ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12736 #endif
12737 log_error ("You can use --force to override this but do not post error reports if you do so");
12738
12739 return (-1);
12740 }
12741 }
12742 }
12743
12744 /*
12745 * Temporary fix:
12746 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
12747 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
12748 * were not working @ full speed (setting hc_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
12749 * Driver / ADL bug?
12750 */
12751
12752 if (vendor_id == VENDOR_ID_AMD)
12753 {
12754 if (powertune_enable == 1)
12755 {
12756 hc_thread_mutex_lock (mux_adl);
12757
12758 for (uint i = 0; i < devices_cnt; i++)
12759 {
12760 if (data.hm_device[i].od_version == 6)
12761 {
12762 // set powertune value only
12763
12764 int powertune_supported = 0;
12765
12766 int ADL_rc = 0;
12767
12768 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll, data.hm_device[i].adapter_index.amd, &powertune_supported)) != ADL_OK)
12769 {
12770 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
12771
12772 return (-1);
12773 }
12774
12775 if (powertune_supported != 0)
12776 {
12777 // powertune set
12778 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
12779
12780 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll, data.hm_device[i].adapter_index.amd, &powertune)) != ADL_OK)
12781 {
12782 log_error ("ERROR: Failed to get current ADL PowerControl settings");
12783
12784 return (-1);
12785 }
12786
12787 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll, data.hm_device[i].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
12788 {
12789 log_error ("ERROR: Failed to set new ADL PowerControl values");
12790
12791 return (-1);
12792 }
12793 }
12794 }
12795 }
12796
12797 hc_thread_mutex_unlock (mux_adl);
12798 }
12799 }
12800
12801 uint gpu_blocks_all = 0;
12802
12803 for (uint device_id = 0; device_id < devices_cnt; device_id++)
12804 {
12805 /**
12806 * host buffer
12807 */
12808
12809 hc_device_param_t *device_param = &data.devices_param[device_id];
12810
12811 /**
12812 * device properties
12813 */
12814
12815 char *device_name = device_param->device_name;
12816 char *device_version = device_param->device_version;
12817 char *driver_version = device_param->driver_version;
12818
12819 uint gpu_processors = device_param->gpu_processors;
12820
12821 /**
12822 * create context for each device
12823 */
12824
12825 device_param->context = hc_clCreateContext (NULL, 1, &device_param->device, NULL, NULL);
12826
12827 /**
12828 * create command-queue
12829 */
12830
12831 // not support with NV
12832 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
12833
12834 device_param->command_queue = hc_clCreateCommandQueue (device_param->context, device_param->device, 0);
12835
12836 /**
12837 * create input buffers on device
12838 */
12839
12840 uint gpu_threads = GPU_THREADS;
12841
12842 if (hash_mode == 3200) gpu_threads = 8;
12843 if (hash_mode == 9000) gpu_threads = 8;
12844
12845 uint gpu_power = gpu_processors * gpu_threads * gpu_accel;
12846 uint gpu_blocks = gpu_power;
12847
12848 device_param->gpu_threads = gpu_threads;
12849 device_param->gpu_power_user = gpu_power;
12850 device_param->gpu_blocks_user = gpu_blocks;
12851
12852 gpu_blocks_all += gpu_blocks;
12853
12854 uint size_pws = gpu_power * sizeof (pw_t);
12855
12856 uint size_tmps = 4;
12857
12858 switch (hash_mode)
12859 {
12860 case 400: size_tmps = gpu_blocks * sizeof (phpass_tmp_t); break;
12861 case 500: size_tmps = gpu_blocks * sizeof (md5crypt_tmp_t); break;
12862 case 501: size_tmps = gpu_blocks * sizeof (md5crypt_tmp_t); break;
12863 case 1600: size_tmps = gpu_blocks * sizeof (md5crypt_tmp_t); break;
12864 case 1800: size_tmps = gpu_blocks * sizeof (sha512crypt_tmp_t); break;
12865 case 2100: size_tmps = gpu_blocks * sizeof (dcc2_tmp_t); break;
12866 case 2500: size_tmps = gpu_blocks * sizeof (wpa_tmp_t); break;
12867 case 3200: size_tmps = gpu_blocks * sizeof (bcrypt_tmp_t); break;
12868 case 5200: size_tmps = gpu_blocks * sizeof (pwsafe3_tmp_t); break;
12869 case 5800: size_tmps = gpu_blocks * sizeof (androidpin_tmp_t); break;
12870 case 6211:
12871 case 6212:
12872 case 6213: size_tmps = gpu_blocks * sizeof (tc_tmp_t); break;
12873 case 6221:
12874 case 6222:
12875 case 6223: size_tmps = gpu_blocks * sizeof (tc64_tmp_t); break;
12876 case 6231:
12877 case 6232:
12878 case 6233: size_tmps = gpu_blocks * sizeof (tc_tmp_t); break;
12879 case 6241:
12880 case 6242:
12881 case 6243: size_tmps = gpu_blocks * sizeof (tc_tmp_t); break;
12882 case 6300: size_tmps = gpu_blocks * sizeof (md5crypt_tmp_t); break;
12883 case 6400: size_tmps = gpu_blocks * sizeof (sha256aix_tmp_t); break;
12884 case 6500: size_tmps = gpu_blocks * sizeof (sha512aix_tmp_t); break;
12885 case 6600: size_tmps = gpu_blocks * sizeof (agilekey_tmp_t); break;
12886 case 6700: size_tmps = gpu_blocks * sizeof (sha1aix_tmp_t); break;
12887 case 6800: size_tmps = gpu_blocks * sizeof (lastpass_tmp_t); break;
12888 case 7100: size_tmps = gpu_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
12889 case 7200: size_tmps = gpu_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
12890 case 7400: size_tmps = gpu_blocks * sizeof (sha256crypt_tmp_t); break;
12891 case 7900: size_tmps = gpu_blocks * sizeof (drupal7_tmp_t); break;
12892 case 8200: size_tmps = gpu_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
12893 case 8800: size_tmps = gpu_blocks * sizeof (androidfde_tmp_t); break;
12894 case 8900: size_tmps = gpu_blocks * sizeof (scrypt_tmp_t); break;
12895 case 9000: size_tmps = gpu_blocks * sizeof (pwsafe2_tmp_t); break;
12896 case 9100: size_tmps = gpu_blocks * sizeof (lotus8_tmp_t); break;
12897 case 9200: size_tmps = gpu_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
12898 case 9300: size_tmps = gpu_blocks * sizeof (scrypt_tmp_t); break;
12899 case 9400: size_tmps = gpu_blocks * sizeof (office2007_tmp_t); break;
12900 case 9500: size_tmps = gpu_blocks * sizeof (office2010_tmp_t); break;
12901 case 9600: size_tmps = gpu_blocks * sizeof (office2013_tmp_t); break;
12902 case 10000: size_tmps = gpu_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
12903 case 10200: size_tmps = gpu_blocks * sizeof (cram_md5_t); break;
12904 case 10300: size_tmps = gpu_blocks * sizeof (saph_sha1_tmp_t); break;
12905 case 10500: size_tmps = gpu_blocks * sizeof (pdf14_tmp_t); break;
12906 case 10700: size_tmps = gpu_blocks * sizeof (pdf17l8_tmp_t); break;
12907 case 10900: size_tmps = gpu_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
12908 case 11300: size_tmps = gpu_blocks * sizeof (bitcoin_wallet_tmp_t); break;
12909 case 11600: size_tmps = gpu_blocks * sizeof (seven_zip_tmp_t); break;
12910 case 11900: size_tmps = gpu_blocks * sizeof (pbkdf2_md5_tmp_t); break;
12911 case 12000: size_tmps = gpu_blocks * sizeof (pbkdf2_sha1_tmp_t); break;
12912 case 12100: size_tmps = gpu_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
12913 case 12200: size_tmps = gpu_blocks * sizeof (ecryptfs_tmp_t); break;
12914 case 12300: size_tmps = gpu_blocks * sizeof (oraclet_tmp_t); break;
12915 case 12400: size_tmps = gpu_blocks * sizeof (bsdicrypt_tmp_t); break;
12916 case 12500: size_tmps = gpu_blocks * sizeof (rar3_tmp_t); break;
12917 case 12700: size_tmps = gpu_blocks * sizeof (mywallet_tmp_t); break;
12918 case 12800: size_tmps = gpu_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
12919 };
12920
12921 uint size_hooks = 4;
12922
12923 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
12924 {
12925 // insert correct hook size
12926 }
12927
12928 // we can optimize some stuff here...
12929
12930 device_param->size_pws = size_pws;
12931 device_param->size_tmps = size_tmps;
12932 device_param->size_hooks = size_hooks;
12933
12934 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
12935 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
12936
12937 device_param->size_root_css = size_root_css;
12938 device_param->size_markov_css = size_markov_css;
12939
12940 uint size_results = GPU_THREADS * sizeof (uint);
12941
12942 device_param->size_results = size_results;
12943
12944 uint size_rules = gpu_rules_cnt * sizeof (gpu_rule_t);
12945 uint size_rules_c = GPU_RULES * sizeof (gpu_rule_t);
12946 uint size_plains = digests_cnt * sizeof (plain_t);
12947 uint size_salts = salts_cnt * sizeof (salt_t);
12948 uint size_esalts = salts_cnt * esalt_size;
12949
12950 device_param->size_plains = size_plains;
12951 device_param->size_digests = size_digests;
12952 device_param->size_shown = size_shown;
12953 device_param->size_salts = size_salts;
12954
12955 uint size_combs = GPU_COMBS * sizeof (comb_t);
12956 uint size_bfs = GPU_BFS * sizeof (bf_t);
12957 uint size_tm = 32 * sizeof (bs_word_t);
12958
12959 uint64_t size_scryptV = 1;
12960
12961 if ((hash_mode == 8900) || (hash_mode == 9300))
12962 {
12963 #define SHADER_PER_MP 8
12964 #define WAVEFRONTS 64
12965
12966 uint tmto_start = 2;
12967 uint tmto_stop = 1024;
12968
12969 if (scrypt_tmto)
12970 {
12971 tmto_start = 1 << scrypt_tmto;
12972 tmto_stop = tmto_start + 1;
12973 }
12974
12975 for (uint tmto = tmto_start; tmto < tmto_stop; tmto <<= 1)
12976 {
12977 // todo -- make sure all salts get the new tmto value
12978
12979 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
12980
12981 size_scryptV /= tmto;
12982
12983 size_scryptV *= gpu_processors * WAVEFRONTS * SHADER_PER_MP;
12984
12985 if (size_scryptV > (device_param->gpu_maxmem_alloc / 2)) continue;
12986
12987 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
12988 {
12989 data.salts_buf[salts_pos].scrypt_tmto = tmto;
12990 data.salts_buf[salts_pos].scrypt_phy = gpu_processors * WAVEFRONTS * SHADER_PER_MP;
12991 }
12992
12993 break;
12994 }
12995
12996 if (data.salts_buf[0].scrypt_tmto == 0)
12997 {
12998 log_error ("ERROR: can't allocate enough GPU memory");
12999
13000 return -1;
13001 }
13002
13003 if (quiet == 0) log_info ("");
13004 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u\n", data.salts_buf[0].scrypt_tmto);
13005 }
13006
13007 /**
13008 * default building options
13009 */
13010
13011 char build_opts[1024];
13012
13013 // we don't have sm_* on AMD but it doesn't matter
13014
13015 sprintf (build_opts, "-I. -IOpenCL/ -DVENDOR_ID=%d -DCUDA_ARCH=%d", vendor_id, (device_param->sm_major * 100) + device_param->sm_minor);
13016
13017 /**
13018 * main kernel
13019 */
13020
13021 {
13022 /**
13023 * kernel source filename
13024 */
13025
13026 char source_file[256];
13027
13028 memset (source_file, 0, sizeof (source_file));
13029
13030 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, install_dir, source_file);
13031
13032 struct stat sst;
13033
13034 if (stat (source_file, &sst) == -1)
13035 {
13036 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13037
13038 return -1;
13039 }
13040
13041 /**
13042 * kernel cached filename
13043 */
13044
13045 char cached_file[256];
13046
13047 memset (cached_file, 0, sizeof (cached_file));
13048
13049 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, install_dir, device_name, device_version, driver_version, vendor_id, cached_file);
13050
13051 int cached = 1;
13052
13053 struct stat cst;
13054
13055 if (stat (cached_file, &cst) == -1)
13056 {
13057 cached = 0;
13058 }
13059
13060 /**
13061 * kernel compile or load
13062 */
13063
13064 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13065
13066 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13067
13068 if (force_jit_compilation == 0)
13069 {
13070 if (cached == 0)
13071 {
13072 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13073
13074 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13075
13076 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13077
13078 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13079
13080 size_t binary_size;
13081
13082 clGetProgramInfo (device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13083
13084 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13085
13086 clGetProgramInfo (device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13087
13088 writeProgramBin (cached_file, binary, binary_size);
13089
13090 local_free (binary);
13091 }
13092 else
13093 {
13094 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13095
13096 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13097
13098 device_param->program = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13099
13100 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13101 }
13102 }
13103 else
13104 {
13105 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13106
13107 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13108
13109 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13110
13111 if (force_jit_compilation == 1500)
13112 {
13113 sprintf (build_opts, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13114 }
13115 else if (force_jit_compilation == 8900)
13116 {
13117 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);
13118 }
13119
13120 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13121 }
13122
13123 local_free (kernel_lengths);
13124 local_free (kernel_sources[0]);
13125 local_free (kernel_sources);
13126
13127 // this is mostly for debug
13128
13129 size_t ret_val_size = 0;
13130
13131 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13132
13133 if (ret_val_size > 2)
13134 {
13135 char *build_log = (char *) mymalloc (ret_val_size + 1);
13136
13137 memset (build_log, 0, ret_val_size + 1);
13138
13139 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13140
13141 puts (build_log);
13142
13143 myfree (build_log);
13144 }
13145 }
13146
13147 /**
13148 * word generator kernel
13149 */
13150
13151 if (attack_mode != ATTACK_MODE_STRAIGHT)
13152 {
13153 /**
13154 * kernel mp source filename
13155 */
13156
13157 char source_file[256];
13158
13159 memset (source_file, 0, sizeof (source_file));
13160
13161 generate_source_kernel_mp_filename (opti_type, opts_type, install_dir, source_file);
13162
13163 struct stat sst;
13164
13165 if (stat (source_file, &sst) == -1)
13166 {
13167 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13168
13169 return -1;
13170 }
13171
13172 /**
13173 * kernel mp cached filename
13174 */
13175
13176 char cached_file[256];
13177
13178 memset (cached_file, 0, sizeof (cached_file));
13179
13180 generate_cached_kernel_mp_filename (opti_type, opts_type, install_dir, device_name, device_version, driver_version, vendor_id, cached_file);
13181
13182 int cached = 1;
13183
13184 struct stat cst;
13185
13186 if (stat (cached_file, &cst) == -1)
13187 {
13188 cached = 0;
13189 }
13190
13191 /**
13192 * kernel compile or load
13193 */
13194
13195 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13196
13197 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13198
13199 if (cached == 0)
13200 {
13201 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13202
13203 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13204
13205 device_param->program_mp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13206
13207 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13208
13209 size_t binary_size;
13210
13211 clGetProgramInfo (device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13212
13213 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13214
13215 clGetProgramInfo (device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13216
13217 writeProgramBin (cached_file, binary, binary_size);
13218
13219 local_free (binary);
13220 }
13221 else
13222 {
13223 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13224
13225 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13226
13227 device_param->program_mp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13228
13229 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13230 }
13231
13232 local_free (kernel_lengths);
13233 local_free (kernel_sources[0]);
13234 local_free (kernel_sources);
13235
13236 // this is mostly for debug
13237
13238 size_t ret_val_size = 0;
13239
13240 clGetProgramBuildInfo (device_param->program_mp, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13241
13242 if (ret_val_size > 2)
13243 {
13244 char *build_log = (char *) mymalloc (ret_val_size + 1);
13245
13246 memset (build_log, 0, ret_val_size + 1);
13247
13248 clGetProgramBuildInfo (device_param->program_mp, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13249
13250 puts (build_log);
13251
13252 myfree (build_log);
13253 }
13254 }
13255
13256 /**
13257 * amplifier kernel
13258 */
13259
13260 if (attack_exec == ATTACK_EXEC_ON_GPU)
13261 {
13262
13263 }
13264 else
13265 {
13266 /**
13267 * kernel amp source filename
13268 */
13269
13270 char source_file[256];
13271
13272 memset (source_file, 0, sizeof (source_file));
13273
13274 generate_source_kernel_amp_filename (attack_kern, install_dir, source_file);
13275
13276 struct stat sst;
13277
13278 if (stat (source_file, &sst) == -1)
13279 {
13280 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13281
13282 return -1;
13283 }
13284
13285 /**
13286 * kernel amp cached filename
13287 */
13288
13289 char cached_file[256];
13290
13291 memset (cached_file, 0, sizeof (cached_file));
13292
13293 generate_cached_kernel_amp_filename (attack_kern, install_dir, device_name, device_version, driver_version, vendor_id, cached_file);
13294
13295 int cached = 1;
13296
13297 struct stat cst;
13298
13299 if (stat (cached_file, &cst) == -1)
13300 {
13301 cached = 0;
13302 }
13303
13304 /**
13305 * kernel compile or load
13306 */
13307
13308 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13309
13310 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13311
13312 if (cached == 0)
13313 {
13314 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13315
13316 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13317
13318 device_param->program_amp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13319
13320 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13321
13322 size_t binary_size;
13323
13324 clGetProgramInfo (device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13325
13326 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13327
13328 clGetProgramInfo (device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13329
13330 writeProgramBin (cached_file, binary, binary_size);
13331
13332 local_free (binary);
13333 }
13334 else
13335 {
13336 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13337
13338 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13339
13340 device_param->program_amp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13341
13342 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13343 }
13344
13345 local_free (kernel_lengths);
13346 local_free (kernel_sources[0]);
13347 local_free (kernel_sources);
13348
13349 // this is mostly for debug
13350
13351 size_t ret_val_size = 0;
13352
13353 clGetProgramBuildInfo (device_param->program_amp, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13354
13355 if (ret_val_size > 2)
13356 {
13357 char *build_log = (char *) mymalloc (ret_val_size + 1);
13358
13359 memset (build_log, 0, ret_val_size + 1);
13360
13361 clGetProgramBuildInfo (device_param->program_amp, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13362
13363 puts (build_log);
13364
13365 myfree (build_log);
13366 }
13367 }
13368
13369 /**
13370 * global buffers
13371 */
13372
13373 device_param->d_pws_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13374 device_param->d_pws_amp_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13375 device_param->d_tmps = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
13376 device_param->d_hooks = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
13377 device_param->d_bitmap_s1_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13378 device_param->d_bitmap_s1_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13379 device_param->d_bitmap_s1_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13380 device_param->d_bitmap_s1_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13381 device_param->d_bitmap_s2_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13382 device_param->d_bitmap_s2_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13383 device_param->d_bitmap_s2_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13384 device_param->d_bitmap_s2_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13385 device_param->d_plain_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
13386 device_param->d_digests_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
13387 device_param->d_digests_shown = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
13388 device_param->d_salt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
13389 device_param->d_result = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
13390 device_param->d_scryptV_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
13391
13392 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_a, CL_TRUE, 0, bitmap_size, bitmap_s1_a, 0, NULL, NULL);
13393 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_b, CL_TRUE, 0, bitmap_size, bitmap_s1_b, 0, NULL, NULL);
13394 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_c, CL_TRUE, 0, bitmap_size, bitmap_s1_c, 0, NULL, NULL);
13395 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_d, CL_TRUE, 0, bitmap_size, bitmap_s1_d, 0, NULL, NULL);
13396 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_a, CL_TRUE, 0, bitmap_size, bitmap_s2_a, 0, NULL, NULL);
13397 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_b, CL_TRUE, 0, bitmap_size, bitmap_s2_b, 0, NULL, NULL);
13398 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_c, CL_TRUE, 0, bitmap_size, bitmap_s2_c, 0, NULL, NULL);
13399 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_d, CL_TRUE, 0, bitmap_size, bitmap_s2_d, 0, NULL, NULL);
13400 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
13401 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
13402 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
13403
13404 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
13405 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
13406 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
13407 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
13408 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
13409 run_kernel_bzero (device_param, device_param->d_result, size_results);
13410
13411 /**
13412 * special buffers
13413 */
13414
13415 if (attack_kern == ATTACK_KERN_STRAIGHT)
13416 {
13417 device_param->d_rules = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
13418 device_param->d_rules_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
13419
13420 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, gpu_rules_buf, 0, NULL, NULL);
13421
13422 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
13423 }
13424 else if (attack_kern == ATTACK_KERN_COMBI)
13425 {
13426 device_param->d_combs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13427 device_param->d_combs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13428 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13429 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13430
13431 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
13432 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
13433 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13434 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13435 }
13436 else if (attack_kern == ATTACK_KERN_BF)
13437 {
13438 device_param->d_bfs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13439 device_param->d_bfs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13440 device_param->d_tm_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
13441 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13442 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13443
13444 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
13445 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
13446 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
13447 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13448 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13449 }
13450
13451 if (size_esalts)
13452 {
13453 device_param->d_esalt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
13454
13455 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
13456 }
13457
13458 /**
13459 * main host data
13460 */
13461
13462 uint *result = (uint *) mymalloc (size_results);
13463
13464 memset (result, 0, size_results);
13465
13466 device_param->result = result;
13467
13468 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
13469
13470 memset (pws_buf, 0, size_pws);
13471
13472 device_param->pws_buf = pws_buf;
13473
13474 pw_cache_t *pw_caches = (pw_cache_t *) mycalloc (64, sizeof (pw_cache_t));
13475
13476 for (int i = 0; i < 64; i++)
13477 {
13478 pw_caches[i].pw_buf.pw_len = i;
13479 pw_caches[i].cnt = 0;
13480 }
13481
13482 device_param->pw_caches = pw_caches;
13483
13484 comb_t *combs_buf = (comb_t *) mycalloc (GPU_COMBS, sizeof (comb_t));
13485
13486 device_param->combs_buf = combs_buf;
13487
13488 void *hooks_buf = mymalloc (size_hooks);
13489
13490 device_param->hooks_buf = hooks_buf;
13491
13492 device_param->pw_transpose = pw_transpose_to_hi1;
13493 device_param->pw_add = pw_add_to_hc1;
13494
13495 /**
13496 * kernel args
13497 */
13498
13499 device_param->kernel_params_buf32[21] = bitmap_mask;
13500 device_param->kernel_params_buf32[22] = bitmap_shift1;
13501 device_param->kernel_params_buf32[23] = bitmap_shift2;
13502 device_param->kernel_params_buf32[24] = 0; // salt_pos
13503 device_param->kernel_params_buf32[25] = 0; // loop_pos
13504 device_param->kernel_params_buf32[26] = 0; // loop_cnt
13505 device_param->kernel_params_buf32[27] = 0; // gpu_rules_cnt
13506 device_param->kernel_params_buf32[28] = 0; // digests_cnt
13507 device_param->kernel_params_buf32[29] = 0; // digests_offset
13508 device_param->kernel_params_buf32[30] = 0; // combs_mode
13509 device_param->kernel_params_buf32[31] = 0; // gid_max
13510
13511 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_ON_GPU)
13512 ? &device_param->d_pws_buf
13513 : &device_param->d_pws_amp_buf;
13514 device_param->kernel_params[ 1] = &device_param->d_rules_c;
13515 device_param->kernel_params[ 2] = &device_param->d_combs_c;
13516 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
13517 device_param->kernel_params[ 4] = &device_param->d_tmps;
13518 device_param->kernel_params[ 5] = &device_param->d_hooks;
13519 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
13520 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
13521 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
13522 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
13523 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
13524 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
13525 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
13526 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
13527 device_param->kernel_params[14] = &device_param->d_plain_bufs;
13528 device_param->kernel_params[15] = &device_param->d_digests_buf;
13529 device_param->kernel_params[16] = &device_param->d_digests_shown;
13530 device_param->kernel_params[17] = &device_param->d_salt_bufs;
13531 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
13532 device_param->kernel_params[19] = &device_param->d_result;
13533 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
13534 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
13535 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
13536 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
13537 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
13538 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
13539 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
13540 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
13541 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
13542 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
13543 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
13544 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
13545
13546 device_param->kernel_params_mp_buf64[3] = 0;
13547 device_param->kernel_params_mp_buf32[4] = 0;
13548 device_param->kernel_params_mp_buf32[5] = 0;
13549 device_param->kernel_params_mp_buf32[6] = 0;
13550 device_param->kernel_params_mp_buf32[7] = 0;
13551 device_param->kernel_params_mp_buf32[8] = 0;
13552
13553 device_param->kernel_params_mp[0] = NULL;
13554 device_param->kernel_params_mp[1] = NULL;
13555 device_param->kernel_params_mp[2] = NULL;
13556 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
13557 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
13558 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
13559 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
13560 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
13561 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
13562
13563 device_param->kernel_params_mp_l_buf64[3] = 0;
13564 device_param->kernel_params_mp_l_buf32[4] = 0;
13565 device_param->kernel_params_mp_l_buf32[5] = 0;
13566 device_param->kernel_params_mp_l_buf32[6] = 0;
13567 device_param->kernel_params_mp_l_buf32[7] = 0;
13568 device_param->kernel_params_mp_l_buf32[8] = 0;
13569 device_param->kernel_params_mp_l_buf32[9] = 0;
13570
13571 device_param->kernel_params_mp_l[0] = NULL;
13572 device_param->kernel_params_mp_l[1] = NULL;
13573 device_param->kernel_params_mp_l[2] = NULL;
13574 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
13575 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
13576 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
13577 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
13578 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
13579 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
13580 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
13581
13582 device_param->kernel_params_mp_r_buf64[3] = 0;
13583 device_param->kernel_params_mp_r_buf32[4] = 0;
13584 device_param->kernel_params_mp_r_buf32[5] = 0;
13585 device_param->kernel_params_mp_r_buf32[6] = 0;
13586 device_param->kernel_params_mp_r_buf32[7] = 0;
13587 device_param->kernel_params_mp_r_buf32[8] = 0;
13588
13589 device_param->kernel_params_mp_r[0] = NULL;
13590 device_param->kernel_params_mp_r[1] = NULL;
13591 device_param->kernel_params_mp_r[2] = NULL;
13592 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
13593 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
13594 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
13595 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
13596 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
13597 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
13598
13599 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
13600 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
13601
13602 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
13603 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
13604 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
13605 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
13606 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
13607 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
13608 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
13609
13610 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
13611
13612 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
13613 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
13614
13615 /**
13616 * kernel name
13617 */
13618
13619 char kernel_name[64];
13620
13621 memset (kernel_name, 0, sizeof (kernel_name));
13622
13623 if (attack_exec == ATTACK_EXEC_ON_GPU)
13624 {
13625 if (opti_type & OPTI_TYPE_SINGLE_HASH)
13626 {
13627 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
13628
13629 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
13630
13631 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
13632
13633 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
13634
13635 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
13636
13637 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
13638 }
13639 else
13640 {
13641 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
13642
13643 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
13644
13645 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
13646
13647 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
13648
13649 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
13650
13651 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
13652 }
13653
13654 if (data.attack_mode == ATTACK_MODE_BF)
13655 {
13656 if (opts_type & OPTS_TYPE_PT_BITSLICE)
13657 {
13658 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
13659
13660 device_param->kernel_tb = hc_clCreateKernel (device_param->program, kernel_name);
13661
13662 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
13663
13664 device_param->kernel_tm = hc_clCreateKernel (device_param->program, kernel_name);
13665 }
13666 }
13667 }
13668 else
13669 {
13670 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
13671
13672 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
13673
13674 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
13675
13676 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
13677
13678 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
13679
13680 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
13681
13682 if (opts_type & OPTS_TYPE_HOOK12)
13683 {
13684 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
13685
13686 device_param->kernel12 = hc_clCreateKernel (device_param->program, kernel_name);
13687 }
13688
13689 if (opts_type & OPTS_TYPE_HOOK23)
13690 {
13691 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
13692
13693 device_param->kernel23 = hc_clCreateKernel (device_param->program, kernel_name);
13694 }
13695 }
13696
13697 for (uint i = 0; i <= 20; i++)
13698 {
13699 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
13700 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
13701 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
13702
13703 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
13704 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
13705 }
13706
13707 for (uint i = 21; i <= 31; i++)
13708 {
13709 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
13710 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
13711 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
13712
13713 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
13714 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
13715 }
13716
13717 if (attack_mode == ATTACK_MODE_BF)
13718 {
13719 device_param->kernel_mp_l = hc_clCreateKernel (device_param->program_mp, "l_markov");
13720 device_param->kernel_mp_r = hc_clCreateKernel (device_param->program_mp, "r_markov");
13721
13722 if (opts_type & OPTS_TYPE_PT_BITSLICE)
13723 {
13724 hc_clSetKernelArg (device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
13725
13726 hc_clSetKernelArg (device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
13727 hc_clSetKernelArg (device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
13728 }
13729 }
13730 else if (attack_mode == ATTACK_MODE_HYBRID1)
13731 {
13732 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
13733 }
13734 else if (attack_mode == ATTACK_MODE_HYBRID2)
13735 {
13736 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
13737 }
13738
13739 if (attack_exec == ATTACK_EXEC_ON_GPU)
13740 {
13741 // nothing to do
13742 }
13743 else
13744 {
13745 device_param->kernel_amp = hc_clCreateKernel (device_param->program_amp, "amp");
13746 }
13747
13748 if (attack_exec == ATTACK_EXEC_ON_GPU)
13749 {
13750 // nothing to do
13751 }
13752 else
13753 {
13754 for (uint i = 0; i < 5; i++)
13755 {
13756 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
13757 }
13758
13759 for (uint i = 5; i < 7; i++)
13760 {
13761 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
13762 }
13763 }
13764
13765 /**
13766 * Store initial fanspeed if gpu_temp_retain is enabled
13767 */
13768
13769 int gpu_temp_retain_set = 0;
13770
13771 if (gpu_temp_disable == 0)
13772 {
13773 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
13774 {
13775 hc_thread_mutex_lock (mux_adl);
13776
13777 if (data.hm_device[device_id].fan_supported == 1)
13778 {
13779 if (gpu_temp_retain_chgd == 0)
13780 {
13781 uint cur_temp = 0;
13782 uint default_temp = 0;
13783
13784 int ADL_rc = hc_ADL_Overdrive6_TargetTemperatureData_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, (int *) &cur_temp, (int *) &default_temp);
13785
13786 if (ADL_rc == ADL_OK)
13787 {
13788 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
13789
13790 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
13791
13792 // special case with multi gpu setups: always use minimum retain
13793
13794 if (gpu_temp_retain_set == 0)
13795 {
13796 gpu_temp_retain = gpu_temp_retain_target;
13797 gpu_temp_retain_set = 1;
13798 }
13799 else
13800 {
13801 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
13802 }
13803
13804 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
13805 }
13806 }
13807
13808 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
13809
13810 temp_retain_fanspeed_value[device_id] = fan_speed;
13811
13812 if (fan_speed == -1)
13813 {
13814 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
13815
13816 temp_retain_fanspeed_value[device_id] = 0;
13817 }
13818 }
13819
13820 hc_thread_mutex_unlock (mux_adl);
13821 }
13822 }
13823
13824 /**
13825 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
13826 */
13827
13828 if (powertune_enable == 1) // VENDOR_ID_AMD implied
13829 {
13830 hc_thread_mutex_lock (mux_adl);
13831
13832 if (data.hm_device[device_id].od_version == 6)
13833 {
13834 int ADL_rc;
13835
13836 // check powertune capabilities first, if not available then skip device
13837
13838 int powertune_supported = 0;
13839
13840 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13841 {
13842 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13843
13844 return (-1);
13845 }
13846
13847 if (powertune_supported != 0)
13848 {
13849 // powercontrol settings
13850
13851 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13852
13853 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
13854 {
13855 ADL_rc = hc_ADL_Overdrive_PowerControl_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
13856 }
13857
13858 if (ADL_rc != ADL_OK)
13859 {
13860 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13861
13862 return (-1);
13863 }
13864
13865 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13866 {
13867 log_error ("ERROR: Failed to set new ADL PowerControl values");
13868
13869 return (-1);
13870 }
13871
13872 // clocks
13873
13874 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
13875
13876 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
13877
13878 if ((ADL_rc = hc_ADL_Overdrive_StateInfo_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, ADL_OD6_GETSTATEINFO_CUSTOM_PERFORMANCE, &od_clock_mem_status[device_id])) != ADL_OK)
13879 {
13880 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
13881
13882 return (-1);
13883 }
13884
13885 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
13886
13887 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
13888
13889 if ((ADL_rc = hc_ADL_Overdrive_Capabilities_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
13890 {
13891 log_error ("ERROR: Failed to get ADL device capabilities");
13892
13893 return (-1);
13894 }
13895
13896 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
13897 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
13898
13899 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
13900 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
13901
13902 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
13903 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
13904
13905 // warning if profile has to low max values
13906
13907 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
13908 {
13909 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
13910 }
13911
13912 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
13913 {
13914 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
13915 }
13916
13917 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
13918
13919 performance_state->iNumberOfPerformanceLevels = 2;
13920
13921 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
13922 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
13923 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
13924 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
13925
13926 if ((ADL_rc = hc_ADL_Overdrive_State_Set (data.hm_dll, data.hm_device[device_id].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
13927 {
13928 log_info ("ERROR: Failed to set ADL performance state");
13929
13930 return (-1);
13931 }
13932
13933 local_free (performance_state);
13934 }
13935 }
13936
13937 hc_thread_mutex_unlock (mux_adl);
13938 }
13939 }
13940
13941 data.gpu_blocks_all = gpu_blocks_all;
13942
13943 if (data.quiet == 0) log_info ("");
13944
13945 /**
13946 * Inform user which algorithm is checked and at which workload setting
13947 */
13948
13949 if (benchmark == 1)
13950 {
13951 quiet = 0;
13952
13953 data.quiet = quiet;
13954
13955 char *hash_type = strhashtype (data.hash_mode); // not a bug
13956
13957 log_info ("Hashtype: %s", hash_type);
13958 log_info ("Workload: %u loops, %u accel", gpu_loops, gpu_accel);
13959 log_info ("");
13960 }
13961
13962 /**
13963 * keep track of the progress
13964 */
13965
13966 data.words_progress_done = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
13967 data.words_progress_rejected = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
13968 data.words_progress_restored = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
13969
13970 /**
13971 * open filehandles
13972 */
13973
13974 #if _WIN
13975 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
13976 {
13977 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
13978
13979 return (-1);
13980 }
13981
13982 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
13983 {
13984 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
13985
13986 return (-1);
13987 }
13988
13989 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
13990 {
13991 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
13992
13993 return (-1);
13994 }
13995 #endif
13996
13997 /**
13998 * dictionary pad
13999 */
14000
14001 segment_size *= (1024 * 1024);
14002
14003 data.segment_size = segment_size;
14004
14005 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14006
14007 wl_data->buf = (char *) mymalloc (segment_size);
14008 wl_data->avail = segment_size;
14009 wl_data->incr = segment_size;
14010 wl_data->cnt = 0;
14011 wl_data->pos = 0;
14012
14013 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14014
14015 data.wordlist_mode = wordlist_mode;
14016
14017 cs_t *css_buf = NULL;
14018 uint css_cnt = 0;
14019 uint dictcnt = 0;
14020 uint maskcnt = 1;
14021 char **masks = NULL;
14022 char **dictfiles = NULL;
14023
14024 uint mask_from_file = 0;
14025
14026 if (attack_mode == ATTACK_MODE_STRAIGHT)
14027 {
14028 if (wordlist_mode == WL_MODE_FILE)
14029 {
14030 int wls_left = myargc - (optind + 1);
14031
14032 for (int i = 0; i < wls_left; i++)
14033 {
14034 char *l0_filename = myargv[optind + 1 + i];
14035
14036 struct stat l0_stat;
14037
14038 if (stat (l0_filename, &l0_stat) == -1)
14039 {
14040 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14041
14042 return (-1);
14043 }
14044
14045 uint is_dir = S_ISDIR (l0_stat.st_mode);
14046
14047 if (is_dir == 0)
14048 {
14049 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14050
14051 dictcnt++;
14052
14053 dictfiles[dictcnt - 1] = l0_filename;
14054 }
14055 else
14056 {
14057 // do not allow --keyspace w/ a directory
14058
14059 if (keyspace == 1)
14060 {
14061 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14062
14063 return (-1);
14064 }
14065
14066 char **dictionary_files = NULL;
14067
14068 dictionary_files = scan_directory (l0_filename);
14069
14070 if (dictionary_files != NULL)
14071 {
14072 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14073
14074 for (int d = 0; dictionary_files[d] != NULL; d++)
14075 {
14076 char *l1_filename = dictionary_files[d];
14077
14078 struct stat l1_stat;
14079
14080 if (stat (l1_filename, &l1_stat) == -1)
14081 {
14082 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14083
14084 return (-1);
14085 }
14086
14087 if (S_ISREG (l1_stat.st_mode))
14088 {
14089 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14090
14091 dictcnt++;
14092
14093 dictfiles[dictcnt - 1] = strdup (l1_filename);
14094 }
14095 }
14096 }
14097
14098 local_free (dictionary_files);
14099 }
14100 }
14101
14102 if (dictcnt < 1)
14103 {
14104 log_error ("ERROR: No usable dictionary file found.");
14105
14106 return (-1);
14107 }
14108 }
14109 else if (wordlist_mode == WL_MODE_STDIN)
14110 {
14111 dictcnt = 1;
14112 }
14113 }
14114 else if (attack_mode == ATTACK_MODE_COMBI)
14115 {
14116 // display
14117
14118 char *dictfile1 = myargv[optind + 1 + 0];
14119 char *dictfile2 = myargv[optind + 1 + 1];
14120
14121 // find the bigger dictionary and use as base
14122
14123 FILE *fp1;
14124 FILE *fp2;
14125
14126 struct stat tmp_stat;
14127
14128 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14129 {
14130 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14131
14132 return (-1);
14133 }
14134
14135 if (stat (dictfile1, &tmp_stat) == -1)
14136 {
14137 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14138
14139 fclose (fp1);
14140
14141 return (-1);
14142 }
14143
14144 if (S_ISDIR (tmp_stat.st_mode))
14145 {
14146 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14147
14148 fclose (fp1);
14149
14150 return (-1);
14151 }
14152
14153 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14154 {
14155 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14156
14157 fclose (fp1);
14158
14159 return (-1);
14160 }
14161
14162 if (stat (dictfile2, &tmp_stat) == -1)
14163 {
14164 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14165
14166 fclose (fp1);
14167 fclose (fp2);
14168
14169 return (-1);
14170 }
14171
14172 if (S_ISDIR (tmp_stat.st_mode))
14173 {
14174 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14175
14176 fclose (fp1);
14177 fclose (fp2);
14178
14179 return (-1);
14180 }
14181
14182 data.combs_cnt = 1;
14183
14184 data.quiet = 1;
14185
14186 const uint64_t words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14187
14188 data.quiet = quiet;
14189
14190 if (words1_cnt == 0)
14191 {
14192 log_error ("ERROR: %s: empty file", dictfile1);
14193
14194 fclose (fp1);
14195 fclose (fp2);
14196
14197 return (-1);
14198 }
14199
14200 data.combs_cnt = 1;
14201
14202 data.quiet = 1;
14203
14204 const uint64_t words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14205
14206 data.quiet = quiet;
14207
14208 if (words2_cnt == 0)
14209 {
14210 log_error ("ERROR: %s: empty file", dictfile2);
14211
14212 fclose (fp1);
14213 fclose (fp2);
14214
14215 return (-1);
14216 }
14217
14218 fclose (fp1);
14219 fclose (fp2);
14220
14221 data.dictfile = dictfile1;
14222 data.dictfile2 = dictfile2;
14223
14224 if (words1_cnt >= words2_cnt)
14225 {
14226 data.combs_cnt = words2_cnt;
14227 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14228
14229 dictfiles = &data.dictfile;
14230
14231 dictcnt = 1;
14232 }
14233 else
14234 {
14235 data.combs_cnt = words1_cnt;
14236 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14237
14238 dictfiles = &data.dictfile2;
14239
14240 dictcnt = 1;
14241
14242 // we also have to switch wordlist related rules!
14243
14244 char *tmpc = data.rule_buf_l;
14245
14246 data.rule_buf_l = data.rule_buf_r;
14247 data.rule_buf_r = tmpc;
14248
14249 int tmpi = data.rule_len_l;
14250
14251 data.rule_len_l = data.rule_len_r;
14252 data.rule_len_r = tmpi;
14253 }
14254 }
14255 else if (attack_mode == ATTACK_MODE_BF)
14256 {
14257 char *mask = NULL;
14258
14259 maskcnt = 0;
14260
14261 if (benchmark == 0)
14262 {
14263 mask = myargv[optind + 1];
14264
14265 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
14266
14267 if ((optind + 2) <= myargc)
14268 {
14269 struct stat file_stat;
14270
14271 if (stat (mask, &file_stat) == -1)
14272 {
14273 maskcnt = 1;
14274
14275 masks[maskcnt - 1] = mystrdup (mask);
14276 }
14277 else
14278 {
14279 int wls_left = myargc - (optind + 1);
14280
14281 uint masks_avail = INCR_MASKS;
14282
14283 for (int i = 0; i < wls_left; i++)
14284 {
14285 if (i != 0)
14286 {
14287 mask = myargv[optind + 1 + i];
14288
14289 if (stat (mask, &file_stat) == -1)
14290 {
14291 log_error ("ERROR: %s: %s", mask, strerror (errno));
14292
14293 return (-1);
14294 }
14295 }
14296
14297 uint is_file = S_ISREG (file_stat.st_mode);
14298
14299 if (is_file == 1)
14300 {
14301 FILE *mask_fp;
14302
14303 if ((mask_fp = fopen (mask, "r")) == NULL)
14304 {
14305 log_error ("ERROR: %s: %s", mask, strerror (errno));
14306
14307 return (-1);
14308 }
14309
14310 char line_buf[BUFSIZ];
14311
14312 while (!feof (mask_fp))
14313 {
14314 memset (line_buf, 0, BUFSIZ);
14315
14316 int line_len = fgetl (mask_fp, line_buf);
14317
14318 if (line_len == 0) continue;
14319
14320 if (line_buf[0] == '#') continue;
14321
14322 if (masks_avail == maskcnt)
14323 {
14324 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14325
14326 masks_avail += INCR_MASKS;
14327 }
14328
14329 masks[maskcnt] = mystrdup (line_buf);
14330
14331 maskcnt++;
14332 }
14333
14334 fclose (mask_fp);
14335 }
14336 else
14337 {
14338 log_error ("ERROR: %s: unsupported file-type", mask);
14339
14340 return (-1);
14341 }
14342 }
14343
14344 mask_from_file = 1;
14345 }
14346 }
14347 else
14348 {
14349 custom_charset_1 = (char *) "?l?d?u";
14350 custom_charset_2 = (char *) "?l?d";
14351 custom_charset_3 = (char *) "?l?d*!$@_";
14352
14353 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
14354 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
14355 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
14356
14357 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
14358
14359 wordlist_mode = WL_MODE_MASK;
14360
14361 data.wordlist_mode = wordlist_mode;
14362
14363 increment = 1;
14364
14365 maskcnt = 1;
14366 }
14367 }
14368 else
14369 {
14370 /**
14371 * generate full masks and charsets
14372 */
14373
14374 masks = (char **) mymalloc (sizeof (char *));
14375
14376 switch (hash_mode)
14377 {
14378 case 1731: pw_min = 5;
14379 pw_max = 5;
14380 mask = mystrdup ("?b?b?b?b?b");
14381 break;
14382 case 12500: pw_min = 5;
14383 pw_max = 5;
14384 mask = mystrdup ("?b?b?b?b?b");
14385 break;
14386 default: pw_min = 7;
14387 pw_max = 7;
14388 mask = mystrdup ("?b?b?b?b?b?b?b");
14389 break;
14390 }
14391
14392 maskcnt = 1;
14393
14394 masks[maskcnt - 1] = mystrdup (mask);
14395
14396 wordlist_mode = WL_MODE_MASK;
14397
14398 data.wordlist_mode = wordlist_mode;
14399
14400 increment = 1;
14401 }
14402
14403 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
14404
14405 if (increment)
14406 {
14407 if (increment_min > pw_min) pw_min = increment_min;
14408
14409 if (increment_max < pw_max) pw_max = increment_max;
14410 }
14411 }
14412 else if (attack_mode == ATTACK_MODE_HYBRID1)
14413 {
14414 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14415
14416 // display
14417
14418 char *mask = myargv[myargc - 1];
14419
14420 maskcnt = 0;
14421
14422 masks = (char **) mymalloc (1 * sizeof (char *));
14423
14424 // mod
14425
14426 struct stat file_stat;
14427
14428 if (stat (mask, &file_stat) == -1)
14429 {
14430 maskcnt = 1;
14431
14432 masks[maskcnt - 1] = mystrdup (mask);
14433 }
14434 else
14435 {
14436 uint is_file = S_ISREG (file_stat.st_mode);
14437
14438 if (is_file == 1)
14439 {
14440 FILE *mask_fp;
14441
14442 if ((mask_fp = fopen (mask, "r")) == NULL)
14443 {
14444 log_error ("ERROR: %s: %s", mask, strerror (errno));
14445
14446 return (-1);
14447 }
14448
14449 char line_buf[BUFSIZ];
14450
14451 uint masks_avail = 1;
14452
14453 while (!feof (mask_fp))
14454 {
14455 memset (line_buf, 0, BUFSIZ);
14456
14457 int line_len = fgetl (mask_fp, line_buf);
14458
14459 if (line_len == 0) continue;
14460
14461 if (line_buf[0] == '#') continue;
14462
14463 if (masks_avail == maskcnt)
14464 {
14465 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14466
14467 masks_avail += INCR_MASKS;
14468 }
14469
14470 masks[maskcnt] = mystrdup (line_buf);
14471
14472 maskcnt++;
14473 }
14474
14475 fclose (mask_fp);
14476
14477 mask_from_file = 1;
14478 }
14479 else
14480 {
14481 maskcnt = 1;
14482
14483 masks[maskcnt - 1] = mystrdup (mask);
14484 }
14485 }
14486
14487 // base
14488
14489 int wls_left = myargc - (optind + 2);
14490
14491 for (int i = 0; i < wls_left; i++)
14492 {
14493 char *filename = myargv[optind + 1 + i];
14494
14495 struct stat file_stat;
14496
14497 if (stat (filename, &file_stat) == -1)
14498 {
14499 log_error ("ERROR: %s: %s", filename, strerror (errno));
14500
14501 return (-1);
14502 }
14503
14504 uint is_dir = S_ISDIR (file_stat.st_mode);
14505
14506 if (is_dir == 0)
14507 {
14508 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14509
14510 dictcnt++;
14511
14512 dictfiles[dictcnt - 1] = filename;
14513 }
14514 else
14515 {
14516 // do not allow --keyspace w/ a directory
14517
14518 if (keyspace == 1)
14519 {
14520 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14521
14522 return (-1);
14523 }
14524
14525 char **dictionary_files = NULL;
14526
14527 dictionary_files = scan_directory (filename);
14528
14529 if (dictionary_files != NULL)
14530 {
14531 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14532
14533 for (int d = 0; dictionary_files[d] != NULL; d++)
14534 {
14535 char *l1_filename = dictionary_files[d];
14536
14537 struct stat l1_stat;
14538
14539 if (stat (l1_filename, &l1_stat) == -1)
14540 {
14541 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14542
14543 return (-1);
14544 }
14545
14546 if (S_ISREG (l1_stat.st_mode))
14547 {
14548 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14549
14550 dictcnt++;
14551
14552 dictfiles[dictcnt - 1] = strdup (l1_filename);
14553 }
14554 }
14555 }
14556
14557 local_free (dictionary_files);
14558 }
14559 }
14560
14561 if (dictcnt < 1)
14562 {
14563 log_error ("ERROR: No usable dictionary file found.");
14564
14565 return (-1);
14566 }
14567
14568 if (increment)
14569 {
14570 maskcnt = 0;
14571
14572 uint mask_min = increment_min; // we can't reject smaller masks here
14573 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
14574
14575 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
14576 {
14577 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
14578
14579 if (cur_mask == NULL) break;
14580
14581 masks[maskcnt] = cur_mask;
14582
14583 maskcnt++;
14584
14585 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
14586 }
14587 }
14588 }
14589 else if (attack_mode == ATTACK_MODE_HYBRID2)
14590 {
14591 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14592
14593 // display
14594
14595 char *mask = myargv[optind + 1 + 0];
14596
14597 maskcnt = 0;
14598
14599 masks = (char **) mymalloc (1 * sizeof (char *));
14600
14601 // mod
14602
14603 struct stat file_stat;
14604
14605 if (stat (mask, &file_stat) == -1)
14606 {
14607 maskcnt = 1;
14608
14609 masks[maskcnt - 1] = mystrdup (mask);
14610 }
14611 else
14612 {
14613 uint is_file = S_ISREG (file_stat.st_mode);
14614
14615 if (is_file == 1)
14616 {
14617 FILE *mask_fp;
14618
14619 if ((mask_fp = fopen (mask, "r")) == NULL)
14620 {
14621 log_error ("ERROR: %s: %s", mask, strerror (errno));
14622
14623 return (-1);
14624 }
14625
14626 char line_buf[BUFSIZ];
14627
14628 uint masks_avail = 1;
14629
14630 while (!feof (mask_fp))
14631 {
14632 memset (line_buf, 0, BUFSIZ);
14633
14634 int line_len = fgetl (mask_fp, line_buf);
14635
14636 if (line_len == 0) continue;
14637
14638 if (line_buf[0] == '#') continue;
14639
14640 if (masks_avail == maskcnt)
14641 {
14642 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14643
14644 masks_avail += INCR_MASKS;
14645 }
14646
14647 masks[maskcnt] = mystrdup (line_buf);
14648
14649 maskcnt++;
14650 }
14651
14652 fclose (mask_fp);
14653
14654 mask_from_file = 1;
14655 }
14656 else
14657 {
14658 maskcnt = 1;
14659
14660 masks[maskcnt - 1] = mystrdup (mask);
14661 }
14662 }
14663
14664 // base
14665
14666 int wls_left = myargc - (optind + 2);
14667
14668 for (int i = 0; i < wls_left; i++)
14669 {
14670 char *filename = myargv[optind + 2 + i];
14671
14672 struct stat file_stat;
14673
14674 if (stat (filename, &file_stat) == -1)
14675 {
14676 log_error ("ERROR: %s: %s", filename, strerror (errno));
14677
14678 return (-1);
14679 }
14680
14681 uint is_dir = S_ISDIR (file_stat.st_mode);
14682
14683 if (is_dir == 0)
14684 {
14685 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14686
14687 dictcnt++;
14688
14689 dictfiles[dictcnt - 1] = filename;
14690 }
14691 else
14692 {
14693 // do not allow --keyspace w/ a directory
14694
14695 if (keyspace == 1)
14696 {
14697 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14698
14699 return (-1);
14700 }
14701
14702 char **dictionary_files = NULL;
14703
14704 dictionary_files = scan_directory (filename);
14705
14706 if (dictionary_files != NULL)
14707 {
14708 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14709
14710 for (int d = 0; dictionary_files[d] != NULL; d++)
14711 {
14712 char *l1_filename = dictionary_files[d];
14713
14714 struct stat l1_stat;
14715
14716 if (stat (l1_filename, &l1_stat) == -1)
14717 {
14718 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14719
14720 return (-1);
14721 }
14722
14723 if (S_ISREG (l1_stat.st_mode))
14724 {
14725 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14726
14727 dictcnt++;
14728
14729 dictfiles[dictcnt - 1] = strdup (l1_filename);
14730 }
14731 }
14732 }
14733
14734 local_free (dictionary_files);
14735 }
14736 }
14737
14738 if (dictcnt < 1)
14739 {
14740 log_error ("ERROR: No usable dictionary file found.");
14741
14742 return (-1);
14743 }
14744
14745 if (increment)
14746 {
14747 maskcnt = 0;
14748
14749 uint mask_min = increment_min; // we can't reject smaller masks here
14750 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
14751
14752 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
14753 {
14754 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
14755
14756 if (cur_mask == NULL) break;
14757
14758 masks[maskcnt] = cur_mask;
14759
14760 maskcnt++;
14761
14762 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
14763 }
14764 }
14765 }
14766
14767 data.pw_min = pw_min;
14768 data.pw_max = pw_max;
14769
14770 /**
14771 * weak hash check
14772 */
14773
14774 if (weak_hash_threshold >= salts_cnt)
14775 {
14776 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
14777
14778 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
14779 {
14780 weak_hash_check (&data.devices_param[0], salt_pos, gpu_loops);
14781 }
14782 }
14783
14784 // Display hack, guarantee that there is at least one \r before real start
14785
14786 if (data.quiet == 0) log_info_nn ("");
14787
14788 /**
14789 * status and monitor threads
14790 */
14791
14792 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
14793
14794 hc_thread_t i_thread = 0;
14795
14796 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
14797 {
14798 hc_thread_create (i_thread, thread_keypress, &benchmark);
14799 }
14800
14801 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
14802
14803 uint ni_threads_cnt = 0;
14804
14805 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
14806
14807 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
14808
14809 ni_threads_cnt++;
14810
14811 /**
14812 * Outfile remove
14813 */
14814
14815 if (keyspace == 0)
14816 {
14817 if (outfile_check_timer != 0)
14818 {
14819 if (data.outfile_check_directory != NULL)
14820 {
14821 if ((hash_mode != 5200) &&
14822 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
14823 (hash_mode != 9000))
14824 {
14825 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
14826
14827 ni_threads_cnt++;
14828 }
14829 else
14830 {
14831 outfile_check_timer = 0;
14832 }
14833 }
14834 else
14835 {
14836 outfile_check_timer = 0;
14837 }
14838 }
14839 }
14840
14841 /**
14842 * Inform the user if we got some hashes remove because of the pot file remove feature
14843 */
14844
14845 if (data.quiet == 0)
14846 {
14847 if (potfile_remove_cracks > 0)
14848 {
14849 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
14850 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
14851 }
14852 }
14853
14854 data.outfile_check_timer = outfile_check_timer;
14855
14856 /**
14857 * main loop
14858 */
14859
14860 char **induction_dictionaries = NULL;
14861
14862 int induction_dictionaries_cnt = 0;
14863
14864 hcstat_table_t *root_table_buf = NULL;
14865 hcstat_table_t *markov_table_buf = NULL;
14866
14867 uint initial_restore_done = 0;
14868
14869 data.maskcnt = maskcnt;
14870
14871 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
14872 {
14873 if (data.devices_status == STATUS_CRACKED) break;
14874
14875 data.devices_status = STATUS_INIT;
14876
14877 if (maskpos > rd->maskpos)
14878 {
14879 rd->dictpos = 0;
14880 }
14881
14882 rd->maskpos = maskpos;
14883 data.maskpos = maskpos;
14884
14885 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
14886 {
14887 char *mask = masks[maskpos];
14888
14889 if (mask_from_file == 1)
14890 {
14891 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
14892
14893 char *str_ptr;
14894 uint str_pos;
14895
14896 uint mask_offset = 0;
14897
14898 uint separator_cnt;
14899
14900 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
14901 {
14902 str_ptr = strstr (mask + mask_offset, ",");
14903
14904 if (str_ptr == NULL) break;
14905
14906 str_pos = str_ptr - mask;
14907
14908 // escaped separator, i.e. "\,"
14909
14910 if (str_pos > 0)
14911 {
14912 if (mask[str_pos - 1] == '\\')
14913 {
14914 separator_cnt --;
14915
14916 mask_offset = str_pos + 1;
14917
14918 continue;
14919 }
14920 }
14921
14922 // reset the offset
14923
14924 mask_offset = 0;
14925
14926 mask[str_pos] = '\0';
14927
14928 switch (separator_cnt)
14929 {
14930 case 0:
14931 mp_reset_usr (mp_usr, 0);
14932
14933 custom_charset_1 = mask;
14934 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
14935 break;
14936
14937 case 1:
14938 mp_reset_usr (mp_usr, 1);
14939
14940 custom_charset_2 = mask;
14941 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
14942 break;
14943
14944 case 2:
14945 mp_reset_usr (mp_usr, 2);
14946
14947 custom_charset_3 = mask;
14948 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
14949 break;
14950
14951 case 3:
14952 mp_reset_usr (mp_usr, 3);
14953
14954 custom_charset_4 = mask;
14955 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
14956 break;
14957 }
14958
14959 mask = mask + str_pos + 1;
14960 }
14961 }
14962
14963 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
14964 {
14965 if (maskpos > 0)
14966 {
14967 local_free (css_buf);
14968 local_free (data.root_css_buf);
14969 local_free (data.markov_css_buf);
14970
14971 local_free (masks[maskpos - 1]);
14972 }
14973
14974 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
14975
14976 data.mask = mask;
14977 data.css_cnt = css_cnt;
14978 data.css_buf = css_buf;
14979
14980 uint uniq_tbls[SP_PW_MAX][CHARSIZ];
14981
14982 memset (uniq_tbls, 0, sizeof (uniq_tbls));
14983
14984 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
14985
14986 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
14987 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
14988
14989 sp_setup_tbl (install_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
14990
14991 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
14992
14993 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
14994 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
14995
14996 data.root_css_buf = root_css_buf;
14997 data.markov_css_buf = markov_css_buf;
14998
14999 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15000
15001 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15002
15003 local_free (root_table_buf);
15004 local_free (markov_table_buf);
15005
15006 // args
15007
15008 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15009 {
15010 hc_device_param_t *device_param = &data.devices_param[device_id];
15011
15012 device_param->kernel_params_mp[0] = &device_param->d_combs;
15013 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15014 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15015
15016 device_param->kernel_params_mp_buf64[3] = 0;
15017 device_param->kernel_params_mp_buf32[4] = css_cnt;
15018 device_param->kernel_params_mp_buf32[5] = 0;
15019 device_param->kernel_params_mp_buf32[6] = 0;
15020 device_param->kernel_params_mp_buf32[7] = 0;
15021
15022 if (attack_mode == ATTACK_MODE_HYBRID1)
15023 {
15024 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15025 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15026 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15027 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15028 }
15029 else if (attack_mode == ATTACK_MODE_HYBRID2)
15030 {
15031 device_param->kernel_params_mp_buf32[5] = 0;
15032 device_param->kernel_params_mp_buf32[6] = 0;
15033 device_param->kernel_params_mp_buf32[7] = 0;
15034 }
15035
15036 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp[i]);
15037 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp[i]);
15038 for (uint i = 4; i < 8; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp[i]);
15039
15040 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);
15041 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);
15042 }
15043 }
15044 else if (attack_mode == ATTACK_MODE_BF)
15045 {
15046 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15047
15048 if (increment)
15049 {
15050 for (uint i = 0; i < dictcnt; i++)
15051 {
15052 local_free (dictfiles[i]);
15053 }
15054
15055 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15056 {
15057 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15058
15059 if (l1_filename == NULL) break;
15060
15061 dictcnt++;
15062
15063 dictfiles[dictcnt - 1] = l1_filename;
15064 }
15065 }
15066 else
15067 {
15068 dictcnt++;
15069
15070 dictfiles[dictcnt - 1] = mask;
15071 }
15072
15073 if (dictcnt == 0)
15074 {
15075 log_error ("ERROR: Mask is too small");
15076
15077 return (-1);
15078 }
15079 }
15080 }
15081
15082 free (induction_dictionaries);
15083
15084 // induction_dictionaries_cnt = 0; // implied
15085
15086 if (attack_mode != ATTACK_MODE_BF)
15087 {
15088 if (keyspace == 0)
15089 {
15090 induction_dictionaries = scan_directory (induction_directory);
15091
15092 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15093 }
15094 }
15095
15096 if (induction_dictionaries_cnt)
15097 {
15098 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15099 }
15100
15101 /**
15102 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15103 */
15104 if (keyspace == 1)
15105 {
15106 if ((maskcnt > 1) || (dictcnt > 1))
15107 {
15108 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15109
15110 return (-1);
15111 }
15112 }
15113
15114 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15115 {
15116 char *subid = logfile_generate_subid ();
15117
15118 data.subid = subid;
15119
15120 logfile_sub_msg ("START");
15121
15122 data.devices_status = STATUS_INIT;
15123
15124 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (uint64_t));
15125 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (uint64_t));
15126 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (uint64_t));
15127
15128 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15129
15130 data.cpt_pos = 0;
15131
15132 data.cpt_start = time (NULL);
15133
15134 data.cpt_total = 0;
15135
15136 if (data.restore == 0)
15137 {
15138 rd->words_cur = skip;
15139
15140 skip = 0;
15141
15142 data.skip = 0;
15143 }
15144
15145 data.ms_paused = 0;
15146
15147 data.words_cur = rd->words_cur;
15148
15149 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15150 {
15151 hc_device_param_t *device_param = &data.devices_param[device_id];
15152
15153 device_param->speed_pos = 0;
15154
15155 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (uint64_t));
15156 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15157 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15158
15159 device_param->gpu_power = device_param->gpu_power_user;
15160 device_param->gpu_blocks = device_param->gpu_blocks_user;
15161
15162 device_param->outerloop_pos = 0;
15163 device_param->outerloop_left = 0;
15164 device_param->innerloop_pos = 0;
15165 device_param->innerloop_left = 0;
15166
15167 // some more resets:
15168
15169 memset (device_param->pw_caches, 0, 64 * sizeof (pw_cache_t));
15170
15171 memset (device_param->pws_buf, 0, device_param->size_pws);
15172
15173 device_param->pw_cnt = 0;
15174 device_param->pws_cnt = 0;
15175
15176 device_param->words_off = 0;
15177 device_param->words_done = 0;
15178 }
15179
15180 data.gpu_blocks_div = 0;
15181
15182 // figure out some workload
15183
15184 if (attack_mode == ATTACK_MODE_STRAIGHT)
15185 {
15186 if (data.wordlist_mode == WL_MODE_FILE)
15187 {
15188 char *dictfile = NULL;
15189
15190 if (induction_dictionaries_cnt)
15191 {
15192 dictfile = induction_dictionaries[0];
15193 }
15194 else
15195 {
15196 dictfile = dictfiles[dictpos];
15197 }
15198
15199 data.dictfile = dictfile;
15200
15201 logfile_sub_string (dictfile);
15202
15203 for (uint i = 0; i < rp_files_cnt; i++)
15204 {
15205 logfile_sub_var_string ("rulefile", rp_files[i]);
15206 }
15207
15208 FILE *fd2 = fopen (dictfile, "rb");
15209
15210 if (fd2 == NULL)
15211 {
15212 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15213
15214 return (-1);
15215 }
15216
15217 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15218
15219 fclose (fd2);
15220
15221 if (data.words_cnt == 0)
15222 {
15223 if (data.devices_status == STATUS_CRACKED) break;
15224 if (data.devices_status == STATUS_ABORTED) break;
15225
15226 dictpos++;
15227
15228 continue;
15229 }
15230 }
15231 }
15232 else if (attack_mode == ATTACK_MODE_COMBI)
15233 {
15234 char *dictfile = data.dictfile;
15235 char *dictfile2 = data.dictfile2;
15236
15237 logfile_sub_string (dictfile);
15238 logfile_sub_string (dictfile2);
15239
15240 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
15241 {
15242 FILE *fd2 = fopen (dictfile, "rb");
15243
15244 if (fd2 == NULL)
15245 {
15246 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15247
15248 return (-1);
15249 }
15250
15251 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15252
15253 fclose (fd2);
15254 }
15255 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
15256 {
15257 FILE *fd2 = fopen (dictfile2, "rb");
15258
15259 if (fd2 == NULL)
15260 {
15261 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15262
15263 return (-1);
15264 }
15265
15266 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
15267
15268 fclose (fd2);
15269 }
15270
15271 if (data.words_cnt == 0)
15272 {
15273 if (data.devices_status == STATUS_CRACKED) break;
15274 if (data.devices_status == STATUS_ABORTED) break;
15275
15276 dictpos++;
15277
15278 continue;
15279 }
15280 }
15281 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15282 {
15283 char *dictfile = NULL;
15284
15285 if (induction_dictionaries_cnt)
15286 {
15287 dictfile = induction_dictionaries[0];
15288 }
15289 else
15290 {
15291 dictfile = dictfiles[dictpos];
15292 }
15293
15294 data.dictfile = dictfile;
15295
15296 char *mask = data.mask;
15297
15298 logfile_sub_string (dictfile);
15299 logfile_sub_string (mask);
15300
15301 FILE *fd2 = fopen (dictfile, "rb");
15302
15303 if (fd2 == NULL)
15304 {
15305 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15306
15307 return (-1);
15308 }
15309
15310 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15311
15312 fclose (fd2);
15313
15314 if (data.words_cnt == 0)
15315 {
15316 if (data.devices_status == STATUS_CRACKED) break;
15317 if (data.devices_status == STATUS_ABORTED) break;
15318
15319 dictpos++;
15320
15321 continue;
15322 }
15323 }
15324 else if (attack_mode == ATTACK_MODE_BF)
15325 {
15326 local_free (css_buf);
15327 local_free (data.root_css_buf);
15328 local_free (data.markov_css_buf);
15329
15330 char *mask = dictfiles[dictpos];
15331
15332 logfile_sub_string (mask);
15333
15334 // base
15335
15336 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15337
15338 if (opts_type & OPTS_TYPE_PT_UNICODE)
15339 {
15340 uint css_cnt_unicode = css_cnt * 2;
15341
15342 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
15343
15344 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
15345 {
15346 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
15347
15348 css_buf_unicode[j + 1].cs_buf[0] = 0;
15349 css_buf_unicode[j + 1].cs_len = 1;
15350 }
15351
15352 free (css_buf);
15353
15354 css_buf = css_buf_unicode;
15355 css_cnt = css_cnt_unicode;
15356 }
15357
15358 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
15359
15360 uint mask_min = pw_min;
15361 uint mask_max = pw_max;
15362
15363 if (opts_type & OPTS_TYPE_PT_UNICODE)
15364 {
15365 mask_min *= 2;
15366 mask_max *= 2;
15367 }
15368
15369 if ((css_cnt < mask_min) || (css_cnt > mask_max))
15370 {
15371 if (css_cnt < mask_min)
15372 {
15373 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
15374 }
15375
15376 if (css_cnt > mask_max)
15377 {
15378 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
15379 }
15380
15381 // skip to next mask
15382
15383 dictpos++;
15384
15385 rd->dictpos = dictpos;
15386
15387 logfile_sub_msg ("STOP");
15388
15389 continue;
15390 }
15391
15392 uint save_css_cnt = css_cnt;
15393
15394 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15395 {
15396 if (opti_type & OPTI_TYPE_APPENDED_SALT)
15397 {
15398 uint salt_len = (uint) data.salts_buf[0].salt_len;
15399 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
15400
15401 uint css_cnt_salt = css_cnt + salt_len;
15402
15403 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
15404
15405 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
15406
15407 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
15408 {
15409 css_buf_salt[j].cs_buf[0] = salt_buf[i];
15410 css_buf_salt[j].cs_len = 1;
15411 }
15412
15413 free (css_buf);
15414
15415 css_buf = css_buf_salt;
15416 css_cnt = css_cnt_salt;
15417 }
15418 }
15419
15420 data.mask = mask;
15421 data.css_cnt = css_cnt;
15422 data.css_buf = css_buf;
15423
15424 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
15425
15426 uint uniq_tbls[SP_PW_MAX][CHARSIZ];
15427
15428 memset (uniq_tbls, 0, sizeof (uniq_tbls));
15429
15430 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15431
15432 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15433 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15434
15435 sp_setup_tbl (install_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15436
15437 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15438
15439 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15440 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15441
15442 data.root_css_buf = root_css_buf;
15443 data.markov_css_buf = markov_css_buf;
15444
15445 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15446
15447 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15448
15449 local_free (root_table_buf);
15450 local_free (markov_table_buf);
15451
15452 // copy + args
15453
15454 uint css_cnt_l = css_cnt;
15455 uint css_cnt_r;
15456
15457 if (attack_exec == ATTACK_EXEC_ON_GPU)
15458 {
15459 if (save_css_cnt < 6)
15460 {
15461 css_cnt_r = 1;
15462 }
15463 else if (save_css_cnt == 6)
15464 {
15465 css_cnt_r = 2;
15466 }
15467 else
15468 {
15469 if (opts_type & OPTS_TYPE_PT_UNICODE)
15470 {
15471 if (save_css_cnt == 8 || save_css_cnt == 10)
15472 {
15473 css_cnt_r = 2;
15474 }
15475 else
15476 {
15477 css_cnt_r = 4;
15478 }
15479 }
15480 else
15481 {
15482 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
15483 {
15484 css_cnt_r = 3;
15485 }
15486 else
15487 {
15488 css_cnt_r = 4;
15489 }
15490 }
15491 }
15492 }
15493 else
15494 {
15495 css_cnt_r = 1;
15496
15497 /* unfinished code?
15498 int sum = css_buf[css_cnt_r - 1].cs_len;
15499
15500 for (uint i = 1; i < 4 && i < css_cnt; i++)
15501 {
15502 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
15503
15504 css_cnt_r++;
15505
15506 sum *= css_buf[css_cnt_r - 1].cs_len;
15507 }
15508 */
15509 }
15510
15511 css_cnt_l -= css_cnt_r;
15512
15513 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
15514
15515 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15516 {
15517 hc_device_param_t *device_param = &data.devices_param[device_id];
15518
15519 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
15520 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
15521 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
15522
15523 device_param->kernel_params_mp_l_buf64[3] = 0;
15524 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
15525 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
15526 device_param->kernel_params_mp_l_buf32[6] = 0;
15527 device_param->kernel_params_mp_l_buf32[7] = 0;
15528 device_param->kernel_params_mp_l_buf32[8] = 0;
15529
15530 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
15531 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
15532 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
15533 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
15534
15535 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
15536 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
15537 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
15538
15539 device_param->kernel_params_mp_r_buf64[3] = 0;
15540 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
15541 device_param->kernel_params_mp_r_buf32[5] = 0;
15542 device_param->kernel_params_mp_r_buf32[6] = 0;
15543 device_param->kernel_params_mp_r_buf32[7] = 0;
15544
15545 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]);
15546 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]);
15547 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]);
15548
15549 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]);
15550 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]);
15551 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]);
15552
15553 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);
15554 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);
15555 }
15556 }
15557
15558 uint64_t words_base = data.words_cnt;
15559
15560 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
15561 {
15562 if (data.gpu_rules_cnt)
15563 {
15564 words_base /= data.gpu_rules_cnt;
15565 }
15566 }
15567 else if (data.attack_kern == ATTACK_KERN_COMBI)
15568 {
15569 if (data.combs_cnt)
15570 {
15571 words_base /= data.combs_cnt;
15572 }
15573 }
15574 else if (data.attack_kern == ATTACK_KERN_BF)
15575 {
15576 if (data.bfs_cnt)
15577 {
15578 words_base /= data.bfs_cnt;
15579 }
15580 }
15581
15582 data.words_base = words_base;
15583
15584 if (keyspace == 1)
15585 {
15586 log_info ("%llu", (unsigned long long int) words_base);
15587
15588 return (0);
15589 }
15590
15591 if (data.words_cur > data.words_base)
15592 {
15593 log_error ("ERROR: restore value greater keyspace");
15594
15595 return (-1);
15596 }
15597
15598 if (data.words_cur)
15599 {
15600 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
15601 {
15602 for (uint i = 0; i < data.salts_cnt; i++)
15603 {
15604 data.words_progress_restored[i] = data.words_cur * data.gpu_rules_cnt;
15605 }
15606 }
15607 else if (data.attack_kern == ATTACK_KERN_COMBI)
15608 {
15609 for (uint i = 0; i < data.salts_cnt; i++)
15610 {
15611 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
15612 }
15613 }
15614 else if (data.attack_kern == ATTACK_KERN_BF)
15615 {
15616 for (uint i = 0; i < data.salts_cnt; i++)
15617 {
15618 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
15619 }
15620 }
15621 }
15622
15623 /*
15624 * Inform user about possible slow speeds
15625 */
15626
15627 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
15628 {
15629 if (data.words_base < gpu_blocks_all)
15630 {
15631 if (quiet == 0)
15632 {
15633 log_info ("");
15634 log_info ("ATTENTION!");
15635 log_info (" The wordlist or mask you are using is too small.");
15636 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your GPU(s).");
15637 log_info (" The cracking speed will drop.");
15638 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
15639 log_info ("");
15640 }
15641 }
15642 }
15643
15644 /*
15645 * Update loopback file
15646 */
15647
15648 if (loopback == 1)
15649 {
15650 time_t now;
15651
15652 time (&now);
15653
15654 uint random_num = get_random_num (0, 9999);
15655
15656 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
15657
15658 data.loopback_file = loopback_file;
15659 }
15660
15661 /*
15662 * Update dictionary statistic
15663 */
15664
15665 if (keyspace == 0)
15666 {
15667 dictstat_fp = fopen (dictstat, "wb");
15668
15669 if (dictstat_fp)
15670 {
15671 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
15672
15673 fclose (dictstat_fp);
15674 }
15675 }
15676
15677 data.devices_status = STATUS_RUNNING;
15678
15679 if (initial_restore_done == 0)
15680 {
15681 if (data.restore_disable == 0) cycle_restore ();
15682
15683 initial_restore_done = 1;
15684 }
15685
15686 hc_timer_set (&data.timer_running);
15687
15688 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
15689 {
15690 if ((quiet == 0) && (status == 0) && (benchmark == 0))
15691 {
15692 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
15693 if (quiet == 0) fflush (stdout);
15694 }
15695 }
15696 else if (wordlist_mode == WL_MODE_STDIN)
15697 {
15698 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
15699 if (data.quiet == 0) log_info ("");
15700 }
15701
15702 time_t runtime_start;
15703
15704 time (&runtime_start);
15705
15706 data.runtime_start = runtime_start;
15707
15708 /**
15709 * create cracker threads
15710 */
15711
15712 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (devices_cnt, sizeof (hc_thread_t));
15713
15714 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15715 {
15716 hc_device_param_t *device_param = &devices_param[device_id];
15717
15718 device_param->device_id = device_id;
15719
15720 if (wordlist_mode == WL_MODE_STDIN)
15721 {
15722 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
15723 }
15724 else
15725 {
15726 hc_thread_create (c_threads[device_id], thread_calc, device_param);
15727 }
15728 }
15729
15730 // wait for crack threads to exit
15731
15732 hc_thread_wait (devices_cnt, c_threads);
15733
15734 local_free (c_threads);
15735
15736 data.restore = 0;
15737
15738 // finalize task
15739
15740 logfile_sub_var_uint ("status-after-work", data.devices_status);
15741
15742 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
15743
15744 if (data.devices_status == STATUS_CRACKED) break;
15745 if (data.devices_status == STATUS_ABORTED) break;
15746
15747 if (data.devices_status == STATUS_BYPASS)
15748 {
15749 data.devices_status = STATUS_RUNNING;
15750 }
15751
15752 if (induction_dictionaries_cnt)
15753 {
15754 unlink (induction_dictionaries[0]);
15755 }
15756
15757 free (induction_dictionaries);
15758
15759 if (attack_mode != ATTACK_MODE_BF)
15760 {
15761 induction_dictionaries = scan_directory (induction_directory);
15762
15763 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15764 }
15765
15766 if (benchmark == 0)
15767 {
15768 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
15769 {
15770 if (quiet == 0) clear_prompt ();
15771
15772 if (quiet == 0) log_info ("");
15773
15774 if (status == 1)
15775 {
15776 status_display ();
15777 }
15778 else
15779 {
15780 if (quiet == 0) status_display ();
15781 }
15782
15783 if (quiet == 0) log_info ("");
15784 }
15785 }
15786
15787 if (attack_mode == ATTACK_MODE_BF)
15788 {
15789 dictpos++;
15790
15791 rd->dictpos = dictpos;
15792 }
15793 else
15794 {
15795 if (induction_dictionaries_cnt)
15796 {
15797 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15798 }
15799 else
15800 {
15801 dictpos++;
15802
15803 rd->dictpos = dictpos;
15804 }
15805 }
15806
15807 time_t runtime_stop;
15808
15809 time (&runtime_stop);
15810
15811 data.runtime_stop = runtime_stop;
15812
15813 logfile_sub_uint (runtime_start);
15814 logfile_sub_uint (runtime_stop);
15815
15816 logfile_sub_msg ("STOP");
15817
15818 global_free (subid);
15819 }
15820
15821 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
15822
15823 if (data.devices_status == STATUS_CRACKED) break;
15824 if (data.devices_status == STATUS_ABORTED) break;
15825 if (data.devices_status == STATUS_QUIT) break;
15826
15827 if (data.devices_status == STATUS_BYPASS)
15828 {
15829 data.devices_status = STATUS_RUNNING;
15830 }
15831 }
15832
15833 // 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
15834
15835 if (attack_mode == ATTACK_MODE_STRAIGHT)
15836 {
15837 if (data.wordlist_mode == WL_MODE_FILE)
15838 {
15839 if (data.dictfile == NULL)
15840 {
15841 if (dictfiles != NULL)
15842 {
15843 data.dictfile = dictfiles[0];
15844
15845 hc_timer_set (&data.timer_running);
15846 }
15847 }
15848 }
15849 }
15850 // NOTE: combi is okay because it is already set beforehand
15851 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
15852 {
15853 if (data.dictfile == NULL)
15854 {
15855 if (dictfiles != NULL)
15856 {
15857 hc_timer_set (&data.timer_running);
15858
15859 data.dictfile = dictfiles[0];
15860 }
15861 }
15862 }
15863 else if (attack_mode == ATTACK_MODE_BF)
15864 {
15865 if (data.mask == NULL)
15866 {
15867 hc_timer_set (&data.timer_running);
15868
15869 data.mask = masks[0];
15870 }
15871 }
15872
15873 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
15874 {
15875 data.devices_status = STATUS_EXHAUSTED;
15876 }
15877
15878 // if cracked / aborted remove last induction dictionary
15879
15880 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
15881 {
15882 struct stat induct_stat;
15883
15884 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
15885 {
15886 unlink (induction_dictionaries[file_pos]);
15887 }
15888 }
15889
15890 // wait for non-interactive threads
15891
15892 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
15893 {
15894 hc_thread_wait (1, &ni_threads[thread_idx]);
15895 }
15896
15897 local_free (ni_threads);
15898
15899 // wait for interactive threads
15900
15901 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15902 {
15903 hc_thread_wait (1, &i_thread);
15904 }
15905
15906 // we dont need restore file anymore
15907 if (data.restore_disable == 0)
15908 {
15909 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
15910 {
15911 unlink (eff_restore_file);
15912 unlink (new_restore_file);
15913 }
15914 else
15915 {
15916 cycle_restore ();
15917 }
15918 }
15919
15920 // finally save left hashes
15921
15922 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
15923 {
15924 save_hash ();
15925 }
15926
15927 /**
15928 * Clean up
15929 */
15930
15931 if (benchmark == 1)
15932 {
15933 status_benchmark ();
15934
15935 log_info ("");
15936 }
15937 else
15938 {
15939 if (quiet == 0) clear_prompt ();
15940
15941 if (quiet == 0) log_info ("");
15942
15943 if (status == 1)
15944 {
15945 status_display ();
15946 }
15947 else
15948 {
15949 if (quiet == 0) status_display ();
15950 }
15951
15952 if (quiet == 0) log_info ("");
15953 }
15954
15955 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15956 {
15957 hc_device_param_t *device_param = &data.devices_param[device_id];
15958
15959 local_free (device_param->result);
15960
15961 local_free (device_param->pw_caches);
15962
15963 local_free (device_param->combs_buf);
15964
15965 local_free (device_param->hooks_buf);
15966
15967 local_free (device_param->device_name);
15968
15969 local_free (device_param->device_version);
15970
15971 local_free (device_param->driver_version);
15972
15973 if (device_param->pws_buf) myfree (device_param->pws_buf);
15974 if (device_param->d_pws_buf) hc_clReleaseMemObject (device_param->d_pws_buf);
15975 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (device_param->d_pws_amp_buf);
15976 if (device_param->d_rules) hc_clReleaseMemObject (device_param->d_rules);
15977 if (device_param->d_rules_c) hc_clReleaseMemObject (device_param->d_rules_c);
15978 if (device_param->d_combs) hc_clReleaseMemObject (device_param->d_combs);
15979 if (device_param->d_combs_c) hc_clReleaseMemObject (device_param->d_combs_c);
15980 if (device_param->d_bfs) hc_clReleaseMemObject (device_param->d_bfs);
15981 if (device_param->d_bfs_c) hc_clReleaseMemObject (device_param->d_bfs_c);
15982 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (device_param->d_bitmap_s1_a);
15983 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (device_param->d_bitmap_s1_b);
15984 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (device_param->d_bitmap_s1_c);
15985 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (device_param->d_bitmap_s1_d);
15986 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (device_param->d_bitmap_s2_a);
15987 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (device_param->d_bitmap_s2_b);
15988 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (device_param->d_bitmap_s2_c);
15989 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (device_param->d_bitmap_s2_d);
15990 if (device_param->d_plain_bufs) hc_clReleaseMemObject (device_param->d_plain_bufs);
15991 if (device_param->d_digests_buf) hc_clReleaseMemObject (device_param->d_digests_buf);
15992 if (device_param->d_digests_shown) hc_clReleaseMemObject (device_param->d_digests_shown);
15993 if (device_param->d_salt_bufs) hc_clReleaseMemObject (device_param->d_salt_bufs);
15994 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (device_param->d_esalt_bufs);
15995 if (device_param->d_tmps) hc_clReleaseMemObject (device_param->d_tmps);
15996 if (device_param->d_hooks) hc_clReleaseMemObject (device_param->d_hooks);
15997 if (device_param->d_result) hc_clReleaseMemObject (device_param->d_result);
15998 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (device_param->d_scryptV_buf);
15999 if (device_param->d_root_css_buf) hc_clReleaseMemObject (device_param->d_root_css_buf);
16000 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (device_param->d_markov_css_buf);
16001
16002 if (device_param->kernel1) hc_clReleaseKernel (device_param->kernel1);
16003 if (device_param->kernel12) hc_clReleaseKernel (device_param->kernel12);
16004 if (device_param->kernel2) hc_clReleaseKernel (device_param->kernel2);
16005 if (device_param->kernel23) hc_clReleaseKernel (device_param->kernel23);
16006 if (device_param->kernel3) hc_clReleaseKernel (device_param->kernel3);
16007 if (device_param->kernel_mp) hc_clReleaseKernel (device_param->kernel_mp);
16008 if (device_param->kernel_mp_l) hc_clReleaseKernel (device_param->kernel_mp_l);
16009 if (device_param->kernel_mp_r) hc_clReleaseKernel (device_param->kernel_mp_r);
16010
16011 if (device_param->program) hc_clReleaseProgram (device_param->program);
16012 if (device_param->program_mp) hc_clReleaseProgram (device_param->program_mp);
16013 if (device_param->command_queue) hc_clReleaseCommandQueue (device_param->command_queue);
16014 if (device_param->context) hc_clReleaseContext (device_param->context);
16015 }
16016
16017 // reset default fan speed
16018
16019 if (gpu_temp_disable == 0)
16020 {
16021 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16022 {
16023 hc_thread_mutex_lock (mux_adl);
16024
16025 for (uint i = 0; i < data.devices_cnt; i++)
16026 {
16027 if (data.hm_device[i].fan_supported == 1)
16028 {
16029 int fanspeed = temp_retain_fanspeed_value[i];
16030
16031 if (fanspeed == -1) continue;
16032
16033 int rc = hm_set_fanspeed_with_device_id_amd (i, fanspeed);
16034
16035 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", i);
16036 }
16037 }
16038
16039 hc_thread_mutex_unlock (mux_adl);
16040 }
16041 }
16042
16043 // reset power tuning
16044
16045 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16046 {
16047 hc_thread_mutex_lock (mux_adl);
16048
16049 for (uint i = 0; i < data.devices_cnt; i++)
16050 {
16051 if (data.hm_device[i].od_version == 6)
16052 {
16053 // check powertune capabilities first, if not available then skip device
16054
16055 int powertune_supported = 0;
16056
16057 if ((hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll, data.hm_device[i].adapter_index.amd, &powertune_supported)) != ADL_OK)
16058 {
16059 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16060
16061 return (-1);
16062 }
16063
16064 if (powertune_supported != 0)
16065 {
16066 // powercontrol settings
16067
16068 if ((hc_ADL_Overdrive_PowerControl_Set (data.hm_dll, data.hm_device[i].adapter_index.amd, od_power_control_status[i])) != ADL_OK)
16069 {
16070 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16071
16072 return (-1);
16073 }
16074
16075 // clocks
16076
16077 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16078
16079 performance_state->iNumberOfPerformanceLevels = 2;
16080
16081 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[i].state.aLevels[0].iEngineClock;
16082 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[i].state.aLevels[1].iEngineClock;
16083 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[i].state.aLevels[0].iMemoryClock;
16084 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[i].state.aLevels[1].iMemoryClock;
16085
16086 if ((hc_ADL_Overdrive_State_Set (data.hm_dll, data.hm_device[i].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
16087 {
16088 log_info ("ERROR: Failed to restore ADL performance state");
16089
16090 return (-1);
16091 }
16092
16093 local_free (performance_state);
16094 }
16095 }
16096 }
16097
16098 hc_thread_mutex_unlock (mux_adl);
16099 }
16100
16101 if (gpu_temp_disable == 0)
16102 {
16103 if (vendor_id == VENDOR_ID_NV)
16104 {
16105 #ifdef LINUX
16106 hc_NVML_nvmlShutdown (data.hm_dll);
16107 #endif
16108
16109 #ifdef WIN
16110 NvAPI_Unload ();
16111 #endif
16112 }
16113
16114 if (vendor_id == VENDOR_ID_AMD)
16115 {
16116 hc_ADL_Main_Control_Destroy (data.hm_dll);
16117
16118 hm_close (data.hm_dll);
16119 }
16120
16121 #ifdef LINUX
16122 if (vendor_id == VENDOR_ID_NV)
16123 {
16124 hm_close (data.hm_dll);
16125 }
16126 #endif
16127 }
16128
16129 // free memory
16130
16131 local_free (masks);
16132
16133 local_free (dictstat_base);
16134
16135 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16136 {
16137 pot_t *pot_ptr = &pot[pot_pos];
16138
16139 hash_t *hash = &pot_ptr->hash;
16140
16141 local_free (hash->digest);
16142
16143 if (isSalted)
16144 {
16145 local_free (hash->salt);
16146 }
16147 }
16148
16149 local_free (pot);
16150
16151 local_free (all_gpu_rules_cnt);
16152 local_free (all_gpu_rules_buf);
16153
16154 local_free (wl_data->buf);
16155 local_free (wl_data);
16156
16157 local_free (bitmap_s1_a);
16158 local_free (bitmap_s1_b);
16159 local_free (bitmap_s1_c);
16160 local_free (bitmap_s1_d);
16161 local_free (bitmap_s2_a);
16162 local_free (bitmap_s2_b);
16163 local_free (bitmap_s2_c);
16164 local_free (bitmap_s2_d);
16165
16166 local_free (temp_retain_fanspeed_value);
16167 local_free (od_clock_mem_status);
16168 local_free (od_power_control_status);
16169
16170 global_free (devices_param);
16171
16172 global_free (gpu_rules_buf);
16173
16174 global_free (root_css_buf);
16175 global_free (markov_css_buf);
16176
16177 global_free (digests_buf);
16178 global_free (digests_shown);
16179 global_free (digests_shown_tmp);
16180
16181 global_free (salts_buf);
16182 global_free (salts_shown);
16183
16184 global_free (esalts_buf);
16185
16186 global_free (words_progress_done);
16187 global_free (words_progress_rejected);
16188 global_free (words_progress_restored);
16189
16190 if (pot_fp) fclose (pot_fp);
16191
16192 if (data.devices_status == STATUS_QUIT) break;
16193 }
16194
16195 // destroy others mutex
16196
16197 hc_thread_mutex_delete (mux_dispatcher);
16198 hc_thread_mutex_delete (mux_counter);
16199 hc_thread_mutex_delete (mux_display);
16200 hc_thread_mutex_delete (mux_adl);
16201
16202 // free memory
16203
16204 local_free (eff_restore_file);
16205 local_free (new_restore_file);
16206
16207 local_free (rd);
16208
16209 // loopback
16210
16211 local_free (loopback_file);
16212
16213 if (loopback == 1) unlink (loopback_file);
16214
16215 // induction directory
16216
16217 if (induction_dir == NULL)
16218 {
16219 if (attack_mode != ATTACK_MODE_BF)
16220 {
16221 if (rmdir (induction_directory) == -1)
16222 {
16223 if (errno == ENOENT)
16224 {
16225 // good, we can ignore
16226 }
16227 else if (errno == ENOTEMPTY)
16228 {
16229 // good, we can ignore
16230 }
16231 else
16232 {
16233 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
16234
16235 return (-1);
16236 }
16237 }
16238
16239 local_free (induction_directory);
16240 }
16241 }
16242
16243 // outfile-check directory
16244
16245 if (outfile_check_dir == NULL)
16246 {
16247 if (rmdir (outfile_check_directory) == -1)
16248 {
16249 if (errno == ENOENT)
16250 {
16251 // good, we can ignore
16252 }
16253 else if (errno == ENOTEMPTY)
16254 {
16255 // good, we can ignore
16256 }
16257 else
16258 {
16259 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
16260
16261 return (-1);
16262 }
16263 }
16264
16265 local_free (outfile_check_directory);
16266 }
16267
16268 time_t proc_stop;
16269
16270 time (&proc_stop);
16271
16272 logfile_top_uint (proc_start);
16273 logfile_top_uint (proc_stop);
16274
16275 logfile_top_msg ("STOP");
16276
16277 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
16278 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
16279
16280 if (data.devices_status == STATUS_ABORTED) return 2;
16281 if (data.devices_status == STATUS_QUIT) return 2;
16282 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
16283 if (data.devices_status == STATUS_EXHAUSTED) return 1;
16284 if (data.devices_status == STATUS_CRACKED) return 0;
16285
16286 return -1;
16287 }
Hashcat additions to support pwdhash