projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Workaround missing clEnqueueFillBuffer() support in NVidia's OpenCL runtime
[hashcat.git] / src / oclHashcat.c
1 /**
2 * Author......: Jens Steube <jens.steube@gmail.com>
3 * License.....: MIT
4 */
5
6 #include <common.h>
7 #include <shared.h>
8 #include <rp_gpu_on_cpu.h>
9 #include <getopt.h>
10
11 const char *PROGNAME = "oclHashcat";
12 const char *VERSION_TXT = "2.01";
13 const uint VERSION_BIN = 201;
14 const uint RESTORE_MIN = 201;
15
16 #define INCR_RULES 10000
17 #define INCR_SALTS 100000
18 #define INCR_MASKS 1000
19 #define INCR_POT 1000
20
21 // comment-out for kernel source mode
22
23 //#define BINARY_KERNEL
24
25 #define USAGE 0
26 #define VERSION 0
27 #define QUIET 0
28 #define MARKOV_THRESHOLD 0
29 #define MARKOV_DISABLE 0
30 #define MARKOV_CLASSIC 0
31 #define BENCHMARK 0
32 #define BENCHMARK_MODE 1
33 #define RESTORE 0
34 #define RESTORE_TIMER 60
35 #define RESTORE_DISABLE 0
36 #define STATUS 0
37 #define STATUS_TIMER 10
38 #define STATUS_AUTOMAT 0
39 #define LOOPBACK 0
40 #define WEAK_HASH_THRESHOLD 100
41 #define SHOW 0
42 #define LEFT 0
43 #define USERNAME 0
44 #define REMOVE 0
45 #define REMOVE_TIMER 60
46 #define SKIP 0
47 #define LIMIT 0
48 #define KEYSPACE 0
49 #define POTFILE_DISABLE 0
50 #define DEBUG_MODE 0
51 #define RP_GEN 0
52 #define RP_GEN_FUNC_MIN 1
53 #define RP_GEN_FUNC_MAX 4
54 #define RP_GEN_SEED 0
55 #define RULE_BUF_L ":"
56 #define RULE_BUF_R ":"
57 #define FORCE 0
58 #define RUNTIME 0
59 #define HEX_CHARSET 0
60 #define HEX_SALT 0
61 #define HEX_WORDLIST 0
62 #define OUTFILE_FORMAT 3
63 #define OUTFILE_AUTOHEX 1
64 #define OUTFILE_CHECK_TIMER 5
65 #define ATTACK_MODE 0
66 #define HASH_MODE 0
67 #define SEGMENT_SIZE 32
68 #define INCREMENT 0
69 #define INCREMENT_MIN 1
70 #define INCREMENT_MAX PW_MAX
71 #define SEPARATOR ':'
72 #define BITMAP_MIN 16
73 #define BITMAP_MAX 24
74 #define GPU_TEMP_DISABLE 0
75 #define GPU_TEMP_ABORT 90
76 #define GPU_TEMP_RETAIN 80
77 #define WORKLOAD_PROFILE 2
78 #define GPU_ACCEL 0
79 #define GPU_LOOPS 0
80 #define GPU_RULES 1024
81 #define GPU_COMBS 1024
82 #define GPU_BFS 1024
83 #define GPU_THREADS 64
84 #define POWERTUNE_ENABLE 0
85 #define LOGFILE_DISABLE 0
86 #define SCRYPT_TMTO 0
87
88 #define WL_MODE_STDIN 1
89 #define WL_MODE_FILE 2
90 #define WL_MODE_MASK 3
91
92 #define HL_MODE_FILE 4
93 #define HL_MODE_ARG 5
94
95 #define HLFMT_HASHCAT 0
96 #define HLFMT_PWDUMP 1
97 #define HLFMT_PASSWD 2
98 #define HLFMT_SHADOW 3
99 #define HLFMT_DCC 4
100 #define HLFMT_DCC2 5
101 #define HLFMT_NETNTLM1 7
102 #define HLFMT_NETNTLM2 8
103 #define HLFMT_NSLDAP 9
104 #define HLFMT_NSLDAPS 10
105 #define HLFMTS_CNT 11
106
107 #define ATTACK_MODE_STRAIGHT 0
108 #define ATTACK_MODE_COMBI 1
109 #define ATTACK_MODE_TOGGLE 2
110 #define ATTACK_MODE_BF 3
111 #define ATTACK_MODE_PERM 4
112 #define ATTACK_MODE_TABLE 5
113 #define ATTACK_MODE_HYBRID1 6
114 #define ATTACK_MODE_HYBRID2 7
115 #define ATTACK_MODE_NONE 100
116
117 #define ATTACK_KERN_STRAIGHT 0
118 #define ATTACK_KERN_COMBI 1
119 #define ATTACK_KERN_BF 3
120 #define ATTACK_KERN_NONE 100
121
122 #define ATTACK_EXEC_ON_CPU 10
123 #define ATTACK_EXEC_ON_GPU 11
124
125 #define COMBINATOR_MODE_BASE_LEFT 10001
126 #define COMBINATOR_MODE_BASE_RIGHT 10002
127
128 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
129 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
130
131 #define MAX_CUT_TRIES 4
132
133 #define MAX_DICTSTAT 10000
134
135 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 128
136
137 #define global_free(attr) \
138 { \
139 myfree ((void *) data.attr); \
140 \
141 data.attr = NULL; \
142 }
143
144 #define local_free(attr) \
145 { \
146 myfree ((void *) attr); \
147 \
148 attr = NULL; \
149 }
150
151 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
152 {
153 900,
154 0,
155 5100,
156 100,
157 1400,
158 10800,
159 1700,
160 5000,
161 10100,
162 6000,
163 6100,
164 6900,
165 11700,
166 11800,
167 400,
168 8900,
169 11900,
170 12000,
171 10900,
172 12100,
173 23,
174 2500,
175 5300,
176 5400,
177 5500,
178 5600,
179 7300,
180 7500,
181 8300,
182 11100,
183 11200,
184 11400,
185 121,
186 2611,
187 2711,
188 2811,
189 8400,
190 11,
191 2612,
192 7900,
193 21,
194 11000,
195 124,
196 10000,
197 3711,
198 7600,
199 12,
200 131,
201 132,
202 1731,
203 200,
204 300,
205 3100,
206 112,
207 12300,
208 8000,
209 141,
210 1441,
211 1600,
212 12600,
213 1421,
214 101,
215 111,
216 1711,
217 3000,
218 1000,
219 1100,
220 2100,
221 12800,
222 1500,
223 12400,
224 500,
225 3200,
226 7400,
227 1800,
228 122,
229 1722,
230 7100,
231 6300,
232 6700,
233 6400,
234 6500,
235 2400,
236 2410,
237 5700,
238 9200,
239 9300,
240 22,
241 501,
242 5800,
243 8100,
244 8500,
245 7200,
246 9900,
247 7700,
248 7800,
249 10300,
250 8600,
251 8700,
252 9100,
253 133,
254 11600,
255 12500,
256 6211,
257 6221,
258 6231,
259 6241,
260 8800,
261 12200,
262 9700,
263 9710,
264 9800,
265 9810,
266 9400,
267 9500,
268 9600,
269 10400,
270 10410,
271 10500,
272 10600,
273 10700,
274 9000,
275 5200,
276 6800,
277 6600,
278 8200,
279 11300,
280 12700
281 };
282
283 /**
284 * types
285 */
286
287 static void (*get_next_word_func) (char *, uint32_t, uint32_t *, uint32_t *);
288
289 /**
290 * globals
291 */
292
293 static unsigned int full01 = 0x01010101;
294 static unsigned int full80 = 0x80808080;
295
296 int SUPPRESS_OUTPUT = 0;
297
298 hc_thread_mutex_t mux_adl;
299 hc_thread_mutex_t mux_counter;
300 hc_thread_mutex_t mux_dispatcher;
301 hc_thread_mutex_t mux_display;
302
303 hc_global_data_t data;
304
305 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
306
307 const char *USAGE_MINI[] =
308 {
309 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
310 "",
311 "Try --help for more help.",
312 NULL
313 };
314
315 const char *USAGE_BIG[] =
316 {
317 "%s, advanced password recovery",
318 "",
319 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
320 "",
321 "=======",
322 "Options",
323 "=======",
324 "",
325 "* General:",
326 "",
327 " -m, --hash-type=NUM Hash-type, see references below",
328 " -a, --attack-mode=NUM Attack-mode, see references below",
329 " -V, --version Print version",
330 " -h, --help Print help",
331 " --quiet Suppress output",
332 "",
333 "* Benchmark:",
334 "",
335 " -b, --benchmark Run benchmark",
336 " --benchmark-mode=NUM Benchmark-mode, see references below",
337 "",
338 "* Misc:",
339 "",
340 " --hex-charset Assume charset is given in hex",
341 " --hex-salt Assume salt is given in hex",
342 " --hex-wordlist Assume words in wordlist is given in hex",
343 " --force Ignore warnings",
344 " --status Enable automatic update of the status-screen",
345 " --status-timer=NUM Seconds between status-screen update",
346 " --status-automat Display the status view in a machine readable format",
347 " --loopback Add new plains to induct directory",
348 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
349 "",
350 "* Markov:",
351 "",
352 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
353 " --markov-disable Disables markov-chains, emulates classic brute-force",
354 " --markov-classic Enables classic markov-chains, no per-position enhancement",
355 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
356 "",
357 "* Session:",
358 "",
359 " --runtime=NUM Abort session after NUM seconds of runtime",
360 " --session=STR Define specific session name",
361 " --restore Restore session from --session",
362 " --restore-disable Do not write restore file",
363 "",
364 "* Files:",
365 "",
366 " -o, --outfile=FILE Define outfile for recovered hash",
367 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
368 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
369 " --outfile-check-timer=NUM Seconds between outfile checks",
370 " -p, --separator=CHAR Separator char for hashlists and outfile",
371 " --show Show cracked passwords only",
372 " --left Show un-cracked passwords only",
373 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
374 " --remove Enable remove of hash once it is cracked",
375 " --remove-timer=NUM Update input hash file each NUM seconds",
376 " --potfile-disable Do not write potfile",
377 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
378 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
379 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
380 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
381 " --logfile-disable Disable the logfile",
382 " --truecrypt-keyfiles=FILE Keyfiles used, seperate with comma",
383 "",
384 "* Resources:",
385 "",
386 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
387 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
388 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
389 " --cpu-affinity=STR Locks to CPU devices, seperate with comma",
390 " -d, --gpu-devices=STR Devices to use, separate with comma",
391 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
392 " -n, --gpu-accel=NUM Workload tuning: 1, 8, 40, 80, 160",
393 " -u, --gpu-loops=NUM Workload fine-tuning: 8 - 1024",
394 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
395 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
396 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
397 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
398 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
399 "",
400 "* Distributed:",
401 "",
402 " -s, --skip=NUM Skip number of words",
403 " -l, --limit=NUM Limit number of words",
404 " --keyspace Show keyspace base:mod values and quit",
405 "",
406 "* Rules:",
407 "",
408 " -j, --rule-left=RULE Single rule applied to each word from left dict",
409 " -k, --rule-right=RULE Single rule applied to each word from right dict",
410 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
411 " -g, --generate-rules=NUM Generate NUM random rules",
412 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
413 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
414 " --generate-rules-seed=NUM Force RNG seed to NUM",
415 "",
416 "* Custom charsets:",
417 "",
418 " -1, --custom-charset1=CS User-defined charsets",
419 " -2, --custom-charset2=CS Example:",
420 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
421 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
422 "",
423 "* Increment:",
424 "",
425 " -i, --increment Enable increment mode",
426 " --increment-min=NUM Start incrementing at NUM",
427 " --increment-max=NUM Stop incrementing at NUM",
428 "",
429 "==========",
430 "References",
431 "==========",
432 "",
433 "* Workload Profile:",
434 "",
435 " 1 = Reduced performance profile (low latency desktop)",
436 " 2 = Default performance profile",
437 " 3 = Tuned performance profile (high latency desktop)",
438 "",
439 "* Benchmark Settings:",
440 "",
441 " 0 = Manual Tuning",
442 " 1 = Performance Tuning, default",
443 "",
444 "* Outfile Formats:",
445 "",
446 " 1 = hash[:salt]",
447 " 2 = plain",
448 " 3 = hash[:salt]:plain",
449 " 4 = hex_plain",
450 " 5 = hash[:salt]:hex_plain",
451 " 6 = plain:hex_plain",
452 " 7 = hash[:salt]:plain:hex_plain",
453 " 8 = crackpos",
454 " 9 = hash[:salt]:crackpos",
455 " 10 = plain:crackpos",
456 " 11 = hash[:salt]:plain:crackpos",
457 " 12 = hex_plain:crackpos",
458 " 13 = hash[:salt]:hex_plain:crackpos",
459 " 14 = plain:hex_plain:crackpos",
460 " 15 = hash[:salt]:plain:hex_plain:crackpos",
461 "",
462 "* Debug mode output formats (for hybrid mode only, by using rules):",
463 "",
464 " 1 = save finding rule",
465 " 2 = save original word",
466 " 3 = save original word and finding rule",
467 " 4 = save original word, finding rule and modified plain",
468 "",
469 "* Built-in charsets:",
470 "",
471 " ?l = abcdefghijklmnopqrstuvwxyz",
472 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
473 " ?d = 0123456789",
474 " ?s = !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~",
475 " ?a = ?l?u?d?s",
476 " ?b = 0x00 - 0xff",
477 "",
478 "* Attack modes:",
479 "",
480 " 0 = Straight",
481 " 1 = Combination",
482 " 3 = Brute-force",
483 " 6 = Hybrid dict + mask",
484 " 7 = Hybrid mask + dict",
485 "",
486 "* Hash types:",
487 "",
488 "[[ Roll-your-own: Raw Hashes ]]",
489 "",
490 " 900 = MD4",
491 " 0 = MD5",
492 " 5100 = Half MD5",
493 " 100 = SHA1",
494 " 10800 = SHA-384",
495 " 1400 = SHA-256",
496 " 1700 = SHA-512",
497 " 5000 = SHA-3(Keccak)",
498 " 10100 = SipHash",
499 " 6000 = RipeMD160",
500 " 6100 = Whirlpool",
501 " 6900 = GOST R 34.11-94",
502 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
503 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
504 "",
505 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
506 "",
507 " 10 = md5($pass.$salt)",
508 " 20 = md5($salt.$pass)",
509 " 30 = md5(unicode($pass).$salt)",
510 " 40 = md5($salt.unicode($pass))",
511 " 3800 = md5($salt.$pass.$salt)",
512 " 3710 = md5($salt.md5($pass))",
513 " 2600 = md5(md5($pass)",
514 " 4300 = md5(strtoupper(md5($pass)))",
515 " 4400 = md5(sha1($pass))",
516 " 110 = sha1($pass.$salt)",
517 " 120 = sha1($salt.$pass)",
518 " 130 = sha1(unicode($pass).$salt)",
519 " 140 = sha1($salt.unicode($pass))",
520 " 4500 = sha1(sha1($pass)",
521 " 4700 = sha1(md5($pass))",
522 " 4900 = sha1($salt.$pass.$salt)",
523 " 1410 = sha256($pass.$salt)",
524 " 1420 = sha256($salt.$pass)",
525 " 1430 = sha256(unicode($pass).$salt)",
526 " 1440 = sha256($salt.unicode($pass))",
527 " 1710 = sha512($pass.$salt)",
528 " 1720 = sha512($salt.$pass)",
529 " 1730 = sha512(unicode($pass).$salt)",
530 " 1740 = sha512($salt.unicode($pass))",
531 "",
532 "[[ Roll-your-own: Authenticated Hashes ]]",
533 "",
534 " 50 = HMAC-MD5 (key = $pass)",
535 " 60 = HMAC-MD5 (key = $salt)",
536 " 150 = HMAC-SHA1 (key = $pass)",
537 " 160 = HMAC-SHA1 (key = $salt)",
538 " 1450 = HMAC-SHA256 (key = $pass)",
539 " 1460 = HMAC-SHA256 (key = $salt)",
540 " 1750 = HMAC-SHA512 (key = $pass)",
541 " 1760 = HMAC-SHA512 (key = $salt)",
542 "",
543 "[[ Generic KDF ]]",
544 "",
545 " 400 = phpass",
546 " 8900 = scrypt",
547 " 11900 = PBKDF2-HMAC-MD5",
548 " 12000 = PBKDF2-HMAC-SHA1",
549 " 10900 = PBKDF2-HMAC-SHA256",
550 " 12100 = PBKDF2-HMAC-SHA512",
551 "",
552 "[[ Network protocols, Challenge-Response ]]",
553 "",
554 " 23 = Skype",
555 " 2500 = WPA/WPA2",
556 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
557 " 5300 = IKE-PSK MD5",
558 " 5400 = IKE-PSK SHA1",
559 " 5500 = NetNTLMv1",
560 " 5500 = NetNTLMv1 + ESS",
561 " 5600 = NetNTLMv2",
562 " 7300 = IPMI2 RAKP HMAC-SHA1",
563 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
564 " 8300 = DNSSEC (NSEC3)",
565 " 10200 = Cram MD5",
566 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
567 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
568 " 11400 = SIP digest authentication (MD5)",
569 "",
570 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
571 "",
572 " 121 = SMF (Simple Machines Forum)",
573 " 400 = phpBB3",
574 " 2611 = vBulletin < v3.8.5",
575 " 2711 = vBulletin > v3.8.5",
576 " 2811 = MyBB",
577 " 2811 = IPB (Invison Power Board)",
578 " 8400 = WBB3 (Woltlab Burning Board)",
579 " 11 = Joomla < 2.5.18",
580 " 400 = Joomla > 2.5.18",
581 " 400 = Wordpress",
582 " 2612 = PHPS",
583 " 7900 = Drupal7",
584 " 21 = osCommerce",
585 " 21 = xt:Commerce",
586 " 11000 = PrestaShop",
587 " 124 = Django (SHA-1)",
588 " 10000 = Django (PBKDF2-SHA256)",
589 " 3711 = Mediawiki B type",
590 " 7600 = Redmine",
591 "",
592 "[[ Database Server ]]",
593 "",
594 " 12 = PostgreSQL",
595 " 131 = MSSQL(2000)",
596 " 132 = MSSQL(2005)",
597 " 1731 = MSSQL(2012)",
598 " 1731 = MSSQL(2014)",
599 " 200 = MySQL323",
600 " 300 = MySQL4.1/MySQL5",
601 " 3100 = Oracle H: Type (Oracle 7+)",
602 " 112 = Oracle S: Type (Oracle 11+)",
603 " 12300 = Oracle T: Type (Oracle 12+)",
604 " 8000 = Sybase ASE",
605 "",
606 "[[ HTTP, SMTP, LDAP Server]]",
607 "",
608 " 141 = EPiServer 6.x < v4",
609 " 1441 = EPiServer 6.x > v4",
610 " 1600 = Apache $apr1$",
611 " 12600 = ColdFusion 10+",
612 " 1421 = hMailServer",
613 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
614 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
615 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
616 "",
617 "[[ Checksums ]]",
618 "",
619 " 11500 = CRC32",
620 "",
621 "[[ Operating-Systems ]]",
622 "",
623 " 3000 = LM",
624 " 1000 = NTLM",
625 " 1100 = Domain Cached Credentials (DCC), MS Cache",
626 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
627 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
628 " 1500 = descrypt, DES(Unix), Traditional DES",
629 " 12400 = BSDiCrypt, Extended DES",
630 " 500 = md5crypt $1$, MD5(Unix)",
631 " 3200 = bcrypt $2*$, Blowfish(Unix)",
632 " 7400 = sha256crypt $5$, SHA256(Unix)",
633 " 1800 = sha512crypt $6$, SHA512(Unix)",
634 " 122 = OSX v10.4",
635 " 122 = OSX v10.5",
636 " 122 = OSX v10.6",
637 " 1722 = OSX v10.7",
638 " 7100 = OSX v10.8",
639 " 7100 = OSX v10.9",
640 " 7100 = OSX v10.10",
641 " 6300 = AIX {smd5}",
642 " 6700 = AIX {ssha1}",
643 " 6400 = AIX {ssha256}",
644 " 6500 = AIX {ssha512}",
645 " 2400 = Cisco-PIX",
646 " 2410 = Cisco-ASA",
647 " 500 = Cisco-IOS $1$",
648 " 5700 = Cisco-IOS $4$",
649 " 9200 = Cisco-IOS $8$",
650 " 9300 = Cisco-IOS $9$",
651 " 22 = Juniper Netscreen/SSG (ScreenOS)",
652 " 501 = Juniper IVE",
653 " 5800 = Android PIN",
654 " 8100 = Citrix Netscaler",
655 " 8500 = RACF",
656 " 7200 = GRUB 2",
657 " 9900 = Radmin2",
658 "",
659 "[[ Enterprise Application Software (EAS) ]]",
660 "",
661 " 7700 = SAP CODVN B (BCODE)",
662 " 7800 = SAP CODVN F/G (PASSCODE)",
663 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
664 " 8600 = Lotus Notes/Domino 5",
665 " 8700 = Lotus Notes/Domino 6",
666 " 9100 = Lotus Notes/Domino 8",
667 " 133 = PeopleSoft",
668 "",
669 "[[ Archives ]]",
670 "",
671 " 11600 = 7-Zip",
672 " 12500 = RAR3-hp",
673 "",
674 "[[ Full-Disk encryptions (FDE) ]]",
675 "",
676 " 62XY = TrueCrypt 5.0+",
677 " X = 1 = PBKDF2-HMAC-RipeMD160",
678 " X = 2 = PBKDF2-HMAC-SHA512",
679 " X = 3 = PBKDF2-HMAC-Whirlpool",
680 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
681 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
682 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
683 " Y = 3 = XTS 1536 bit (Ciphers: All)",
684 " 8800 = Android FDE < v4.3",
685 " 12200 = eCryptfs",
686 "",
687 "[[ Documents ]]",
688 "",
689 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
690 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
691 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
692 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
693 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
694 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
695 " 9400 = MS Office 2007",
696 " 9500 = MS Office 2010",
697 " 9600 = MS Office 2013",
698 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
699 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
700 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
701 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
702 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
703 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
704 "",
705 "[[ Password Managers ]]",
706 "",
707 " 9000 = Password Safe v2",
708 " 5200 = Password Safe v3",
709 " 6800 = Lastpass",
710 " 6600 = 1Password, agilekeychain",
711 " 8200 = 1Password, cloudkeychain",
712 " 11300 = Bitcoin/Litecoin wallet.dat",
713 " 12700 = Blockchain, My Wallet",
714 "",
715 NULL
716 };
717
718 /**
719 * oclHashcat specific functions
720 */
721
722 void status_display_automat ()
723 {
724 FILE *out = stdout;
725
726 fprintf (out, "STATUS\t%u\t", data.devices_status);
727
728 /**
729 * speed new
730 */
731
732 fprintf (out, "SPEED\t");
733
734 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
735 {
736 hc_device_param_t *device_param = &data.devices_param[device_id];
737
738 uint64_t speed_cnt = 0;
739 float speed_ms = 0;
740
741 for (int i = 0; i < SPEED_CACHE; i++)
742 {
743 float rec_ms;
744
745 hc_timer_get (device_param->speed_rec[i], rec_ms);
746
747 if (rec_ms > SPEED_MAXAGE) continue;
748
749 speed_cnt += device_param->speed_cnt[i];
750 speed_ms += device_param->speed_ms[i];
751 }
752
753 speed_cnt /= SPEED_CACHE;
754 speed_ms /= SPEED_CACHE;
755
756 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
757 }
758
759 /**
760 * words_cur
761 */
762
763 uint64_t words_cur = get_lowest_words_done ();
764
765 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
766
767 /**
768 * counter
769 */
770
771 uint salts_left = data.salts_cnt - data.salts_done;
772
773 if (salts_left == 0) salts_left = 1;
774
775 uint64_t progress_total = data.words_cnt * salts_left;
776
777 uint64_t all_done = 0;
778 uint64_t all_rejected = 0;
779 uint64_t all_restored = 0;
780
781 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
782 {
783 if (salts_left > 1)
784 {
785 // otherwise the final cracked status shows 0/XXX progress
786
787 if (data.salts_shown[salt_pos] == 1) continue;
788 }
789
790 all_done += data.words_progress_done[salt_pos];
791 all_rejected += data.words_progress_rejected[salt_pos];
792 all_restored += data.words_progress_restored[salt_pos];
793 }
794
795 uint64_t progress_cur = all_restored + all_done + all_rejected;
796 uint64_t progress_end = progress_total;
797
798 uint64_t progress_skip = 0;
799
800 if (data.skip)
801 {
802 progress_skip = MIN (data.skip, data.words_base) * salts_left;
803
804 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.gpu_rules_cnt;
805 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
806 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
807 }
808
809 if (data.limit)
810 {
811 progress_end = MIN (data.limit, data.words_base) * salts_left;
812
813 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.gpu_rules_cnt;
814 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
815 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
816 }
817
818 uint64_t progress_cur_relative_skip = progress_cur - progress_skip;
819 uint64_t progress_end_relative_skip = progress_end - progress_skip;
820
821 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
822
823 /**
824 * cracks
825 */
826
827 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
828 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
829
830 /**
831 * temperature
832 */
833
834 if (data.gpu_temp_disable == 0)
835 {
836 fprintf (out, "TEMP\t");
837
838 hc_thread_mutex_lock (mux_adl);
839
840 for (uint i = 0; i < data.devices_cnt; i++)
841 {
842 int temp = hm_get_temperature_with_device_id (i);
843
844 fprintf (out, "%d\t", temp);
845 }
846
847 hc_thread_mutex_unlock (mux_adl);
848 }
849
850 #ifdef _WIN
851 fputc ('\r', out);
852 fputc ('\n', out);
853 #endif
854
855 #ifdef _POSIX
856 fputc ('\n', out);
857 #endif
858
859 fflush (out);
860 }
861
862 void status_display ()
863 {
864 if (data.devices_status == STATUS_INIT) return;
865 if (data.devices_status == STATUS_STARTING) return;
866 if (data.devices_status == STATUS_BYPASS) return;
867
868 if (data.status_automat == 1)
869 {
870 status_display_automat ();
871
872 return;
873 }
874
875 char tmp_buf[1000];
876
877 uint tmp_len = 0;
878
879 log_info ("Session.Name...: %s", data.session);
880
881 char *status_type = strstatus (data.devices_status);
882
883 uint hash_mode = data.hash_mode;
884
885 char *hash_type = strhashtype (hash_mode); // not a bug
886
887 log_info ("Status.........: %s", status_type);
888
889 /**
890 * show rules
891 */
892
893 if (data.rp_files_cnt)
894 {
895 uint i;
896
897 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
898 {
899 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
900 }
901
902 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
903
904 log_info ("Rules.Type.....: %s", tmp_buf);
905
906 tmp_len = 0;
907 }
908
909 if (data.rp_gen)
910 {
911 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
912
913 if (data.rp_gen_seed)
914 {
915 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
916 }
917 }
918
919 /**
920 * show input
921 */
922
923 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
924 {
925 if (data.wordlist_mode == WL_MODE_FILE)
926 {
927 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
928 }
929 else if (data.wordlist_mode == WL_MODE_STDIN)
930 {
931 log_info ("Input.Mode.....: Pipe");
932 }
933 }
934 else if (data.attack_mode == ATTACK_MODE_COMBI)
935 {
936 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
937 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
938 }
939 else if (data.attack_mode == ATTACK_MODE_BF)
940 {
941 char *mask = data.mask;
942
943 if (mask != NULL)
944 {
945 uint mask_len = data.css_cnt;
946
947 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
948
949 if (mask_len > 0)
950 {
951 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
952 {
953 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
954 {
955 mask_len -= data.salts_buf[0].salt_len;
956 }
957 }
958
959 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
960
961 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
962 }
963
964 if (data.maskcnt > 1)
965 {
966 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
967
968 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
969 }
970
971 log_info ("Input.Mode.....: %s", tmp_buf);
972 }
973
974 tmp_len = 0;
975 }
976 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
977 {
978 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
979 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
980 }
981 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
982 {
983 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
984 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
985 }
986
987 if (data.digests_cnt == 1)
988 {
989 if (data.hash_mode == 2500)
990 {
991 wpa_t *wpa = (wpa_t *) data.esalts_buf;
992
993 uint pke[25];
994
995 char *pke_ptr = (char *) pke;
996
997 for (uint i = 0; i < 25; i++)
998 {
999 pke[i] = byte_swap_32 (wpa->pke[i]);
1000 }
1001
1002 char mac1[6];
1003 char mac2[6];
1004
1005 memcpy (mac1, pke_ptr + 23, 6);
1006 memcpy (mac2, pke_ptr + 29, 6);
1007
1008 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1009 (char *) data.salts_buf[0].salt_buf,
1010 mac1[0] & 0xff,
1011 mac1[1] & 0xff,
1012 mac1[2] & 0xff,
1013 mac1[3] & 0xff,
1014 mac1[4] & 0xff,
1015 mac1[5] & 0xff,
1016 mac2[0] & 0xff,
1017 mac2[1] & 0xff,
1018 mac2[2] & 0xff,
1019 mac2[3] & 0xff,
1020 mac2[4] & 0xff,
1021 mac2[5] & 0xff);
1022 }
1023 else if (data.hash_mode == 5200)
1024 {
1025 log_info ("Hash.Target....: File (%s)", data.hashfile);
1026 }
1027 else if (data.hash_mode == 9000)
1028 {
1029 log_info ("Hash.Target....: File (%s)", data.hashfile);
1030 }
1031 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1032 {
1033 log_info ("Hash.Target....: File (%s)", data.hashfile);
1034 }
1035 else
1036 {
1037 char out_buf[4096];
1038
1039 ascii_digest (out_buf, 0, 0);
1040
1041 // limit length
1042 if (strlen (out_buf) > 40)
1043 {
1044 out_buf[41] = '.';
1045 out_buf[42] = '.';
1046 out_buf[43] = '.';
1047 out_buf[44] = 0;
1048 }
1049
1050 log_info ("Hash.Target....: %s", out_buf);
1051 }
1052 }
1053 else
1054 {
1055 if (data.hash_mode == 3000)
1056 {
1057 char out_buf1[4096];
1058 char out_buf2[4096];
1059
1060 ascii_digest (out_buf1, 0, 0);
1061 ascii_digest (out_buf2, 0, 1);
1062
1063 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1064 }
1065 else
1066 {
1067 log_info ("Hash.Target....: File (%s)", data.hashfile);
1068 }
1069 }
1070
1071 log_info ("Hash.Type......: %s", hash_type);
1072
1073 /**
1074 * speed new
1075 */
1076
1077 uint64_t speed_cnt[DEVICES_MAX];
1078 float speed_ms[DEVICES_MAX];
1079
1080 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1081 {
1082 hc_device_param_t *device_param = &data.devices_param[device_id];
1083
1084 // we need to clear values (set to 0) because in case the gpu does
1085 // not get new candidates it idles around but speed display would
1086 // show it as working.
1087 // if we instantly set it to 0 after reading it happens that the
1088 // speed can be shown as zero if the users refreshs to fast.
1089 // therefore, we add a timestamp when a stat was recorded and if its
1090 // to old we will not use it
1091
1092 speed_cnt[device_id] = 0;
1093 speed_ms[device_id] = 0;
1094
1095 for (int i = 0; i < SPEED_CACHE; i++)
1096 {
1097 float rec_ms;
1098
1099 hc_timer_get (device_param->speed_rec[i], rec_ms);
1100
1101 if (rec_ms > SPEED_MAXAGE) continue;
1102
1103 speed_cnt[device_id] += device_param->speed_cnt[i];
1104 speed_ms[device_id] += device_param->speed_ms[i];
1105 }
1106
1107 speed_cnt[device_id] /= SPEED_CACHE;
1108 speed_ms[device_id] /= SPEED_CACHE;
1109 }
1110
1111 float hashes_all_ms = 0;
1112
1113 float hashes_dev_ms[DEVICES_MAX];
1114
1115 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1116 {
1117 hashes_dev_ms[device_id] = 0;
1118
1119 if (speed_ms[device_id])
1120 {
1121 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1122
1123 hashes_all_ms += hashes_dev_ms[device_id];
1124 }
1125 }
1126
1127 /**
1128 * timers
1129 */
1130
1131 float ms_running = 0;
1132
1133 hc_timer_get (data.timer_running, ms_running);
1134
1135 float ms_paused = data.ms_paused;
1136
1137 if (data.devices_status == STATUS_PAUSED)
1138 {
1139 float ms_paused_tmp = 0;
1140
1141 hc_timer_get (data.timer_paused, ms_paused_tmp);
1142
1143 ms_paused += ms_paused_tmp;
1144 }
1145
1146 #ifdef WIN
1147
1148 __time64_t sec_run = ms_running / 1000;
1149
1150 #else
1151
1152 time_t sec_run = ms_running / 1000;
1153
1154 #endif
1155
1156 if (sec_run)
1157 {
1158 char display_run[32];
1159
1160 struct tm tm_run;
1161
1162 struct tm *tmp;
1163
1164 #ifdef WIN
1165
1166 tmp = _gmtime64 (&sec_run);
1167
1168 #else
1169
1170 tmp = gmtime (&sec_run);
1171
1172 #endif
1173
1174 if (tmp != NULL)
1175 {
1176 memcpy (&tm_run, tmp, sizeof (struct tm));
1177
1178 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1179
1180 char *start = ctime (&data.proc_start);
1181
1182 size_t start_len = strlen (start);
1183
1184 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1185 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1186
1187 log_info ("Time.Started...: %s (%s)", start, display_run);
1188 }
1189 }
1190 else
1191 {
1192 log_info ("Time.Started...: 0 secs");
1193 }
1194
1195 /**
1196 * counters
1197 */
1198
1199 uint salts_left = data.salts_cnt - data.salts_done;
1200
1201 if (salts_left == 0) salts_left = 1;
1202
1203 uint64_t progress_total = data.words_cnt * salts_left;
1204
1205 uint64_t all_done = 0;
1206 uint64_t all_rejected = 0;
1207 uint64_t all_restored = 0;
1208
1209 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1210 {
1211 if (salts_left > 1)
1212 {
1213 // otherwise the final cracked status shows 0/XXX progress
1214
1215 if (data.salts_shown[salt_pos] == 1) continue;
1216 }
1217
1218 all_done += data.words_progress_done[salt_pos];
1219 all_rejected += data.words_progress_rejected[salt_pos];
1220 all_restored += data.words_progress_restored[salt_pos];
1221 }
1222
1223 uint64_t progress_cur = all_restored + all_done + all_rejected;
1224 uint64_t progress_end = progress_total;
1225
1226 uint64_t progress_skip = 0;
1227
1228 if (data.skip)
1229 {
1230 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1231
1232 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.gpu_rules_cnt;
1233 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1234 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1235 }
1236
1237 if (data.limit)
1238 {
1239 progress_end = MIN (data.limit, data.words_base) * salts_left;
1240
1241 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.gpu_rules_cnt;
1242 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1243 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1244 }
1245
1246 uint64_t progress_cur_relative_skip = progress_cur - progress_skip;
1247 uint64_t progress_end_relative_skip = progress_end - progress_skip;
1248
1249 float speed_ms_real = ms_running - ms_paused;
1250 uint64_t speed_plains_real = all_done;
1251
1252 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1253 {
1254 if (data.devices_status != STATUS_CRACKED)
1255 {
1256 uint64_t words_per_ms = 0;
1257
1258 if (speed_plains_real && speed_ms_real)
1259 {
1260 words_per_ms = speed_plains_real / speed_ms_real;
1261 }
1262
1263 #ifdef WIN
1264 __time64_t sec_etc = 0;
1265 #else
1266 time_t sec_etc = 0;
1267 #endif
1268
1269 if (words_per_ms)
1270 {
1271 uint64_t progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1272
1273 uint64_t ms_left = progress_left_relative_skip / words_per_ms;
1274
1275 sec_etc = ms_left / 1000;
1276 }
1277
1278 if (sec_etc == 0)
1279 {
1280 log_info ("Time.Estimated.: 0 secs");
1281 }
1282 else if ((uint64_t) sec_etc > ETC_MAX)
1283 {
1284 log_info ("Time.Estimated.: > 10 Years");
1285 }
1286 else
1287 {
1288 char display_etc[32];
1289
1290 struct tm tm_etc;
1291
1292 struct tm *tmp;
1293
1294 #ifdef WIN
1295
1296 tmp = _gmtime64 (&sec_etc);
1297
1298 #else
1299
1300 tmp = gmtime (&sec_etc);
1301
1302 #endif
1303
1304 if (tmp != NULL)
1305 {
1306 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1307
1308 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1309
1310 time_t now;
1311
1312 time (&now);
1313
1314 now += sec_etc;
1315
1316 char *etc = ctime (&now);
1317
1318 size_t etc_len = strlen (etc);
1319
1320 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1321 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1322
1323 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1324 }
1325 }
1326 }
1327 }
1328
1329 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1330 {
1331 char display_dev_cur[16];
1332
1333 memset (display_dev_cur, 0, sizeof (display_dev_cur));
1334
1335 strncpy (display_dev_cur, "0.00", 4);
1336
1337 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1338
1339 log_info ("Speed.GPU.#%d...: %9sH/s", device_id + 1, display_dev_cur);
1340 }
1341
1342 char display_all_cur[16];
1343
1344 memset (display_all_cur, 0, sizeof (display_all_cur));
1345
1346 strncpy (display_all_cur, "0.00", 4);
1347
1348 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1349
1350 if (data.devices_cnt > 1) log_info ("Speed.GPU.#*...: %9sH/s", display_all_cur);
1351
1352 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1353 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1354
1355 log_info ("Recovered......: %u/%u (%.2f%%) Digests, %u/%u (%.2f%%) Salts", data.digests_done, data.digests_cnt, digests_percent * 100, data.salts_done, data.salts_cnt, salts_percent * 100);
1356
1357 // crack-per-time
1358
1359 if (data.digests_cnt > 100)
1360 {
1361 time_t now = time (NULL);
1362
1363 int cpt_cur_min = 0;
1364 int cpt_cur_hour = 0;
1365 int cpt_cur_day = 0;
1366
1367 for (int i = 0; i < CPT_BUF; i++)
1368 {
1369 const uint cracked = data.cpt_buf[i].cracked;
1370 const time_t timestamp = data.cpt_buf[i].timestamp;
1371
1372 if ((timestamp + 60) > now)
1373 {
1374 cpt_cur_min += cracked;
1375 }
1376
1377 if ((timestamp + 3600) > now)
1378 {
1379 cpt_cur_hour += cracked;
1380 }
1381
1382 if ((timestamp + 86400) > now)
1383 {
1384 cpt_cur_day += cracked;
1385 }
1386 }
1387
1388 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1389 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1390 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1391
1392 if ((data.cpt_start + 86400) < now)
1393 {
1394 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1395 cpt_cur_min,
1396 cpt_cur_hour,
1397 cpt_cur_day,
1398 cpt_avg_min,
1399 cpt_avg_hour,
1400 cpt_avg_day);
1401 }
1402 else if ((data.cpt_start + 3600) < now)
1403 {
1404 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1405 cpt_cur_min,
1406 cpt_cur_hour,
1407 cpt_avg_min,
1408 cpt_avg_hour,
1409 cpt_avg_day);
1410 }
1411 else if ((data.cpt_start + 60) < now)
1412 {
1413 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1414 cpt_cur_min,
1415 cpt_avg_min,
1416 cpt_avg_hour,
1417 cpt_avg_day);
1418 }
1419 else
1420 {
1421 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1422 cpt_avg_min,
1423 cpt_avg_hour,
1424 cpt_avg_day);
1425 }
1426 }
1427
1428 // Restore point
1429
1430 uint64_t restore_point = get_lowest_words_done ();
1431
1432 uint64_t restore_total = data.words_base;
1433
1434 float percent_restore = 0;
1435
1436 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1437
1438 if (progress_end_relative_skip)
1439 {
1440 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1441 {
1442 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1443 float percent_rejected = 0.0;
1444
1445 if (progress_cur)
1446 {
1447 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1448 }
1449
1450 log_info ("Progress.......: %llu/%llu (%.02f%%)", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip, percent_finished * 100);
1451 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1452
1453 if (data.restore_disable == 0)
1454 {
1455 if (percent_finished != 1)
1456 {
1457 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1458 }
1459 }
1460 }
1461 }
1462 else
1463 {
1464 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1465 {
1466 log_info ("Progress.......: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1467 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1468
1469 if (data.restore_disable == 0)
1470 {
1471 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1472 }
1473 }
1474 else
1475 {
1476 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1477 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1478
1479 // --restore not allowed if stdin is used -- really? why?
1480
1481 //if (data.restore_disable == 0)
1482 //{
1483 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1484 //}
1485 }
1486 }
1487
1488 if (data.gpu_temp_disable == 0)
1489 {
1490 hc_thread_mutex_lock (mux_adl);
1491
1492 for (uint i = 0; i < data.devices_cnt; i++)
1493 {
1494 if (data.hm_device[i].fan_supported == 1)
1495 {
1496 const int temperature = hm_get_temperature_with_device_id (i);
1497 const int utilization = hm_get_utilization_with_device_id (i);
1498 const int fanspeed = hm_get_fanspeed_with_device_id (i);
1499
1500 if (data.vendor_id == VENDOR_ID_AMD)
1501 {
1502 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, %2d%% Fan", i + 1, utilization, temperature, fanspeed);
1503 }
1504
1505 if (data.vendor_id == VENDOR_ID_NV)
1506 {
1507 #ifdef LINUX
1508 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, %2d%% Fan", i + 1, utilization, temperature, fanspeed);
1509 #else
1510 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, %2drpm Fan", i + 1, utilization, temperature, fanspeed);
1511 #endif
1512 }
1513 }
1514 else
1515 {
1516 const int temperature = hm_get_temperature_with_device_id (i);
1517 const int utilization = hm_get_utilization_with_device_id (i);
1518
1519 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, N/A Fan", i + 1, utilization, temperature);
1520 }
1521 }
1522
1523 hc_thread_mutex_unlock (mux_adl);
1524 }
1525 }
1526
1527 static void status_benchmark ()
1528 {
1529 if (data.devices_status == STATUS_INIT) return;
1530 if (data.devices_status == STATUS_STARTING) return;
1531
1532 if (data.words_cnt == 0) return;
1533
1534 uint64_t speed_cnt[DEVICES_MAX];
1535 float speed_ms[DEVICES_MAX];
1536
1537 uint device_id;
1538
1539 for (device_id = 0; device_id < data.devices_cnt; device_id++)
1540 {
1541 hc_device_param_t *device_param = &data.devices_param[device_id];
1542
1543 speed_cnt[device_id] = 0;
1544 speed_ms[device_id] = 0;
1545
1546 for (int i = 0; i < SPEED_CACHE; i++)
1547 {
1548 speed_cnt[device_id] += device_param->speed_cnt[i];
1549 speed_ms[device_id] += device_param->speed_ms[i];
1550 }
1551
1552 speed_cnt[device_id] /= SPEED_CACHE;
1553 speed_ms[device_id] /= SPEED_CACHE;
1554 }
1555
1556 float hashes_all_ms = 0;
1557
1558 float hashes_dev_ms[DEVICES_MAX];
1559
1560 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1561 {
1562 hashes_dev_ms[device_id] = 0;
1563
1564 if (speed_ms[device_id])
1565 {
1566 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1567
1568 hashes_all_ms += hashes_dev_ms[device_id];
1569 }
1570 }
1571
1572 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1573 {
1574 char display_dev_cur[16];
1575
1576 memset (display_dev_cur, 0, sizeof (display_dev_cur));
1577
1578 strncpy (display_dev_cur, "0.00", 4);
1579
1580 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1581
1582 log_info ("Speed.GPU.#%d.: %9sH/s", device_id + 1, display_dev_cur);
1583 }
1584
1585 char display_all_cur[16];
1586
1587 memset (display_all_cur, 0, sizeof (display_all_cur));
1588
1589 strncpy (display_all_cur, "0.00", 4);
1590
1591 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1592
1593 if (data.devices_cnt > 1) log_info ("Speed.GPU.#*.: %9sH/s", display_all_cur);
1594 }
1595
1596 /**
1597 * oclHashcat -only- functions
1598 */
1599
1600 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *install_dir, char *kernel_file)
1601 {
1602 if (attack_exec == ATTACK_EXEC_ON_GPU)
1603 {
1604 if (attack_kern == ATTACK_KERN_STRAIGHT)
1605 snprintf (kernel_file, 255, "%s/OpenCL/m%05d_a0.cl", install_dir, (int) kern_type);
1606 else if (attack_kern == ATTACK_KERN_COMBI)
1607 snprintf (kernel_file, 255, "%s/OpenCL/m%05d_a1.cl", install_dir, (int) kern_type);
1608 else if (attack_kern == ATTACK_KERN_BF)
1609 snprintf (kernel_file, 255, "%s/OpenCL/m%05d_a3.cl", install_dir, (int) kern_type);
1610 }
1611 else
1612 snprintf (kernel_file, 255, "%s/OpenCL/m%05d.cl", install_dir, (int) kern_type);
1613 }
1614
1615 static uint convert_from_hex (char *line_buf, const uint line_len)
1616 {
1617 if (line_len & 1) return (line_len); // not in hex
1618
1619 if (data.hex_wordlist == 1)
1620 {
1621 uint i;
1622 uint j;
1623
1624 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1625 {
1626 line_buf[i] = hex_to_char (&line_buf[j]);
1627 }
1628
1629 memset (line_buf + i, 0, line_len - i);
1630
1631 return (i);
1632 }
1633 else if (line_len >= 6) // $HEX[] = 6
1634 {
1635 if (line_buf[0] != '$') return (line_len);
1636 if (line_buf[1] != 'H') return (line_len);
1637 if (line_buf[2] != 'E') return (line_len);
1638 if (line_buf[3] != 'X') return (line_len);
1639 if (line_buf[4] != '[') return (line_len);
1640 if (line_buf[line_len - 1] != ']') return (line_len);
1641
1642 uint i;
1643 uint j;
1644
1645 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1646 {
1647 line_buf[i] = hex_to_char (&line_buf[j]);
1648 }
1649
1650 memset (line_buf + i, 0, line_len - i);
1651
1652 return (i);
1653 }
1654
1655 return (line_len);
1656 }
1657
1658 static uint count_lines (FILE *fd)
1659 {
1660 uint cnt = 0;
1661
1662 char *buf = (char *) mymalloc (BUFSIZ);
1663
1664 size_t nread_tmp = 0;
1665
1666 char *ptr = buf;
1667
1668 while (!feof (fd))
1669 {
1670 size_t nread = fread (buf, sizeof (char), BUFSIZ, fd);
1671 nread_tmp = nread;
1672
1673 if (nread < 1) continue;
1674
1675 ptr = buf;
1676
1677 do
1678 {
1679 if (*ptr++ == '\n') cnt++;
1680
1681 } while (nread--);
1682 }
1683
1684 // special case (if last line did not contain a newline char ... at the very end of the file)
1685
1686 if (nread_tmp > 3)
1687 {
1688 ptr -= 2;
1689
1690 if (*ptr != '\n')
1691 {
1692 ptr--;
1693
1694 if (*ptr != '\n') // needed ? different on windows systems?
1695 {
1696 cnt++;
1697 }
1698 }
1699 }
1700
1701 myfree (buf);
1702
1703 return cnt;
1704 }
1705
1706 static void clear_prompt ()
1707 {
1708 fputc ('\r', stdout);
1709
1710 for (size_t i = 0; i < strlen (PROMPT); i++)
1711 {
1712 fputc (' ', stdout);
1713 }
1714
1715 fputc ('\r', stdout);
1716
1717 fflush (stdout);
1718 }
1719
1720 static void gidd_to_pw_t (hc_device_param_t *device_param, const uint64_t gidd, pw_t *pw)
1721 {
1722 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1723 }
1724
1725 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1726 {
1727 char *outfile = data.outfile;
1728 uint quiet = data.quiet;
1729 FILE *pot_fp = data.pot_fp;
1730 uint loopback = data.loopback;
1731 uint debug_mode = data.debug_mode;
1732 char *debug_file = data.debug_file;
1733
1734 char debug_rule_buf[BLOCK_SIZE];
1735 int debug_rule_len = 0; // -1 error
1736 uint debug_plain_len = 0;
1737
1738 unsigned char debug_plain_ptr[BLOCK_SIZE];
1739
1740 // hash
1741
1742 char out_buf[4096]; memset (out_buf, 0, sizeof (out_buf));
1743
1744 ascii_digest (out_buf, salt_pos, digest_pos);
1745
1746 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1747
1748 // plain
1749
1750 plain_t plain;
1751
1752 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, idx * sizeof (plain_t), sizeof (plain_t), &plain, 0, NULL, NULL);
1753
1754 uint gidvid = plain.gidvid;
1755 uint il_pos = plain.il_pos;
1756
1757 uint64_t crackpos = device_param->words_off;
1758
1759 uint plain_buf[16];
1760
1761 unsigned char *plain_ptr = (unsigned char *) plain_buf;
1762 unsigned int plain_len = 0;
1763
1764 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1765 {
1766 uint64_t gidd = gidvid;
1767 uint64_t gidm = 0;
1768
1769 pw_t pw;
1770
1771 gidd_to_pw_t (device_param, gidd, &pw);
1772
1773 for (int i = 0, j = gidm; i < 16; i++, j++)
1774 {
1775 plain_buf[i] = pw.hi1[0][j];
1776 }
1777
1778 plain_len = pw.pw_len;
1779
1780 const uint off = device_param->innerloop_pos + il_pos;
1781
1782 if (debug_mode > 0)
1783 {
1784 debug_rule_len = 0;
1785
1786 // save rule
1787 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1788 {
1789 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1790
1791 debug_rule_len = gpu_rule_to_cpu_rule (debug_rule_buf, &data.gpu_rules_buf[off]);
1792 }
1793
1794 // save plain
1795 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1796 {
1797 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1798
1799 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1800
1801 debug_plain_len = plain_len;
1802 }
1803 }
1804
1805 plain_len = apply_rules (data.gpu_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1806
1807 crackpos += gidvid;
1808 crackpos *= data.gpu_rules_cnt;
1809 crackpos += device_param->innerloop_pos + il_pos;
1810
1811 if (plain_len > data.pw_max) plain_len = data.pw_max;
1812 }
1813 else if (data.attack_mode == ATTACK_MODE_COMBI)
1814 {
1815 uint64_t gidd = gidvid;
1816 uint64_t gidm = 0;
1817
1818 pw_t pw;
1819
1820 gidd_to_pw_t (device_param, gidd, &pw);
1821
1822 for (int i = 0, j = gidm; i < 16; i++, j++)
1823 {
1824 plain_buf[i] = pw.hi1[0][j];
1825 }
1826
1827 plain_len = pw.pw_len;
1828
1829 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1830 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1831
1832 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1833 {
1834 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1835 }
1836 else
1837 {
1838 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1839
1840 memcpy (plain_ptr, comb_buf, comb_len);
1841 }
1842
1843 plain_len += comb_len;
1844
1845 crackpos += gidvid;
1846 crackpos *= data.combs_cnt;
1847 crackpos += device_param->innerloop_pos + il_pos;
1848
1849 if (data.pw_max != PW_DICTMAX1)
1850 {
1851 if (plain_len > data.pw_max) plain_len = data.pw_max;
1852 }
1853 }
1854 else if (data.attack_mode == ATTACK_MODE_BF)
1855 {
1856 uint64_t l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1857 uint64_t r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1858
1859 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1860 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1861
1862 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1863 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1864
1865 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1866 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1867
1868 plain_len = data.css_cnt;
1869
1870 crackpos += gidvid;
1871 crackpos *= data.bfs_cnt;
1872 crackpos += device_param->innerloop_pos + il_pos;
1873 }
1874 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1875 {
1876 uint64_t gidd = gidvid;
1877 uint64_t gidm = 0;
1878
1879 pw_t pw;
1880
1881 gidd_to_pw_t (device_param, gidd, &pw);
1882
1883 for (int i = 0, j = gidm; i < 16; i++, j++)
1884 {
1885 plain_buf[i] = pw.hi1[0][j];
1886 }
1887
1888 plain_len = pw.pw_len;
1889
1890 uint64_t off = device_param->kernel_params_mp_buf64[3] + il_pos;
1891
1892 uint start = 0;
1893 uint stop = device_param->kernel_params_mp_buf32[4];
1894
1895 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
1896
1897 plain_len += start + stop;
1898
1899 crackpos += gidvid;
1900 crackpos *= data.combs_cnt;
1901 crackpos += device_param->innerloop_pos + il_pos;
1902
1903 if (data.pw_max != PW_DICTMAX1)
1904 {
1905 if (plain_len > data.pw_max) plain_len = data.pw_max;
1906 }
1907 }
1908 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1909 {
1910 uint64_t gidd = gidvid;
1911 uint64_t gidm = 0;
1912
1913 pw_t pw;
1914
1915 gidd_to_pw_t (device_param, gidd, &pw);
1916
1917 for (int i = 0, j = gidm; i < 16; i++, j++)
1918 {
1919 plain_buf[i] = pw.hi1[0][j];
1920 }
1921
1922 plain_len = pw.pw_len;
1923
1924 uint64_t off = device_param->kernel_params_mp_buf64[3] + il_pos;
1925
1926 uint start = 0;
1927 uint stop = device_param->kernel_params_mp_buf32[4];
1928
1929 memmove (plain_ptr + stop, plain_ptr, plain_len);
1930
1931 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
1932
1933 plain_len += start + stop;
1934
1935 crackpos += gidvid;
1936 crackpos *= data.combs_cnt;
1937 crackpos += device_param->innerloop_pos + il_pos;
1938
1939 if (data.pw_max != PW_DICTMAX1)
1940 {
1941 if (plain_len > data.pw_max) plain_len = data.pw_max;
1942 }
1943 }
1944
1945 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
1946 {
1947 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1948 {
1949 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1950 {
1951 plain_len = plain_len - data.salts_buf[0].salt_len;
1952 }
1953 }
1954
1955 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
1956 {
1957 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
1958 {
1959 plain_ptr[j] = plain_ptr[i];
1960 }
1961
1962 plain_len = plain_len / 2;
1963 }
1964 }
1965
1966 // if enabled, update also the potfile
1967
1968 if (pot_fp)
1969 {
1970 fprintf (pot_fp, "%s:", out_buf);
1971
1972 format_plain (pot_fp, plain_ptr, plain_len, 1);
1973
1974 fputc ('\n', pot_fp);
1975
1976 fflush (pot_fp);
1977 }
1978
1979 // outfile
1980
1981 FILE *out_fp = NULL;
1982
1983 if (outfile != NULL)
1984 {
1985 if ((out_fp = fopen (outfile, "ab")) == NULL)
1986 {
1987 log_error ("ERROR: %s: %s", outfile, strerror (errno));
1988
1989 out_fp = stdout;
1990 }
1991 }
1992 else
1993 {
1994 out_fp = stdout;
1995
1996 if (quiet == 0) clear_prompt ();
1997 }
1998
1999 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2000
2001 if (outfile != NULL)
2002 {
2003 if (out_fp != stdout)
2004 {
2005 fclose (out_fp);
2006 }
2007 }
2008 else
2009 {
2010 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2011 {
2012 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2013 {
2014 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2015 if (quiet == 0) fflush (stdout);
2016 }
2017 }
2018 }
2019
2020 // loopback
2021
2022 if (loopback)
2023 {
2024 char *loopback_file = data.loopback_file;
2025
2026 FILE *fb_fp = NULL;
2027
2028 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2029 {
2030 format_plain (fb_fp, plain_ptr, plain_len, 1);
2031
2032 fputc ('\n', fb_fp);
2033
2034 fclose (fb_fp);
2035 }
2036 }
2037
2038 // (rule) debug mode
2039
2040 // the next check implies that:
2041 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2042 // - debug_mode > 0
2043
2044 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2045 {
2046 if (debug_rule_len < 0) debug_rule_len = 0;
2047
2048 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2049
2050 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2051
2052 if ((quiet == 0) && (debug_file == NULL))
2053 {
2054 fprintf (stdout, "%s", PROMPT);
2055 fflush (stdout);
2056 }
2057 }
2058 }
2059
2060 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2061 {
2062 salt_t *salt_buf = &data.salts_buf[salt_pos];
2063
2064 int found = 0;
2065
2066 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2067
2068 for (uint i = 0; i < GPU_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2069
2070 if (found == 1)
2071 {
2072 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2073
2074 log_info_nn ("");
2075
2076 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2077
2078 uint cpt_cracked = 0;
2079
2080 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2081 {
2082 uint idx = salt_buf->digests_offset + digest_pos;
2083
2084 if (data.digests_shown_tmp[idx] == 0) continue;
2085
2086 if (data.digests_shown[idx] == 1) continue;
2087
2088 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2089 {
2090 data.digests_shown[idx] = 1;
2091
2092 data.digests_done++;
2093
2094 cpt_cracked++;
2095
2096 salt_buf->digests_done++;
2097
2098 if (salt_buf->digests_done == salt_buf->digests_cnt)
2099 {
2100 data.salts_shown[salt_pos] = 1;
2101
2102 data.salts_done++;
2103 }
2104 }
2105
2106 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2107
2108 check_hash (device_param, salt_pos, digest_pos);
2109 }
2110
2111 if (cpt_cracked > 0)
2112 {
2113 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2114 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2115
2116 data.cpt_pos++;
2117
2118 data.cpt_total += cpt_cracked;
2119
2120 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2121 }
2122
2123 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2124 {
2125 // we need to reset cracked state on the gpu
2126 // otherwise host thinks again and again the hash was cracked
2127 // and returns invalid password each time
2128
2129 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2130
2131 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2132 }
2133
2134 memset (device_param->result, 0, device_param->size_results);
2135
2136 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2137 }
2138 }
2139
2140 static void save_hash ()
2141 {
2142 char *hashfile = data.hashfile;
2143
2144 char new_hashfile[256];
2145 char old_hashfile[256];
2146
2147 memset (new_hashfile, 0, sizeof (new_hashfile));
2148 memset (old_hashfile, 0, sizeof (old_hashfile));
2149
2150 snprintf (new_hashfile, 255, "%s.new", hashfile);
2151 snprintf (old_hashfile, 255, "%s.old", hashfile);
2152
2153 unlink (new_hashfile);
2154
2155 char separator = data.separator;
2156
2157 FILE *fp = fopen (new_hashfile, "wb");
2158
2159 if (fp == NULL)
2160 {
2161 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2162
2163 exit (-1);
2164 }
2165
2166 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2167 {
2168 if (data.salts_shown[salt_pos] == 1) continue;
2169
2170 salt_t *salt_buf = &data.salts_buf[salt_pos];
2171
2172 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2173 {
2174 uint idx = salt_buf->digests_offset + digest_pos;
2175
2176 if (data.digests_shown[idx] == 1) continue;
2177
2178 if (data.hash_mode != 2500)
2179 {
2180 char out_buf[4096];
2181
2182 memset (out_buf, 0, sizeof (out_buf));
2183
2184 if (data.username == 1)
2185 {
2186 user_t *user = data.hash_info[idx]->user;
2187
2188 uint i;
2189
2190 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2191
2192 fputc (separator, fp);
2193 }
2194
2195 ascii_digest (out_buf, salt_pos, digest_pos);
2196
2197 fputs (out_buf, fp);
2198
2199 log_out (fp, "");
2200 }
2201 else
2202 {
2203 hccap_t hccap;
2204
2205 to_hccap_t (&hccap, salt_pos, digest_pos);
2206
2207 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2208 }
2209 }
2210 }
2211
2212 fflush (fp);
2213
2214 fclose (fp);
2215
2216 unlink (old_hashfile);
2217
2218 if (rename (hashfile, old_hashfile) != 0)
2219 {
2220 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2221
2222 exit (-1);
2223 }
2224
2225 unlink (hashfile);
2226
2227 if (rename (new_hashfile, hashfile) != 0)
2228 {
2229 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2230
2231 exit (-1);
2232 }
2233
2234 unlink (old_hashfile);
2235 }
2236
2237 static float find_gpu_blocks_div (const uint64_t total_left, const uint gpu_blocks_all)
2238 {
2239 // function called only in case gpu_blocks_all > words_left)
2240
2241 float gpu_blocks_div = (float) (total_left) / gpu_blocks_all;
2242
2243 gpu_blocks_div += gpu_blocks_div / 100;
2244
2245 uint32_t gpu_blocks_new = (uint32_t) (gpu_blocks_all * gpu_blocks_div);
2246
2247 while (gpu_blocks_new < total_left)
2248 {
2249 gpu_blocks_div += gpu_blocks_div / 100;
2250
2251 gpu_blocks_new = (uint32_t) (gpu_blocks_all * gpu_blocks_div);
2252 }
2253
2254 if (data.quiet == 0)
2255 {
2256 clear_prompt ();
2257
2258 log_info ("");
2259
2260 log_info ("INFO: approaching final keyspace, workload adjusted");
2261
2262 log_info ("");
2263
2264 fprintf (stdout, "%s", PROMPT);
2265
2266 fflush (stdout);
2267 }
2268
2269 if ((gpu_blocks_all * gpu_blocks_div) < 8) return 1;
2270
2271 return gpu_blocks_div;
2272 }
2273
2274 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num)
2275 {
2276 uint num_elements = num;
2277
2278 device_param->kernel_params_buf32[30] = data.combs_mode;
2279 device_param->kernel_params_buf32[31] = num;
2280
2281 uint gpu_threads = device_param->gpu_threads;
2282
2283 while (num_elements % gpu_threads) num_elements++;
2284
2285 cl_kernel kernel = NULL;
2286
2287 switch (kern_run)
2288 {
2289 case KERN_RUN_1: kernel = device_param->kernel1; break;
2290 case KERN_RUN_12: kernel = device_param->kernel12; break;
2291 case KERN_RUN_2: kernel = device_param->kernel2; break;
2292 case KERN_RUN_23: kernel = device_param->kernel23; break;
2293 case KERN_RUN_3: kernel = device_param->kernel3; break;
2294 }
2295
2296 hc_clSetKernelArg (kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2297 hc_clSetKernelArg (kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2298 hc_clSetKernelArg (kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2299 hc_clSetKernelArg (kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2300 hc_clSetKernelArg (kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2301 hc_clSetKernelArg (kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2302 hc_clSetKernelArg (kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2303 hc_clSetKernelArg (kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2304 hc_clSetKernelArg (kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2305 hc_clSetKernelArg (kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2306 hc_clSetKernelArg (kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2307
2308 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2309 {
2310 const size_t global_work_size[3] = { num_elements, 32, 1 };
2311 const size_t local_work_size[3] = { gpu_threads / 32, 32, 1 };
2312
2313 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2314 }
2315 else
2316 {
2317 const size_t global_work_size[3] = { num_elements, 1, 1 };
2318 const size_t local_work_size[3] = { gpu_threads, 1, 1 };
2319
2320 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2321 }
2322
2323 hc_clFlush (device_param->command_queue);
2324
2325 hc_clFinish (device_param->command_queue);
2326 }
2327
2328 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2329 {
2330 uint num_elements = num;
2331
2332 switch (kern_run)
2333 {
2334 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2335 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2336 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2337 }
2338
2339 // causes problems with special threads like in bcrypt
2340 // const uint gpu_threads = device_param->gpu_threads;
2341
2342 const uint gpu_threads = GPU_THREADS;
2343
2344 while (num_elements % gpu_threads) num_elements++;
2345
2346 cl_kernel kernel = NULL;
2347
2348 switch (kern_run)
2349 {
2350 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2351 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2352 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2353 }
2354
2355 switch (kern_run)
2356 {
2357 case KERN_RUN_MP: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2358 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2359 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2360 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2361 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2362 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2363 break;
2364 case KERN_RUN_MP_R: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2365 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2366 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2367 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2368 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2369 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2370 break;
2371 case KERN_RUN_MP_L: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2372 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2373 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2374 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2375 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2376 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2377 hc_clSetKernelArg (kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2378 break;
2379 }
2380
2381 const size_t global_work_size[3] = { num_elements, 1, 1 };
2382 const size_t local_work_size[3] = { gpu_threads, 1, 1 };
2383
2384 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2385
2386 hc_clFlush (device_param->command_queue);
2387
2388 hc_clFinish (device_param->command_queue);
2389 }
2390
2391 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2392 {
2393 uint num_elements = num;
2394
2395 uint gpu_threads = device_param->gpu_threads;
2396
2397 while (num_elements % gpu_threads) num_elements++;
2398
2399 cl_kernel kernel = device_param->kernel_tb;
2400
2401 const size_t global_work_size[3] = { num_elements, 1, 1 };
2402 const size_t local_work_size[3] = { gpu_threads, 1, 1 };
2403
2404 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2405
2406 hc_clFlush (device_param->command_queue);
2407
2408 hc_clFinish (device_param->command_queue);
2409 }
2410
2411 static void run_kernel_tm (hc_device_param_t *device_param)
2412 {
2413 const uint num_elements = 1024; // fixed
2414
2415 const uint gpu_threads = 32;
2416
2417 cl_kernel kernel = device_param->kernel_tm;
2418
2419 const size_t global_work_size[3] = { num_elements, 1, 1 };
2420 const size_t local_work_size[3] = { gpu_threads, 1, 1 };
2421
2422 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2423
2424 hc_clFlush (device_param->command_queue);
2425
2426 hc_clFinish (device_param->command_queue);
2427 }
2428
2429 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2430 {
2431 uint num_elements = num;
2432
2433 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2434 device_param->kernel_params_amp_buf32[6] = num_elements;
2435
2436 // causes problems with special threads like in bcrypt
2437 // const uint gpu_threads = device_param->gpu_threads;
2438
2439 const uint gpu_threads = GPU_THREADS;
2440
2441 while (num_elements % gpu_threads) num_elements++;
2442
2443 cl_kernel kernel = device_param->kernel_amp;
2444
2445 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2446 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2447
2448 const size_t global_work_size[3] = { num_elements, 1, 1 };
2449 const size_t local_work_size[3] = { gpu_threads, 1, 1 };
2450
2451 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2452
2453 hc_clFlush (device_param->command_queue);
2454
2455 hc_clFinish (device_param->command_queue);
2456 }
2457
2458 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2459 {
2460 if (data.vendor_id == VENDOR_ID_AMD)
2461 {
2462 const cl_uchar zero = 0;
2463
2464 hc_clEnqueueFillBuffer (device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2465 }
2466
2467 if (data.vendor_id == VENDOR_ID_NV)
2468 {
2469 // NOTE: clEnqueueFillBuffer () always fails with -59
2470 // IOW, it's not supported by Nvidia ForceWare <= 352.21,
2471 // How's that possible, OpenCL 1.2 support is advertised??
2472 // We need to workaround...
2473
2474 #define FILLSZ 0x100000
2475
2476 char *tmp = (char *) mymalloc (FILLSZ);
2477
2478 memset (tmp, 0, FILLSZ);
2479
2480 for (uint i = 0; i < size; i += FILLSZ)
2481 {
2482 const int left = size - i;
2483
2484 const int fillsz = MIN (FILLSZ, left);
2485
2486 hc_clEnqueueWriteBuffer (device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2487 }
2488
2489 myfree (tmp);
2490 }
2491 }
2492
2493 static int run_rule_engine (const int rule_len, const char *rule_buf)
2494 {
2495 if (rule_len == 0)
2496 {
2497 return 0;
2498 }
2499 else if (rule_len == 1)
2500 {
2501 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2502 }
2503
2504 return 1;
2505 }
2506
2507 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2508 {
2509 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2510 {
2511 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);
2512 }
2513 else if (data.attack_kern == ATTACK_KERN_COMBI)
2514 {
2515 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);
2516 }
2517 else if (data.attack_kern == ATTACK_KERN_BF)
2518 {
2519 const uint64_t off = device_param->words_off;
2520
2521 device_param->kernel_params_mp_l_buf64[3] = off;
2522
2523 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2524 }
2525 }
2526
2527 static void run_cracker (hc_device_param_t *device_param, const uint pw_cnt, const uint pws_cnt)
2528 {
2529 const uint gpu_loops = data.gpu_loops;
2530
2531 // init speed timer
2532
2533 uint speed_pos = device_param->speed_pos;
2534
2535 #ifdef _POSIX
2536 if (device_param->timer_speed.tv_sec == 0)
2537 {
2538 hc_timer_set (&device_param->timer_speed);
2539 }
2540 #endif
2541
2542 #ifdef _WIN
2543 if (device_param->timer_speed.QuadPart == 0)
2544 {
2545 hc_timer_set (&device_param->timer_speed);
2546 }
2547 #endif
2548
2549 // find higest password length, this is for optimization stuff
2550
2551 uint highest_pw_len = 0;
2552
2553 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2554 {
2555 }
2556 else if (data.attack_kern == ATTACK_KERN_COMBI)
2557 {
2558 }
2559 else if (data.attack_kern == ATTACK_KERN_BF)
2560 {
2561 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
2562 + device_param->kernel_params_mp_l_buf32[5];
2563 }
2564
2565 // bitslice optimization stuff
2566
2567 if (data.attack_mode == ATTACK_MODE_BF)
2568 {
2569 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2570 {
2571 run_kernel_tb (device_param, pws_cnt);
2572 }
2573 }
2574
2575 // iteration type
2576
2577 uint innerloop_step = 0;
2578 uint innerloop_cnt = 0;
2579
2580 if (data.attack_exec == ATTACK_EXEC_ON_GPU) innerloop_step = gpu_loops;
2581 else innerloop_step = 1;
2582
2583 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.gpu_rules_cnt;
2584 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
2585 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
2586
2587 // loop start: most outer loop = salt iteration, then innerloops (if multi)
2588
2589 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2590 {
2591 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2592
2593 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2594
2595 if (data.devices_status == STATUS_CRACKED) break;
2596 if (data.devices_status == STATUS_ABORTED) break;
2597 if (data.devices_status == STATUS_QUIT) break;
2598 if (data.devices_status == STATUS_BYPASS) break;
2599
2600 if (data.salts_shown[salt_pos] == 1) continue;
2601
2602 salt_t *salt_buf = &data.salts_buf[salt_pos];
2603
2604 device_param->kernel_params_buf32[24] = salt_pos;
2605 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
2606 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
2607
2608 FILE *combs_fp = device_param->combs_fp;
2609
2610 if (data.attack_mode == ATTACK_MODE_COMBI)
2611 {
2612 rewind (combs_fp);
2613 }
2614
2615 // innerloops
2616
2617 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
2618 {
2619 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2620
2621 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2622
2623 if (data.devices_status == STATUS_CRACKED) break;
2624 if (data.devices_status == STATUS_ABORTED) break;
2625 if (data.devices_status == STATUS_QUIT) break;
2626 if (data.devices_status == STATUS_BYPASS) break;
2627
2628 uint innerloop_left = innerloop_cnt - innerloop_pos;
2629
2630 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
2631
2632 device_param->innerloop_pos = innerloop_pos;
2633 device_param->innerloop_left = innerloop_left;
2634
2635 device_param->kernel_params_buf32[27] = innerloop_left;
2636
2637 if (innerloop_left == 0) continue;
2638
2639 // initialize amplifiers
2640
2641 if (data.attack_mode == ATTACK_MODE_COMBI)
2642 {
2643 char line_buf[BUFSIZ];
2644
2645 uint i = 0;
2646
2647 while (i < innerloop_left)
2648 {
2649 if (feof (combs_fp)) break;
2650
2651 int line_len = fgetl (combs_fp, line_buf);
2652
2653 if (line_len >= PW_MAX1) continue;
2654
2655 line_len = convert_from_hex (line_buf, line_len);
2656
2657 char *line_buf_new = line_buf;
2658
2659 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
2660 {
2661 char rule_buf_out[BLOCK_SIZE];
2662
2663 memset (rule_buf_out, 0, sizeof (rule_buf_out));
2664
2665 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
2666
2667 if (rule_len_out < 0)
2668 {
2669 data.words_progress_rejected[salt_pos] += pw_cnt;
2670
2671 continue;
2672 }
2673
2674 line_len = rule_len_out;
2675
2676 line_buf_new = rule_buf_out;
2677 }
2678
2679 line_len = MIN (line_len, PW_DICTMAX);
2680
2681 char *ptr = (char *) device_param->combs_buf[i].i;
2682
2683 memcpy (ptr, line_buf_new, line_len);
2684
2685 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
2686
2687 if (data.opts_type & OPTS_TYPE_PT_UPPER)
2688 {
2689 uppercase (ptr, line_len);
2690 }
2691
2692 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2693 {
2694 if (data.opts_type & OPTS_TYPE_PT_ADD80)
2695 {
2696 ptr[line_len] = 0x80;
2697 }
2698
2699 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2700 {
2701 ptr[line_len] = 0x01;
2702 }
2703 }
2704
2705 device_param->combs_buf[i].pw_len = line_len;
2706
2707 i++;
2708 }
2709
2710 for (uint j = i; j < innerloop_left; j++)
2711 {
2712 device_param->combs_buf[j].i[0] = 0;
2713 device_param->combs_buf[j].i[1] = 0;
2714 device_param->combs_buf[j].i[2] = 0;
2715 device_param->combs_buf[j].i[3] = 0;
2716 device_param->combs_buf[j].i[4] = 0;
2717 device_param->combs_buf[j].i[5] = 0;
2718 device_param->combs_buf[j].i[6] = 0;
2719 device_param->combs_buf[j].i[7] = 0;
2720
2721 device_param->combs_buf[j].pw_len = 0;
2722 }
2723
2724 innerloop_left = i;
2725 }
2726 else if (data.attack_mode == ATTACK_MODE_BF)
2727 {
2728 uint64_t off = innerloop_pos;
2729
2730 device_param->kernel_params_mp_r_buf64[3] = off;
2731
2732 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
2733 }
2734 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2735 {
2736 uint64_t off = innerloop_pos;
2737
2738 device_param->kernel_params_mp_buf64[3] = off;
2739
2740 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2741 }
2742 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2743 {
2744 uint64_t off = innerloop_pos;
2745
2746 device_param->kernel_params_mp_buf64[3] = off;
2747
2748 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2749 }
2750
2751 // copy amplifiers
2752
2753 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2754 {
2755 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);
2756 }
2757 else if (data.attack_mode == ATTACK_MODE_COMBI)
2758 {
2759 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);
2760 }
2761 else if (data.attack_mode == ATTACK_MODE_BF)
2762 {
2763 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);
2764 }
2765 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2766 {
2767 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);
2768 }
2769 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2770 {
2771 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);
2772 }
2773
2774 if (data.attack_exec == ATTACK_EXEC_ON_GPU)
2775 {
2776 if (data.attack_mode == ATTACK_MODE_BF)
2777 {
2778 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2779 {
2780 const uint size_tm = 32 * sizeof (bs_word_t);
2781
2782 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2783
2784 run_kernel_tm (device_param);
2785
2786 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2787 }
2788 }
2789
2790 if (highest_pw_len < 16)
2791 {
2792 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2793 }
2794 else if (highest_pw_len < 32)
2795 {
2796 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2797 }
2798 else
2799 {
2800 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2801 }
2802 }
2803 else
2804 {
2805 run_kernel_amp (device_param, pws_cnt);
2806
2807 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2808
2809 if (data.opts_type & OPTS_TYPE_HOOK12)
2810 {
2811 run_kernel (KERN_RUN_12, device_param, pws_cnt);
2812 }
2813
2814 uint iter = salt_buf->salt_iter;
2815
2816 for (uint loop_pos = 0; loop_pos < iter; loop_pos += gpu_loops)
2817 {
2818 uint loop_left = iter - loop_pos;
2819
2820 loop_left = MIN (loop_left, gpu_loops);
2821
2822 device_param->kernel_params_buf32[25] = loop_pos;
2823 device_param->kernel_params_buf32[26] = loop_left;
2824
2825 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2826
2827 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2828
2829 if (data.devices_status == STATUS_CRACKED) break;
2830 if (data.devices_status == STATUS_ABORTED) break;
2831 if (data.devices_status == STATUS_QUIT) break;
2832 }
2833
2834 if (data.opts_type & OPTS_TYPE_HOOK23)
2835 {
2836 run_kernel (KERN_RUN_23, device_param, pws_cnt);
2837
2838 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2839
2840 // do something with data
2841
2842 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2843 }
2844
2845 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2846 }
2847
2848 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2849
2850 if (data.devices_status == STATUS_CRACKED) break;
2851 if (data.devices_status == STATUS_ABORTED) break;
2852 if (data.devices_status == STATUS_QUIT) break;
2853
2854 /**
2855 * result
2856 */
2857
2858 hc_thread_mutex_lock (mux_display);
2859
2860 check_cracked (device_param, salt_pos);
2861
2862 hc_thread_mutex_unlock (mux_display);
2863
2864 /**
2865 * progress
2866 */
2867
2868 uint64_t perf_sum_all = (uint64_t) pw_cnt * (uint64_t) innerloop_left;
2869
2870 hc_thread_mutex_lock (mux_counter);
2871
2872 data.words_progress_done[salt_pos] += perf_sum_all;
2873
2874 hc_thread_mutex_unlock (mux_counter);
2875
2876 /**
2877 * speed
2878 */
2879
2880 float speed_ms;
2881
2882 hc_timer_get (device_param->timer_speed, speed_ms);
2883
2884 hc_timer_set (&device_param->timer_speed);
2885
2886 hc_thread_mutex_lock (mux_display);
2887
2888 device_param->speed_cnt[speed_pos] = perf_sum_all;
2889
2890 device_param->speed_ms[speed_pos] = speed_ms;
2891
2892 device_param->speed_rec[speed_pos] = device_param->timer_speed;
2893
2894 hc_thread_mutex_unlock (mux_display);
2895
2896 speed_pos++;
2897
2898 if (speed_pos == SPEED_CACHE)
2899 {
2900 speed_pos = 0;
2901 }
2902 }
2903 }
2904
2905 device_param->speed_pos = speed_pos;
2906 }
2907
2908 static void load_segment (wl_data_t *wl_data, FILE *fd)
2909 {
2910 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
2911
2912 wl_data->pos = 0;
2913
2914 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
2915
2916 wl_data->buf[wl_data->cnt] = 0;
2917
2918 if (wl_data->cnt == 0) return;
2919
2920 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
2921
2922 while (!feof (fd))
2923 {
2924 if (wl_data->cnt == wl_data->avail)
2925 {
2926 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
2927
2928 wl_data->avail += wl_data->incr;
2929 }
2930
2931 const int c = fgetc (fd);
2932
2933 if (c == EOF) break;
2934
2935 wl_data->buf[wl_data->cnt] = (char) c;
2936
2937 wl_data->cnt++;
2938
2939 if (c == '\n') break;
2940 }
2941
2942 // ensure stream ends with a newline
2943
2944 if (wl_data->buf[wl_data->cnt - 1] != '\n')
2945 {
2946 wl_data->cnt++;
2947
2948 wl_data->buf[wl_data->cnt - 1] = '\n';
2949 }
2950
2951 return;
2952 }
2953
2954 static void get_next_word_lm (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
2955 {
2956 char *ptr = buf;
2957
2958 for (uint32_t i = 0; i < sz; i++, ptr++)
2959 {
2960 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
2961
2962 if (i == 7)
2963 {
2964 *off = i;
2965 *len = i;
2966
2967 return;
2968 }
2969
2970 if (*ptr != '\n') continue;
2971
2972 *off = i + 1;
2973
2974 if ((i > 0) && (buf[i - 1] == '\r')) i--;
2975
2976 *len = i;
2977
2978 return;
2979 }
2980
2981 *off = sz;
2982 *len = sz;
2983 }
2984
2985 static void get_next_word_uc (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
2986 {
2987 char *ptr = buf;
2988
2989 for (uint32_t i = 0; i < sz; i++, ptr++)
2990 {
2991 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
2992
2993 if (*ptr != '\n') continue;
2994
2995 *off = i + 1;
2996
2997 if ((i > 0) && (buf[i - 1] == '\r')) i--;
2998
2999 *len = i;
3000
3001 return;
3002 }
3003
3004 *off = sz;
3005 *len = sz;
3006 }
3007
3008 static void get_next_word_std (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
3009 {
3010 char *ptr = buf;
3011
3012 for (uint32_t i = 0; i < sz; i++, ptr++)
3013 {
3014 if (*ptr != '\n') continue;
3015
3016 *off = i + 1;
3017
3018 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3019
3020 *len = i;
3021
3022 return;
3023 }
3024
3025 *off = sz;
3026 *len = sz;
3027 }
3028
3029 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3030 {
3031 while (wl_data->pos < wl_data->cnt)
3032 {
3033 uint off;
3034 uint len;
3035
3036 char *ptr = wl_data->buf + wl_data->pos;
3037
3038 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3039
3040 wl_data->pos += off;
3041
3042 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3043 {
3044 char rule_buf_out[BLOCK_SIZE];
3045
3046 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3047
3048 int rule_len_out = -1;
3049
3050 if (len < BLOCK_SIZE)
3051 {
3052 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3053 }
3054
3055 if (rule_len_out < 0)
3056 {
3057 continue;
3058 }
3059
3060 if (rule_len_out > PW_MAX)
3061 {
3062 continue;
3063 }
3064 }
3065 else
3066 {
3067 if (len > PW_MAX)
3068 {
3069 continue;
3070 }
3071 }
3072
3073 *out_buf = ptr;
3074 *out_len = len;
3075
3076 return;
3077 }
3078
3079 if (feof (fd))
3080 {
3081 fprintf (stderr, "bug!!\n");
3082
3083 return;
3084 }
3085
3086 load_segment (wl_data, fd);
3087
3088 get_next_word (wl_data, fd, out_buf, out_len);
3089 }
3090
3091 #ifdef _POSIX
3092 static uint64_t count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3093 #endif
3094
3095 #ifdef _WIN
3096 static uint64_t count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3097 #endif
3098 {
3099 hc_signal (NULL);
3100
3101 dictstat_t d;
3102
3103 d.cnt = 0;
3104
3105 #ifdef _POSIX
3106 fstat (fileno (fd), &d.stat);
3107 #endif
3108
3109 #ifdef _WIN
3110 _fstat64 (fileno (fd), &d.stat);
3111 #endif
3112
3113 d.stat.st_mode = 0;
3114 d.stat.st_nlink = 0;
3115 d.stat.st_uid = 0;
3116 d.stat.st_gid = 0;
3117 d.stat.st_rdev = 0;
3118 d.stat.st_atime = 0;
3119
3120 #ifdef _POSIX
3121 d.stat.st_blksize = 0;
3122 d.stat.st_blocks = 0;
3123 #endif
3124
3125 if (d.stat.st_size == 0) return 0;
3126
3127 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3128
3129 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3130 {
3131 if (d_cache)
3132 {
3133 uint64_t cnt = d_cache->cnt;
3134
3135 uint64_t keyspace = cnt;
3136
3137 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3138 {
3139 keyspace *= data.gpu_rules_cnt;
3140 }
3141 else if (data.attack_kern == ATTACK_KERN_COMBI)
3142 {
3143 keyspace *= data.combs_cnt;
3144 }
3145
3146 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);
3147 if (data.quiet == 0) log_info ("");
3148
3149 hc_signal (sigHandler_default);
3150
3151 return (keyspace);
3152 }
3153 }
3154
3155 time_t now = 0;
3156 time_t prev = 0;
3157
3158 uint64_t comp = 0;
3159 uint64_t cnt = 0;
3160 uint64_t cnt2 = 0;
3161
3162 while (!feof (fd))
3163 {
3164 load_segment (wl_data, fd);
3165
3166 comp += wl_data->cnt;
3167
3168 uint32_t i = 0;
3169
3170 while (i < wl_data->cnt)
3171 {
3172 uint32_t len;
3173 uint32_t off;
3174
3175 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3176
3177 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3178 {
3179 char rule_buf_out[BLOCK_SIZE];
3180
3181 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3182
3183 int rule_len_out = -1;
3184
3185 if (len < BLOCK_SIZE)
3186 {
3187 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3188 }
3189
3190 if (rule_len_out < 0)
3191 {
3192 len = PW_MAX1;
3193 }
3194 else
3195 {
3196 len = rule_len_out;
3197 }
3198 }
3199
3200 if (len < PW_MAX1)
3201 {
3202 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3203 {
3204 cnt += data.gpu_rules_cnt;
3205 }
3206 else if (data.attack_kern == ATTACK_KERN_COMBI)
3207 {
3208 cnt += data.combs_cnt;
3209 }
3210
3211 d.cnt++;
3212 }
3213
3214 i += off;
3215
3216 cnt2++;
3217 }
3218
3219 time (&now);
3220
3221 if ((now - prev) == 0) continue;
3222
3223 float percent = (float) comp / (float) d.stat.st_size;
3224
3225 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);
3226
3227 time (&prev);
3228 }
3229
3230 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);
3231 if (data.quiet == 0) log_info ("");
3232
3233 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3234
3235 hc_signal (sigHandler_default);
3236
3237 return (cnt);
3238 }
3239
3240 static void pw_transpose_to_hi1 (const pw_t *p1, pw_t *p2)
3241 {
3242 memcpy (p2->hi1, p1->hi1, 64 * sizeof (uint));
3243 }
3244
3245 static uint pw_add_to_hc1 (hc_device_param_t *device_param, const uint8_t *pw_buf, const uint pw_len)
3246 {
3247 if (data.devices_status == STATUS_BYPASS) return 0;
3248
3249 pw_cache_t *pw_cache = device_param->pw_caches + pw_len;
3250
3251 uint cache_cnt = pw_cache->cnt;
3252
3253 uint8_t *pw_hc1 = pw_cache->pw_buf.hc1[cache_cnt];
3254
3255 memcpy (pw_hc1, pw_buf, pw_len);
3256
3257 memset (pw_hc1 + pw_len, 0, 256 - pw_len);
3258
3259 uint pws_cnt = device_param->pws_cnt;
3260
3261 cache_cnt++;
3262
3263 pw_t *pw = device_param->pws_buf + pws_cnt;
3264
3265 device_param->pw_transpose (&pw_cache->pw_buf, pw);
3266
3267 pw->pw_len = pw_len;
3268
3269 pws_cnt++;
3270
3271 device_param->pws_cnt = pws_cnt;
3272 device_param->pw_cnt = pws_cnt * 1;
3273
3274 cache_cnt = 0;
3275
3276 pw_cache->cnt = cache_cnt;
3277
3278 return pws_cnt;
3279 }
3280
3281 static void *thread_monitor (void *p)
3282 {
3283 uint runtime_check = 0;
3284 uint remove_check = 0;
3285 uint status_check = 0;
3286 uint hwmon_check = 0;
3287 uint restore_check = 0;
3288
3289 uint restore_left = data.restore_timer;
3290 uint remove_left = data.remove_timer;
3291 uint status_left = data.status_timer;
3292
3293 // these variables are mainly used for fan control (AMD only)
3294
3295 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3296
3297 // temperature controller "loopback" values
3298
3299 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3300 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3301
3302 int temp_threshold = 1; // degrees celcius
3303
3304 int fan_speed_min = 15; // in percentage
3305 int fan_speed_max = 100;
3306
3307 time_t last_temp_check_time;
3308
3309 uint sleep_time = 1;
3310
3311 if (data.runtime)
3312 {
3313 runtime_check = 1;
3314 }
3315
3316 if (data.restore_timer)
3317 {
3318 restore_check = 1;
3319 }
3320
3321 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3322 {
3323 remove_check = 1;
3324 }
3325
3326 if (data.status == 1)
3327 {
3328 status_check = 1;
3329 }
3330
3331 if (data.gpu_temp_disable == 0)
3332 {
3333 time (&last_temp_check_time);
3334
3335 hwmon_check = 1;
3336 }
3337
3338 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (hwmon_check == 0) && (restore_check == 0))
3339 {
3340 return (p);
3341 }
3342
3343 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3344 {
3345 hc_sleep (sleep_time);
3346
3347 if (data.devices_status != STATUS_RUNNING) continue;
3348
3349 if (hwmon_check == 1)
3350 {
3351 hc_thread_mutex_lock (mux_adl);
3352
3353 time_t temp_check_time;
3354
3355 time (&temp_check_time);
3356
3357 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3358
3359 if (Ta == 0) Ta = 1;
3360
3361 for (uint i = 0; i < data.devices_cnt; i++)
3362 {
3363 const int temperature = hm_get_temperature_with_device_id (i);
3364
3365 if (temperature > (int) data.gpu_temp_abort)
3366 {
3367 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", i + 1);
3368
3369 if (data.devices_status != STATUS_QUIT) myabort ();
3370
3371 break;
3372 }
3373
3374 const int gpu_temp_retain = data.gpu_temp_retain;
3375
3376 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3377 {
3378 if (data.hm_device[i].fan_supported == 1)
3379 {
3380 int temp_cur = temperature;
3381
3382 int temp_diff_new = gpu_temp_retain - temp_cur;
3383
3384 temp_diff_sum[i] = temp_diff_sum[i] + temp_diff_new;
3385
3386 // calculate Ta value (time difference in seconds between the last check and this check)
3387
3388 last_temp_check_time = temp_check_time;
3389
3390 float Kp = 1.8;
3391 float Ki = 0.005;
3392 float Kd = 6;
3393
3394 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3395
3396 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);
3397
3398 if (abs (fan_diff_required) >= temp_threshold)
3399 {
3400 const int fan_speed_cur = hm_get_fanspeed_with_device_id (i);
3401
3402 int fan_speed_level = fan_speed_cur;
3403
3404 if (fan_speed_chgd[i] == 0) fan_speed_level = temp_cur;
3405
3406 int fan_speed_new = fan_speed_level - fan_diff_required;
3407
3408 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3409 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3410
3411 if (fan_speed_new != fan_speed_cur)
3412 {
3413 int freely_change_fan_speed = (fan_speed_chgd[i] == 1);
3414 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3415
3416 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3417 {
3418 hm_set_fanspeed_with_device_id_amd (i, fan_speed_new);
3419
3420 fan_speed_chgd[i] = 1;
3421 }
3422
3423 temp_diff_old[i] = temp_diff_new;
3424 }
3425 }
3426 }
3427 }
3428 }
3429
3430 hc_thread_mutex_unlock (mux_adl);
3431 }
3432
3433 if (restore_check == 1)
3434 {
3435 restore_left--;
3436
3437 if (restore_left == 0)
3438 {
3439 if (data.restore_disable == 0) cycle_restore ();
3440
3441 restore_left = data.restore_timer;
3442 }
3443 }
3444
3445 if ((runtime_check == 1) && (data.runtime_start > 0))
3446 {
3447 time_t runtime_cur;
3448
3449 time (&runtime_cur);
3450
3451 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3452
3453 if (runtime_left <= 0)
3454 {
3455 if (data.benchmark == 0)
3456 {
3457 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3458 }
3459
3460 if (data.devices_status != STATUS_QUIT) myabort ();
3461 }
3462 }
3463
3464 if (remove_check == 1)
3465 {
3466 remove_left--;
3467
3468 if (remove_left == 0)
3469 {
3470 if (data.digests_saved != data.digests_done)
3471 {
3472 data.digests_saved = data.digests_done;
3473
3474 save_hash ();
3475 }
3476
3477 remove_left = data.remove_timer;
3478 }
3479 }
3480
3481 if (status_check == 1)
3482 {
3483 status_left--;
3484
3485 if (status_left == 0)
3486 {
3487 hc_thread_mutex_lock (mux_display);
3488
3489 if (data.quiet == 0) clear_prompt ();
3490
3491 if (data.quiet == 0) log_info ("");
3492
3493 status_display ();
3494
3495 if (data.quiet == 0) log_info ("");
3496
3497 hc_thread_mutex_unlock (mux_display);
3498
3499 status_left = data.status_timer;
3500 }
3501 }
3502 }
3503
3504 myfree (fan_speed_chgd);
3505
3506 myfree (temp_diff_old);
3507 myfree (temp_diff_sum);
3508
3509 p = NULL;
3510
3511 return (p);
3512 }
3513
3514 static void *thread_outfile_remove (void *p)
3515 {
3516 // some hash-dependent constants
3517 char *outfile_dir = data.outfile_check_directory;
3518 uint dgst_size = data.dgst_size;
3519 uint isSalted = data.isSalted;
3520 uint esalt_size = data.esalt_size;
3521 uint hash_mode = data.hash_mode;
3522
3523 uint outfile_check_timer = data.outfile_check_timer;
3524
3525 char separator = data.separator;
3526
3527 // some hash-dependent functions
3528 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3529 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3530
3531 // buffers
3532 hash_t hash_buf;
3533
3534 memset (&hash_buf, 0, sizeof (hash_buf));
3535
3536 hash_buf.digest = mymalloc (dgst_size);
3537
3538 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3539
3540 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3541
3542 uint digest_buf[64];
3543
3544 outfile_data_t *out_info = NULL;
3545
3546 char **out_files = NULL;
3547
3548 time_t folder_mtime = 0;
3549
3550 int out_cnt = 0;
3551
3552 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3553
3554 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3555 {
3556 hc_sleep (1);
3557
3558 if (data.devices_status != STATUS_RUNNING) continue;
3559
3560 check_left--;
3561
3562 if (check_left == 0)
3563 {
3564 struct stat outfile_check_stat;
3565
3566 if (stat (outfile_dir, &outfile_check_stat) == 0)
3567 {
3568 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3569
3570 if (is_dir == 1)
3571 {
3572 if (outfile_check_stat.st_mtime > folder_mtime)
3573 {
3574 char **out_files_new = scan_directory (outfile_dir);
3575
3576 int out_cnt_new = count_dictionaries (out_files_new);
3577
3578 outfile_data_t *out_info_new = NULL;
3579
3580 if (out_cnt_new > 0)
3581 {
3582 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3583
3584 for (int i = 0; i < out_cnt_new; i++)
3585 {
3586 out_info_new[i].file_name = out_files_new[i];
3587
3588 // check if there are files that we have seen/checked before (and not changed)
3589
3590 for (int j = 0; j < out_cnt; j++)
3591 {
3592 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
3593 {
3594 struct stat outfile_stat;
3595
3596 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
3597 {
3598 if (outfile_stat.st_ctime == out_info[j].ctime)
3599 {
3600 out_info_new[i].ctime = out_info[j].ctime;
3601 out_info_new[i].seek = out_info[j].seek;
3602 }
3603 }
3604 }
3605 }
3606 }
3607 }
3608
3609 local_free (out_info);
3610 local_free (out_files);
3611
3612 out_files = out_files_new;
3613 out_cnt = out_cnt_new;
3614 out_info = out_info_new;
3615
3616 folder_mtime = outfile_check_stat.st_mtime;
3617 }
3618
3619 for (int j = 0; j < out_cnt; j++)
3620 {
3621 FILE *fp = fopen (out_info[j].file_name, "rb");
3622
3623 if (fp != NULL)
3624 {
3625 //hc_thread_mutex_lock (mux_display);
3626
3627 #ifdef _POSIX
3628 struct stat outfile_stat;
3629
3630 fstat (fileno (fp), &outfile_stat);
3631 #endif
3632
3633 #ifdef _WIN
3634 struct stat64 outfile_stat;
3635
3636 _fstat64 (fileno (fp), &outfile_stat);
3637 #endif
3638
3639 if (outfile_stat.st_ctime > out_info[j].ctime)
3640 {
3641 out_info[j].ctime = outfile_stat.st_ctime;
3642 out_info[j].seek = 0;
3643 }
3644
3645 fseek (fp, out_info[j].seek, SEEK_SET);
3646
3647 while (!feof (fp))
3648 {
3649 char line_buf[BUFSIZ];
3650
3651 memset (line_buf, 0, BUFSIZ);
3652
3653 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
3654
3655 if (ptr == NULL) break;
3656
3657 int line_len = strlen (line_buf);
3658
3659 if (line_len <= 0) continue;
3660
3661 int iter = MAX_CUT_TRIES;
3662
3663 for (uint i = line_len - 1; i && iter; i--, line_len--)
3664 {
3665 if (line_buf[i] != separator) continue;
3666
3667 int parser_status = PARSER_OK;
3668
3669 if ((hash_mode != 2500) && (hash_mode != 6800))
3670 {
3671 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
3672 }
3673
3674 uint found = 0;
3675
3676 if (parser_status == PARSER_OK)
3677 {
3678 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
3679 {
3680 if (data.salts_shown[salt_pos] == 1) continue;
3681
3682 salt_t *salt_buf = &data.salts_buf[salt_pos];
3683
3684 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
3685 {
3686 uint idx = salt_buf->digests_offset + digest_pos;
3687
3688 if (data.digests_shown[idx] == 1) continue;
3689
3690 uint cracked = 0;
3691
3692 if (hash_mode == 6800)
3693 {
3694 if (i == salt_buf->salt_len)
3695 {
3696 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3697 }
3698 }
3699 else if (hash_mode == 2500)
3700 {
3701 // BSSID : MAC1 : MAC2 (:plain)
3702 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
3703 {
3704 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3705
3706 if (!cracked) continue;
3707
3708 // now compare MAC1 and MAC2 too, since we have this additional info
3709 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
3710 char *mac2_pos = mac1_pos + 12 + 1;
3711
3712 wpa_t *wpas = (wpa_t *) data.esalts_buf;
3713 wpa_t *wpa = &wpas[salt_pos];
3714
3715 uint pke[25];
3716
3717 char *pke_ptr = (char *) pke;
3718
3719 for (uint i = 0; i < 25; i++)
3720 {
3721 pke[i] = byte_swap_32 (wpa->pke[i]);
3722 }
3723
3724 unsigned char mac1[6];
3725 unsigned char mac2[6];
3726
3727 memcpy (mac1, pke_ptr + 23, 6);
3728 memcpy (mac2, pke_ptr + 29, 6);
3729
3730 // compare hex string(s) vs binary MAC address(es)
3731
3732 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3733 {
3734 if (mac1[i] != (unsigned char) hex_to_char (&mac1_pos[j]))
3735 {
3736 cracked = 0;
3737 break;
3738 }
3739 }
3740
3741 // early skip ;)
3742 if (!cracked) continue;
3743
3744 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3745 {
3746 if (mac2[i] != (unsigned char) hex_to_char (&mac2_pos[j]))
3747 {
3748 cracked = 0;
3749 break;
3750 }
3751 }
3752 }
3753 }
3754 else
3755 {
3756 char *digests_buf_ptr = (char *) data.digests_buf;
3757
3758 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
3759
3760 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
3761 }
3762
3763 if (cracked == 1)
3764 {
3765 found = 1;
3766
3767 data.digests_shown[idx] = 1;
3768
3769 data.digests_done++;
3770
3771 salt_buf->digests_done++;
3772
3773 if (salt_buf->digests_done == salt_buf->digests_cnt)
3774 {
3775 data.salts_shown[salt_pos] = 1;
3776
3777 data.salts_done++;
3778
3779 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
3780 }
3781 }
3782 }
3783
3784 if (data.devices_status == STATUS_CRACKED) break;
3785 }
3786 }
3787
3788 if (found) break;
3789
3790 if (data.devices_status == STATUS_CRACKED) break;
3791
3792 iter--;
3793 }
3794
3795 if (data.devices_status == STATUS_CRACKED) break;
3796 }
3797
3798 out_info[j].seek = ftell (fp);
3799
3800 //hc_thread_mutex_unlock (mux_display);
3801
3802 fclose (fp);
3803 }
3804 }
3805 }
3806 }
3807
3808 check_left = outfile_check_timer;
3809 }
3810 }
3811
3812 if (esalt_size) local_free (hash_buf.esalt);
3813
3814 if (isSalted) local_free (hash_buf.salt);
3815
3816 local_free (hash_buf.digest);
3817
3818 local_free (out_info);
3819
3820 local_free (out_files);
3821
3822 p = NULL;
3823
3824 return (p);
3825 }
3826
3827 static uint get_work (hc_device_param_t *device_param, const uint64_t max)
3828 {
3829 hc_thread_mutex_lock (mux_dispatcher);
3830
3831 const uint64_t words_cur = data.words_cur;
3832 const uint64_t words_base = (data.limit == 0) ? data.words_base : data.limit;
3833
3834 device_param->words_off = words_cur;
3835
3836 const uint64_t words_left = words_base - words_cur;
3837
3838 if (data.gpu_blocks_all > words_left)
3839 {
3840 if (data.gpu_blocks_div == 0)
3841 {
3842 data.gpu_blocks_div = find_gpu_blocks_div (words_left, data.gpu_blocks_all);
3843 }
3844 }
3845
3846 if (data.gpu_blocks_div)
3847 {
3848 if (device_param->gpu_blocks == device_param->gpu_blocks_user)
3849 {
3850 const uint32_t gpu_blocks_new = (float) device_param->gpu_blocks * data.gpu_blocks_div;
3851 const uint32_t gpu_power_new = gpu_blocks_new;
3852
3853 if (gpu_blocks_new < device_param->gpu_blocks)
3854 {
3855 device_param->gpu_blocks = gpu_blocks_new;
3856 device_param->gpu_power = gpu_power_new;
3857 }
3858 }
3859 }
3860
3861 const uint gpu_blocks = device_param->gpu_blocks;
3862
3863 uint work = MIN (words_left, gpu_blocks);
3864
3865 work = MIN (work, max);
3866
3867 data.words_cur += work;
3868
3869 hc_thread_mutex_unlock (mux_dispatcher);
3870
3871 return work;
3872 }
3873
3874 static void *thread_calc_stdin (void *p)
3875 {
3876 hc_device_param_t *device_param = (hc_device_param_t *) p;
3877
3878 const uint attack_kern = data.attack_kern;
3879
3880 const uint gpu_blocks = device_param->gpu_blocks;
3881
3882 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3883 {
3884 hc_thread_mutex_lock (mux_dispatcher);
3885
3886 if (feof (stdin) != 0)
3887 {
3888 hc_thread_mutex_unlock (mux_dispatcher);
3889
3890 break;
3891 }
3892
3893 uint words_cur = 0;
3894
3895 while (words_cur < gpu_blocks)
3896 {
3897 char buf[BUFSIZ];
3898
3899 char *line_buf = fgets (buf, sizeof (buf), stdin);
3900
3901 if (line_buf == NULL) break;
3902
3903 uint line_len = in_superchop (line_buf);
3904
3905 line_len = convert_from_hex (line_buf, line_len);
3906
3907 // post-process rule engine
3908
3909 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3910 {
3911 char rule_buf_out[BLOCK_SIZE];
3912
3913 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3914
3915 int rule_len_out = -1;
3916
3917 if (line_len < BLOCK_SIZE)
3918 {
3919 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
3920 }
3921
3922 if (rule_len_out < 0) continue;
3923
3924 line_buf = rule_buf_out;
3925 line_len = rule_len_out;
3926 }
3927
3928 if (line_len > PW_MAX)
3929 {
3930 continue;
3931 }
3932
3933 if (attack_kern == ATTACK_KERN_STRAIGHT)
3934 {
3935 if ((line_len < data.pw_min) || (line_len > data.pw_max))
3936 {
3937 hc_thread_mutex_lock (mux_counter);
3938
3939 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3940 {
3941 data.words_progress_rejected[salt_pos] += data.gpu_rules_cnt;
3942 }
3943
3944 hc_thread_mutex_unlock (mux_counter);
3945
3946 continue;
3947 }
3948 }
3949 else if (attack_kern == ATTACK_KERN_COMBI)
3950 {
3951 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
3952 // since we still need to combine the plains
3953
3954 if (line_len > data.pw_max)
3955 {
3956 hc_thread_mutex_lock (mux_counter);
3957
3958 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3959 {
3960 data.words_progress_rejected[salt_pos] += data.combs_cnt;
3961 }
3962
3963 hc_thread_mutex_unlock (mux_counter);
3964
3965 continue;
3966 }
3967 }
3968
3969 device_param->pw_add (device_param, (uint8_t *) line_buf, line_len);
3970
3971 words_cur++;
3972
3973 if (data.devices_status == STATUS_CRACKED) break;
3974 if (data.devices_status == STATUS_ABORTED) break;
3975 if (data.devices_status == STATUS_QUIT) break;
3976 if (data.devices_status == STATUS_BYPASS) break;
3977 }
3978
3979 hc_thread_mutex_unlock (mux_dispatcher);
3980
3981 if (data.devices_status == STATUS_CRACKED) break;
3982 if (data.devices_status == STATUS_ABORTED) break;
3983 if (data.devices_status == STATUS_QUIT) break;
3984 if (data.devices_status == STATUS_BYPASS) break;
3985
3986 // we need 2 flushing because we have two independant caches and it can occur
3987 // that one buffer is already at threshold plus for that length also exists
3988 // more data in the 2nd buffer so it would overflow
3989
3990 // flush session 1
3991
3992 {
3993 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
3994 {
3995 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
3996
3997 const uint pw_cache_cnt = pw_cache->cnt;
3998
3999 if (pw_cache_cnt == 0) continue;
4000
4001 pw_cache->cnt = 0;
4002
4003 uint pws_cnt = device_param->pws_cnt;
4004
4005 pw_t *pw = device_param->pws_buf + pws_cnt;
4006
4007 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4008
4009 pw->pw_len = pw_len;
4010
4011 uint pw_cnt = device_param->pw_cnt;
4012
4013 pw_cnt += pw_cache_cnt;
4014
4015 device_param->pw_cnt = pw_cnt;
4016
4017 pws_cnt++;
4018
4019 device_param->pws_cnt = pws_cnt;
4020
4021 if (pws_cnt == device_param->gpu_power_user) break;
4022 }
4023
4024 const uint pw_cnt = device_param->pw_cnt;
4025 const uint pws_cnt = device_param->pws_cnt;
4026
4027 if (pws_cnt)
4028 {
4029 run_copy (device_param, pws_cnt);
4030
4031 run_cracker (device_param, pw_cnt, pws_cnt);
4032
4033 device_param->pw_cnt = 0;
4034 device_param->pws_cnt = 0;
4035 }
4036 }
4037
4038 // flush session 2
4039
4040 {
4041 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4042 {
4043 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4044
4045 const uint pw_cache_cnt = pw_cache->cnt;
4046
4047 if (pw_cache_cnt == 0) continue;
4048
4049 pw_cache->cnt = 0;
4050
4051 uint pws_cnt = device_param->pws_cnt;
4052
4053 pw_t *pw = device_param->pws_buf + pws_cnt;
4054
4055 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4056
4057 pw->pw_len = pw_len;
4058
4059 uint pw_cnt = device_param->pw_cnt;
4060
4061 pw_cnt += pw_cache_cnt;
4062
4063 device_param->pw_cnt = pw_cnt;
4064
4065 pws_cnt++;
4066
4067 device_param->pws_cnt = pws_cnt;
4068 }
4069
4070 const uint pw_cnt = device_param->pw_cnt;
4071 const uint pws_cnt = device_param->pws_cnt;
4072
4073 if (pws_cnt)
4074 {
4075 run_copy (device_param, pws_cnt);
4076
4077 run_cracker (device_param, pw_cnt, pws_cnt);
4078
4079 device_param->pw_cnt = 0;
4080 device_param->pws_cnt = 0;
4081 }
4082 }
4083 }
4084
4085 return NULL;
4086 }
4087
4088 static void *thread_calc (void *p)
4089 {
4090 hc_device_param_t *device_param = (hc_device_param_t *) p;
4091
4092 const uint attack_mode = data.attack_mode;
4093 const uint attack_kern = data.attack_kern;
4094
4095 if (attack_mode == ATTACK_MODE_BF)
4096 {
4097 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4098 {
4099 const uint work = get_work (device_param, -1);
4100
4101 if (work == 0) break;
4102
4103 const uint64_t words_off = device_param->words_off;
4104 const uint64_t words_fin = words_off + work;
4105
4106 const uint pw_cnt = work;
4107 const uint pws_cnt = work;
4108
4109 device_param->pw_cnt = pw_cnt;
4110 device_param->pws_cnt = pws_cnt;
4111
4112 if (pws_cnt)
4113 {
4114 run_copy (device_param, pws_cnt);
4115
4116 run_cracker (device_param, pw_cnt, pws_cnt);
4117
4118 device_param->pw_cnt = 0;
4119 device_param->pws_cnt = 0;
4120 }
4121
4122 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4123
4124 if (data.devices_status == STATUS_CRACKED) break;
4125 if (data.devices_status == STATUS_ABORTED) break;
4126 if (data.devices_status == STATUS_QUIT) break;
4127 if (data.devices_status == STATUS_BYPASS) break;
4128
4129 device_param->words_done = words_fin;
4130 }
4131 }
4132 else
4133 {
4134 const uint segment_size = data.segment_size;
4135
4136 char *dictfile = data.dictfile;
4137
4138 if (attack_mode == ATTACK_MODE_COMBI)
4139 {
4140 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4141 {
4142 dictfile = data.dictfile2;
4143 }
4144 }
4145
4146 FILE *fd = fopen (dictfile, "rb");
4147
4148 if (fd == NULL)
4149 {
4150 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4151
4152 return NULL;
4153 }
4154
4155 if (attack_mode == ATTACK_MODE_COMBI)
4156 {
4157 const uint combs_mode = data.combs_mode;
4158
4159 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4160 {
4161 const char *dictfilec = data.dictfile2;
4162
4163 FILE *combs_fp = fopen (dictfilec, "rb");
4164
4165 if (combs_fp == NULL)
4166 {
4167 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4168
4169 fclose (fd);
4170
4171 return NULL;
4172 }
4173
4174 device_param->combs_fp = combs_fp;
4175 }
4176 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4177 {
4178 const char *dictfilec = data.dictfile;
4179
4180 FILE *combs_fp = fopen (dictfilec, "rb");
4181
4182 if (combs_fp == NULL)
4183 {
4184 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4185
4186 fclose (fd);
4187
4188 return NULL;
4189 }
4190
4191 device_param->combs_fp = combs_fp;
4192 }
4193 }
4194
4195 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4196
4197 wl_data->buf = (char *) mymalloc (segment_size);
4198 wl_data->avail = segment_size;
4199 wl_data->incr = segment_size;
4200 wl_data->cnt = 0;
4201 wl_data->pos = 0;
4202
4203 uint64_t words_cur = 0;
4204
4205 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4206 {
4207 uint64_t words_off = 0;
4208 uint64_t words_fin = 0;
4209
4210 uint64_t max = -1;
4211
4212 while (max)
4213 {
4214 const uint work = get_work (device_param, max);
4215
4216 if (work == 0) break;
4217
4218 words_off = device_param->words_off;
4219 words_fin = words_off + work;
4220
4221 char *line_buf;
4222 uint line_len;
4223
4224 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4225
4226 max = 0;
4227
4228 for ( ; words_cur < words_fin; words_cur++)
4229 {
4230 get_next_word (wl_data, fd, &line_buf, &line_len);
4231
4232 line_len = convert_from_hex (line_buf, line_len);
4233
4234 // post-process rule engine
4235
4236 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4237 {
4238 char rule_buf_out[BLOCK_SIZE];
4239
4240 memset (rule_buf_out, 0, sizeof (rule_buf_out));
4241
4242 int rule_len_out = -1;
4243
4244 if (line_len < BLOCK_SIZE)
4245 {
4246 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4247 }
4248
4249 if (rule_len_out < 0) continue;
4250
4251 line_buf = rule_buf_out;
4252 line_len = rule_len_out;
4253 }
4254
4255 if (attack_kern == ATTACK_KERN_STRAIGHT)
4256 {
4257 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4258 {
4259 max++;
4260
4261 hc_thread_mutex_lock (mux_counter);
4262
4263 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4264 {
4265 data.words_progress_rejected[salt_pos] += data.gpu_rules_cnt;
4266 }
4267
4268 hc_thread_mutex_unlock (mux_counter);
4269
4270 continue;
4271 }
4272 }
4273 else if (attack_kern == ATTACK_KERN_COMBI)
4274 {
4275 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4276 // since we still need to combine the plains
4277
4278 if (line_len > data.pw_max)
4279 {
4280 max++;
4281
4282 hc_thread_mutex_lock (mux_counter);
4283
4284 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4285 {
4286 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4287 }
4288
4289 hc_thread_mutex_unlock (mux_counter);
4290
4291 continue;
4292 }
4293 }
4294
4295 device_param->pw_add (device_param, (uint8_t *) line_buf, line_len);
4296
4297 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4298
4299 if (data.devices_status == STATUS_CRACKED) break;
4300 if (data.devices_status == STATUS_ABORTED) break;
4301 if (data.devices_status == STATUS_QUIT) break;
4302 if (data.devices_status == STATUS_BYPASS) break;
4303 }
4304
4305 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4306
4307 if (data.devices_status == STATUS_CRACKED) break;
4308 if (data.devices_status == STATUS_ABORTED) break;
4309 if (data.devices_status == STATUS_QUIT) break;
4310 if (data.devices_status == STATUS_BYPASS) break;
4311 }
4312
4313 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4314
4315 if (data.devices_status == STATUS_CRACKED) break;
4316 if (data.devices_status == STATUS_ABORTED) break;
4317 if (data.devices_status == STATUS_QUIT) break;
4318 if (data.devices_status == STATUS_BYPASS) break;
4319
4320 // we need 2 flushing because we have two independant caches and it can occur
4321 // that one buffer is already at threshold plus for that length also exists
4322 // more data in the 2nd buffer so it would overflow
4323
4324 //
4325 // flush session 1
4326 //
4327
4328 {
4329 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4330 {
4331 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4332
4333 const uint pw_cache_cnt = pw_cache->cnt;
4334
4335 if (pw_cache_cnt == 0) continue;
4336
4337 pw_cache->cnt = 0;
4338
4339 uint pws_cnt = device_param->pws_cnt;
4340
4341 pw_t *pw = device_param->pws_buf + pws_cnt;
4342
4343 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4344
4345 pw->pw_len = pw_len;
4346
4347 uint pw_cnt = device_param->pw_cnt;
4348
4349 pw_cnt += pw_cache_cnt;
4350
4351 device_param->pw_cnt = pw_cnt;
4352
4353 pws_cnt++;
4354
4355 device_param->pws_cnt = pws_cnt;
4356
4357 if (pws_cnt == device_param->gpu_power_user) break;
4358 }
4359
4360 const uint pw_cnt = device_param->pw_cnt;
4361 const uint pws_cnt = device_param->pws_cnt;
4362
4363 if (pws_cnt)
4364 {
4365 run_copy (device_param, pws_cnt);
4366
4367 run_cracker (device_param, pw_cnt, pws_cnt);
4368
4369 device_param->pw_cnt = 0;
4370 device_param->pws_cnt = 0;
4371 }
4372
4373 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4374
4375 if (data.devices_status == STATUS_CRACKED) break;
4376 if (data.devices_status == STATUS_ABORTED) break;
4377 if (data.devices_status == STATUS_QUIT) break;
4378 if (data.devices_status == STATUS_BYPASS) break;
4379 }
4380
4381 //
4382 // flush session 2
4383 //
4384
4385 {
4386 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4387 {
4388 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4389
4390 const uint pw_cache_cnt = pw_cache->cnt;
4391
4392 if (pw_cache_cnt == 0) continue;
4393
4394 pw_cache->cnt = 0;
4395
4396 uint pws_cnt = device_param->pws_cnt;
4397
4398 pw_t *pw = device_param->pws_buf + pws_cnt;
4399
4400 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4401
4402 pw->pw_len = pw_len;
4403
4404 uint pw_cnt = device_param->pw_cnt;
4405
4406 pw_cnt += pw_cache_cnt;
4407
4408 device_param->pw_cnt = pw_cnt;
4409
4410 pws_cnt++;
4411
4412 device_param->pws_cnt = pws_cnt;
4413 }
4414
4415 const uint pw_cnt = device_param->pw_cnt;
4416 const uint pws_cnt = device_param->pws_cnt;
4417
4418 if (pws_cnt)
4419 {
4420 run_copy (device_param, pws_cnt);
4421
4422 run_cracker (device_param, pw_cnt, pws_cnt);
4423
4424 device_param->pw_cnt = 0;
4425 device_param->pws_cnt = 0;
4426 }
4427
4428 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4429
4430 if (data.devices_status == STATUS_CRACKED) break;
4431 if (data.devices_status == STATUS_ABORTED) break;
4432 if (data.devices_status == STATUS_QUIT) break;
4433 if (data.devices_status == STATUS_BYPASS) break;
4434 }
4435
4436 if (words_fin == 0) break;
4437
4438 device_param->words_done = words_fin;
4439 }
4440
4441 if (attack_mode == ATTACK_MODE_COMBI)
4442 {
4443 fclose (device_param->combs_fp);
4444 }
4445
4446 free (wl_data->buf);
4447 free (wl_data);
4448
4449 fclose (fd);
4450 }
4451
4452 return NULL;
4453 }
4454
4455 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos, const uint gpu_loops)
4456 {
4457 salt_t *salt_buf = &data.salts_buf[salt_pos];
4458
4459 device_param->kernel_params_buf32[24] = salt_pos;
4460 device_param->kernel_params_buf32[27] = 1;
4461 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4462 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4463 device_param->kernel_params_buf32[30] = 0;
4464 device_param->kernel_params_buf32[31] = 1;
4465
4466 char *dictfile_old = data.dictfile;
4467 char *dictfile2_old = data.dictfile2;
4468 char *mask_old = data.mask;
4469
4470 const char *weak_hash_check = "weak-hash-check";
4471
4472 data.dictfile = (char *) weak_hash_check;
4473 data.dictfile2 = (char *) weak_hash_check;
4474 data.mask = (char *) weak_hash_check;
4475
4476 /**
4477 * run the kernel
4478 */
4479
4480 if (data.attack_exec == ATTACK_EXEC_ON_GPU)
4481 {
4482 run_kernel (KERN_RUN_1, device_param, 1);
4483 }
4484 else
4485 {
4486 run_kernel (KERN_RUN_1, device_param, 1);
4487
4488 const uint iter = salt_buf->salt_iter;
4489
4490 for (uint loop_pos = 0; loop_pos < iter; loop_pos += gpu_loops)
4491 {
4492 uint loop_left = iter - loop_pos;
4493
4494 loop_left = MIN (loop_left, gpu_loops);
4495
4496 device_param->kernel_params_buf32[25] = loop_pos;
4497 device_param->kernel_params_buf32[26] = loop_left;
4498
4499 run_kernel (KERN_RUN_2, device_param, 1);
4500 }
4501
4502 run_kernel (KERN_RUN_3, device_param, 1);
4503 }
4504
4505 /**
4506 * result
4507 */
4508
4509 check_cracked (device_param, salt_pos);
4510
4511 /**
4512 * cleanup
4513 */
4514
4515 device_param->kernel_params_buf32[24] = 0;
4516 device_param->kernel_params_buf32[25] = 0;
4517 device_param->kernel_params_buf32[26] = 0;
4518 device_param->kernel_params_buf32[27] = 0;
4519 device_param->kernel_params_buf32[28] = 0;
4520 device_param->kernel_params_buf32[29] = 0;
4521 device_param->kernel_params_buf32[30] = 0;
4522 device_param->kernel_params_buf32[31] = 0;
4523
4524 data.dictfile = dictfile_old;
4525 data.dictfile2 = dictfile2_old;
4526 data.mask = mask_old;
4527 }
4528
4529 // hlfmt hashcat
4530
4531 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4532 {
4533 if (data.username == 0)
4534 {
4535 *hashbuf_pos = line_buf;
4536 *hashbuf_len = line_len;
4537 }
4538 else
4539 {
4540 char *pos = line_buf;
4541 int len = line_len;
4542
4543 for (int i = 0; i < line_len; i++, pos++, len--)
4544 {
4545 if (line_buf[i] == data.separator)
4546 {
4547 pos++;
4548
4549 len--;
4550
4551 break;
4552 }
4553 }
4554
4555 *hashbuf_pos = pos;
4556 *hashbuf_len = len;
4557 }
4558 }
4559
4560 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4561 {
4562 char *pos = NULL;
4563 int len = 0;
4564
4565 int sep_cnt = 0;
4566
4567 for (int i = 0; i < line_len; i++)
4568 {
4569 if (line_buf[i] == data.separator)
4570 {
4571 sep_cnt++;
4572
4573 continue;
4574 }
4575
4576 if (sep_cnt == 0)
4577 {
4578 if (pos == NULL) pos = line_buf + i;
4579
4580 len++;
4581 }
4582 }
4583
4584 *userbuf_pos = pos;
4585 *userbuf_len = len;
4586 }
4587
4588 // hlfmt pwdump
4589
4590 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
4591 {
4592 int sep_cnt = 0;
4593
4594 int sep2_len = 0;
4595 int sep3_len = 0;
4596
4597 for (int i = 0; i < line_len; i++)
4598 {
4599 if (line_buf[i] == ':')
4600 {
4601 sep_cnt++;
4602
4603 continue;
4604 }
4605
4606 if (sep_cnt == 2) sep2_len++;
4607 if (sep_cnt == 3) sep3_len++;
4608 }
4609
4610 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4611
4612 return 0;
4613 }
4614
4615 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4616 {
4617 char *pos = NULL;
4618 int len = 0;
4619
4620 int sep_cnt = 0;
4621
4622 for (int i = 0; i < line_len; i++)
4623 {
4624 if (line_buf[i] == ':')
4625 {
4626 sep_cnt++;
4627
4628 continue;
4629 }
4630
4631 if (data.hash_mode == 1000)
4632 {
4633 if (sep_cnt == 3)
4634 {
4635 if (pos == NULL) pos = line_buf + i;
4636
4637 len++;
4638 }
4639 }
4640 else if (data.hash_mode == 3000)
4641 {
4642 if (sep_cnt == 2)
4643 {
4644 if (pos == NULL) pos = line_buf + i;
4645
4646 len++;
4647 }
4648 }
4649 }
4650
4651 *hashbuf_pos = pos;
4652 *hashbuf_len = len;
4653 }
4654
4655 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4656 {
4657 char *pos = NULL;
4658 int len = 0;
4659
4660 int sep_cnt = 0;
4661
4662 for (int i = 0; i < line_len; i++)
4663 {
4664 if (line_buf[i] == ':')
4665 {
4666 sep_cnt++;
4667
4668 continue;
4669 }
4670
4671 if (sep_cnt == 0)
4672 {
4673 if (pos == NULL) pos = line_buf + i;
4674
4675 len++;
4676 }
4677 }
4678
4679 *userbuf_pos = pos;
4680 *userbuf_len = len;
4681 }
4682
4683 // hlfmt passwd
4684
4685 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
4686 {
4687 int sep_cnt = 0;
4688
4689 char sep5_first = 0;
4690 char sep6_first = 0;
4691
4692 for (int i = 0; i < line_len; i++)
4693 {
4694 if (line_buf[i] == ':')
4695 {
4696 sep_cnt++;
4697
4698 continue;
4699 }
4700
4701 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
4702 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
4703 }
4704
4705 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
4706
4707 return 0;
4708 }
4709
4710 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4711 {
4712 char *pos = NULL;
4713 int len = 0;
4714
4715 int sep_cnt = 0;
4716
4717 for (int i = 0; i < line_len; i++)
4718 {
4719 if (line_buf[i] == ':')
4720 {
4721 sep_cnt++;
4722
4723 continue;
4724 }
4725
4726 if (sep_cnt == 1)
4727 {
4728 if (pos == NULL) pos = line_buf + i;
4729
4730 len++;
4731 }
4732 }
4733
4734 *hashbuf_pos = pos;
4735 *hashbuf_len = len;
4736 }
4737
4738 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4739 {
4740 char *pos = NULL;
4741 int len = 0;
4742
4743 int sep_cnt = 0;
4744
4745 for (int i = 0; i < line_len; i++)
4746 {
4747 if (line_buf[i] == ':')
4748 {
4749 sep_cnt++;
4750
4751 continue;
4752 }
4753
4754 if (sep_cnt == 0)
4755 {
4756 if (pos == NULL) pos = line_buf + i;
4757
4758 len++;
4759 }
4760 }
4761
4762 *userbuf_pos = pos;
4763 *userbuf_len = len;
4764 }
4765
4766 // hlfmt shadow
4767
4768 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
4769 {
4770 int sep_cnt = 0;
4771
4772 for (int i = 0; i < line_len; i++)
4773 {
4774 if (line_buf[i] == ':') sep_cnt++;
4775 }
4776
4777 if (sep_cnt == 8) return 1;
4778
4779 return 0;
4780 }
4781
4782 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4783 {
4784 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
4785 }
4786
4787 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4788 {
4789 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
4790 }
4791
4792 // hlfmt main
4793
4794 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4795 {
4796 switch (hashfile_format)
4797 {
4798 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4799 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4800 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4801 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4802 }
4803 }
4804
4805 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4806 {
4807 switch (hashfile_format)
4808 {
4809 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
4810 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
4811 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
4812 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
4813 }
4814 }
4815
4816 static uint hlfmt_detect (FILE *fp, uint max_check)
4817 {
4818 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
4819
4820 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
4821 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
4822
4823 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
4824
4825 uint num_check = 0;
4826
4827 while (!feof (fp))
4828 {
4829 char line_buf[BUFSIZ];
4830
4831 int line_len = fgetl (fp, line_buf);
4832
4833 if (line_len == 0) continue;
4834
4835 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
4836 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
4837 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
4838
4839 if (num_check == max_check) break;
4840
4841 num_check++;
4842 }
4843
4844 uint hashlist_format = HLFMT_HASHCAT;
4845
4846 for (int i = 1; i < HLFMTS_CNT; i++)
4847 {
4848 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
4849
4850 hashlist_format = i;
4851 }
4852
4853 free (formats_cnt);
4854
4855 return hashlist_format;
4856 }
4857
4858 /**
4859 * some further helper function
4860 */
4861
4862 // wrapper around mymalloc for ADL
4863
4864 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
4865 {
4866 return mymalloc (iSize);
4867 }
4868
4869 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)
4870 {
4871 uint64_t collisions = 0;
4872
4873 const uint dgst_pos0 = data.dgst_pos0;
4874 const uint dgst_pos1 = data.dgst_pos1;
4875 const uint dgst_pos2 = data.dgst_pos2;
4876 const uint dgst_pos3 = data.dgst_pos3;
4877
4878 memset (bitmap_a, 0, bitmap_size);
4879 memset (bitmap_b, 0, bitmap_size);
4880 memset (bitmap_c, 0, bitmap_size);
4881 memset (bitmap_d, 0, bitmap_size);
4882
4883 for (uint i = 0; i < digests_cnt; i++)
4884 {
4885 uint *digest_ptr = (uint *) digests_buf_ptr;
4886
4887 digests_buf_ptr += dgst_size;
4888
4889 const uint val0 = 1 << (digest_ptr[dgst_pos0] & 0x1f);
4890 const uint val1 = 1 << (digest_ptr[dgst_pos1] & 0x1f);
4891 const uint val2 = 1 << (digest_ptr[dgst_pos2] & 0x1f);
4892 const uint val3 = 1 << (digest_ptr[dgst_pos3] & 0x1f);
4893
4894 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
4895 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
4896 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
4897 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
4898
4899 if (bitmap_a[idx0] & val0) collisions++;
4900 if (bitmap_b[idx1] & val1) collisions++;
4901 if (bitmap_c[idx2] & val2) collisions++;
4902 if (bitmap_d[idx3] & val3) collisions++;
4903
4904 bitmap_a[idx0] |= val0;
4905 bitmap_b[idx1] |= val1;
4906 bitmap_c[idx2] |= val2;
4907 bitmap_d[idx3] |= val3;
4908
4909 if (collisions >= collisions_max) return 0x7fffffff;
4910 }
4911
4912 return collisions;
4913 }
4914
4915 /**
4916 * main
4917 */
4918
4919 int main (int argc, char **argv)
4920 {
4921 /**
4922 * To help users a bit
4923 */
4924
4925 char *compute = getenv ("COMPUTE");
4926
4927 if (compute)
4928 {
4929 char display[100];
4930
4931 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
4932
4933 putenv (display);
4934 }
4935 else
4936 {
4937 if (getenv ("DISPLAY") == NULL)
4938 putenv ((char *) "DISPLAY=:0");
4939 }
4940
4941 /*
4942 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
4943 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
4944
4945 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
4946 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
4947 */
4948
4949 /**
4950 * Real init
4951 */
4952
4953 memset (&data, 0, sizeof (hc_global_data_t));
4954
4955 time_t proc_start;
4956
4957 time (&proc_start);
4958
4959 data.proc_start = proc_start;
4960
4961 int myargc = argc;
4962 char **myargv = argv;
4963
4964 hc_thread_mutex_init (mux_dispatcher);
4965 hc_thread_mutex_init (mux_counter);
4966 hc_thread_mutex_init (mux_display);
4967 hc_thread_mutex_init (mux_adl);
4968
4969 /**
4970 * commandline parameters
4971 */
4972
4973 uint usage = USAGE;
4974 uint version = VERSION;
4975 uint quiet = QUIET;
4976 uint benchmark = BENCHMARK;
4977 uint benchmark_mode = BENCHMARK_MODE;
4978 uint show = SHOW;
4979 uint left = LEFT;
4980 uint username = USERNAME;
4981 uint remove = REMOVE;
4982 uint remove_timer = REMOVE_TIMER;
4983 uint64_t skip = SKIP;
4984 uint64_t limit = LIMIT;
4985 uint keyspace = KEYSPACE;
4986 uint potfile_disable = POTFILE_DISABLE;
4987 uint debug_mode = DEBUG_MODE;
4988 char *debug_file = NULL;
4989 char *induction_dir = NULL;
4990 char *outfile_check_dir = NULL;
4991 uint force = FORCE;
4992 uint runtime = RUNTIME;
4993 uint hash_mode = HASH_MODE;
4994 uint attack_mode = ATTACK_MODE;
4995 uint markov_disable = MARKOV_DISABLE;
4996 uint markov_classic = MARKOV_CLASSIC;
4997 uint markov_threshold = MARKOV_THRESHOLD;
4998 char *markov_hcstat = NULL;
4999 char *outfile = NULL;
5000 uint outfile_format = OUTFILE_FORMAT;
5001 uint outfile_autohex = OUTFILE_AUTOHEX;
5002 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5003 uint restore = RESTORE;
5004 uint restore_timer = RESTORE_TIMER;
5005 uint restore_disable = RESTORE_DISABLE;
5006 uint status = STATUS;
5007 uint status_timer = STATUS_TIMER;
5008 uint status_automat = STATUS_AUTOMAT;
5009 uint loopback = LOOPBACK;
5010 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5011 char *session = NULL;
5012 uint hex_charset = HEX_CHARSET;
5013 uint hex_salt = HEX_SALT;
5014 uint hex_wordlist = HEX_WORDLIST;
5015 uint rp_gen = RP_GEN;
5016 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5017 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5018 uint rp_gen_seed = RP_GEN_SEED;
5019 char *rule_buf_l = (char *) RULE_BUF_L;
5020 char *rule_buf_r = (char *) RULE_BUF_R;
5021 uint increment = INCREMENT;
5022 uint increment_min = INCREMENT_MIN;
5023 uint increment_max = INCREMENT_MAX;
5024 char *cpu_affinity = NULL;
5025 char *gpu_devices = NULL;
5026 char *truecrypt_keyfiles = NULL;
5027 uint workload_profile = WORKLOAD_PROFILE;
5028 uint gpu_accel = GPU_ACCEL;
5029 uint gpu_loops = GPU_LOOPS;
5030 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5031 uint gpu_temp_abort = GPU_TEMP_ABORT;
5032 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5033 uint powertune_enable = POWERTUNE_ENABLE;
5034 uint logfile_disable = LOGFILE_DISABLE;
5035 uint segment_size = SEGMENT_SIZE;
5036 uint scrypt_tmto = SCRYPT_TMTO;
5037 char separator = SEPARATOR;
5038 uint bitmap_min = BITMAP_MIN;
5039 uint bitmap_max = BITMAP_MAX;
5040 char *custom_charset_1 = NULL;
5041 char *custom_charset_2 = NULL;
5042 char *custom_charset_3 = NULL;
5043 char *custom_charset_4 = NULL;
5044
5045 #define IDX_HELP 'h'
5046 #define IDX_VERSION 'V'
5047 #define IDX_VERSION_LOWER 'v'
5048 #define IDX_QUIET 0xff02
5049 #define IDX_SHOW 0xff03
5050 #define IDX_LEFT 0xff04
5051 #define IDX_REMOVE 0xff05
5052 #define IDX_REMOVE_TIMER 0xff37
5053 #define IDX_SKIP 's'
5054 #define IDX_LIMIT 'l'
5055 #define IDX_KEYSPACE 0xff35
5056 #define IDX_POTFILE_DISABLE 0xff06
5057 #define IDX_DEBUG_MODE 0xff43
5058 #define IDX_DEBUG_FILE 0xff44
5059 #define IDX_INDUCTION_DIR 0xff46
5060 #define IDX_OUTFILE_CHECK_DIR 0xff47
5061 #define IDX_USERNAME 0xff07
5062 #define IDX_FORCE 0xff08
5063 #define IDX_RUNTIME 0xff09
5064 #define IDX_BENCHMARK 'b'
5065 #define IDX_BENCHMARK_MODE 0xff32
5066 #define IDX_HASH_MODE 'm'
5067 #define IDX_ATTACK_MODE 'a'
5068 #define IDX_RP_FILE 'r'
5069 #define IDX_RP_GEN 'g'
5070 #define IDX_RP_GEN_FUNC_MIN 0xff10
5071 #define IDX_RP_GEN_FUNC_MAX 0xff11
5072 #define IDX_RP_GEN_SEED 0xff34
5073 #define IDX_RULE_BUF_L 'j'
5074 #define IDX_RULE_BUF_R 'k'
5075 #define IDX_INCREMENT 'i'
5076 #define IDX_INCREMENT_MIN 0xff12
5077 #define IDX_INCREMENT_MAX 0xff13
5078 #define IDX_OUTFILE 'o'
5079 #define IDX_OUTFILE_FORMAT 0xff14
5080 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5081 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5082 #define IDX_RESTORE 0xff15
5083 #define IDX_RESTORE_DISABLE 0xff27
5084 #define IDX_STATUS 0xff17
5085 #define IDX_STATUS_TIMER 0xff18
5086 #define IDX_STATUS_AUTOMAT 0xff50
5087 #define IDX_LOOPBACK 0xff38
5088 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5089 #define IDX_SESSION 0xff19
5090 #define IDX_HEX_CHARSET 0xff20
5091 #define IDX_HEX_SALT 0xff21
5092 #define IDX_HEX_WORDLIST 0xff40
5093 #define IDX_MARKOV_DISABLE 0xff22
5094 #define IDX_MARKOV_CLASSIC 0xff23
5095 #define IDX_MARKOV_THRESHOLD 't'
5096 #define IDX_MARKOV_HCSTAT 0xff24
5097 #define IDX_CPU_AFFINITY 0xff25
5098 #define IDX_GPU_DEVICES 'd'
5099 #define IDX_WORKLOAD_PROFILE 'w'
5100 #define IDX_GPU_ACCEL 'n'
5101 #define IDX_GPU_LOOPS 'u'
5102 #define IDX_GPU_TEMP_DISABLE 0xff29
5103 #define IDX_GPU_TEMP_ABORT 0xff30
5104 #define IDX_GPU_TEMP_RETAIN 0xff31
5105 #define IDX_POWERTUNE_ENABLE 0xff41
5106 #define IDX_LOGFILE_DISABLE 0xff51
5107 #define IDX_TRUECRYPT_KEYFILES 0xff52
5108 #define IDX_SCRYPT_TMTO 0xff61
5109 #define IDX_SEGMENT_SIZE 'c'
5110 #define IDX_SEPARATOR 'p'
5111 #define IDX_BITMAP_MIN 0xff70
5112 #define IDX_BITMAP_MAX 0xff71
5113 #define IDX_CUSTOM_CHARSET_1 '1'
5114 #define IDX_CUSTOM_CHARSET_2 '2'
5115 #define IDX_CUSTOM_CHARSET_3 '3'
5116 #define IDX_CUSTOM_CHARSET_4 '4'
5117
5118 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5119
5120 struct option long_options[] =
5121 {
5122 {"help", no_argument, 0, IDX_HELP},
5123 {"version", no_argument, 0, IDX_VERSION},
5124 {"quiet", no_argument, 0, IDX_QUIET},
5125 {"show", no_argument, 0, IDX_SHOW},
5126 {"left", no_argument, 0, IDX_LEFT},
5127 {"username", no_argument, 0, IDX_USERNAME},
5128 {"remove", no_argument, 0, IDX_REMOVE},
5129 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5130 {"skip", required_argument, 0, IDX_SKIP},
5131 {"limit", required_argument, 0, IDX_LIMIT},
5132 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5133 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5134 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5135 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5136 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5137 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5138 {"force", no_argument, 0, IDX_FORCE},
5139 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5140 {"benchmark-mode", required_argument, 0, IDX_BENCHMARK_MODE},
5141 {"restore", no_argument, 0, IDX_RESTORE},
5142 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5143 {"status", no_argument, 0, IDX_STATUS},
5144 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5145 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5146 {"loopback", no_argument, 0, IDX_LOOPBACK},
5147 {"weak-hash-threshold",
5148 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5149 {"session", required_argument, 0, IDX_SESSION},
5150 {"runtime", required_argument, 0, IDX_RUNTIME},
5151 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5152 {"generate-rules-func-min",
5153 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5154 {"generate-rules-func-max",
5155 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5156 {"generate-rules-seed",
5157 required_argument, 0, IDX_RP_GEN_SEED},
5158 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5159 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5160 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5161 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5162 {"rules-file", required_argument, 0, IDX_RP_FILE},
5163 {"outfile", required_argument, 0, IDX_OUTFILE},
5164 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5165 {"outfile-autohex-disable",
5166 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5167 {"outfile-check-timer",
5168 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5169 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5170 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5171 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5172 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5173 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5174 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5175 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5176 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5177 {"gpu-devices", required_argument, 0, IDX_GPU_DEVICES},
5178 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5179 {"gpu-accel", required_argument, 0, IDX_GPU_ACCEL},
5180 {"gpu-loops", required_argument, 0, IDX_GPU_LOOPS},
5181 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5182 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5183 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5184 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5185 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5186 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5187 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5188 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5189 // deprecated
5190 {"seperator", required_argument, 0, IDX_SEPARATOR},
5191 {"separator", required_argument, 0, IDX_SEPARATOR},
5192 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5193 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5194 {"increment", no_argument, 0, IDX_INCREMENT},
5195 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5196 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5197 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5198 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5199 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5200 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5201
5202 {0, 0, 0, 0}
5203 };
5204
5205 uint rp_files_cnt = 0;
5206
5207 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5208
5209 int option_index;
5210 int c;
5211
5212 optind = 1;
5213 optopt = 0;
5214 option_index = 0;
5215
5216 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5217 {
5218 switch (c)
5219 {
5220 case IDX_HELP: usage = 1; break;
5221 case IDX_VERSION:
5222 case IDX_VERSION_LOWER: version = 1; break;
5223 case IDX_RESTORE: restore = 1; break;
5224 case IDX_SESSION: session = optarg; break;
5225 case IDX_SHOW: show = 1; break;
5226 case IDX_LEFT: left = 1; break;
5227 case '?': return (-1);
5228 }
5229 }
5230
5231 if (optopt != 0)
5232 {
5233 log_error ("ERROR: Invalid argument specified");
5234
5235 return (-1);
5236 }
5237
5238 /**
5239 * exit functions
5240 */
5241
5242 if (version)
5243 {
5244 log_info (VERSION_TXT);
5245
5246 return (0);
5247 }
5248
5249 if (usage)
5250 {
5251 usage_big_print (PROGNAME);
5252
5253 return (0);
5254 }
5255
5256 /**
5257 * session
5258 */
5259
5260 if (session == NULL) session = (char *) PROGNAME;
5261
5262 size_t session_size = strlen (session) + 32;
5263
5264 data.session = session;
5265
5266 char *eff_restore_file = (char *) mymalloc (session_size);
5267 char *new_restore_file = (char *) mymalloc (session_size);
5268
5269 snprintf (eff_restore_file, session_size - 1, "%s.restore", session);
5270 snprintf (new_restore_file, session_size - 1, "%s.restore.new", session);
5271
5272 data.eff_restore_file = eff_restore_file;
5273 data.new_restore_file = new_restore_file;
5274
5275 if (((show == 1) || (left == 1)) && (restore == 1))
5276 {
5277 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5278 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5279
5280 return (-1);
5281 }
5282
5283 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5284 if ((show == 1) || (left == 1))
5285 {
5286 restore_disable = 1;
5287
5288 restore = 0;
5289 }
5290
5291 data.restore_disable = restore_disable;
5292
5293 restore_data_t *rd = init_restore (argc, argv);
5294
5295 data.rd = rd;
5296
5297 /**
5298 * restore file
5299 */
5300
5301 if (restore == 1)
5302 {
5303 read_restore (eff_restore_file, rd);
5304
5305 if (rd->version_bin < RESTORE_MIN)
5306 {
5307 log_error ("ERROR: Incompatible restore-file version");
5308
5309 return (-1);
5310 }
5311
5312 myargc = rd->argc;
5313 myargv = rd->argv;
5314
5315 #ifdef _POSIX
5316 rd->pid = getpid ();
5317 #elif _WIN
5318 rd->pid = GetCurrentProcessId ();
5319 #endif
5320 }
5321
5322 uint hash_mode_chgd = 0;
5323 uint runtime_chgd = 0;
5324 uint gpu_loops_chgd = 0;
5325 uint gpu_accel_chgd = 0;
5326 uint attack_mode_chgd = 0;
5327 uint outfile_format_chgd = 0;
5328 uint rp_gen_seed_chgd = 0;
5329 uint remove_timer_chgd = 0;
5330 uint increment_min_chgd = 0;
5331 uint increment_max_chgd = 0;
5332 uint gpu_temp_abort_chgd = 0;
5333 uint gpu_temp_retain_chgd = 0;
5334
5335 optind = 1;
5336 optopt = 0;
5337 option_index = 0;
5338
5339 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5340 {
5341 switch (c)
5342 {
5343 //case IDX_HELP: usage = 1; break;
5344 //case IDX_VERSION: version = 1; break;
5345 //case IDX_RESTORE: restore = 1; break;
5346 case IDX_QUIET: quiet = 1; break;
5347 //case IDX_SHOW: show = 1; break;
5348 case IDX_SHOW: break;
5349 //case IDX_LEFT: left = 1; break;
5350 case IDX_LEFT: break;
5351 case IDX_USERNAME: username = 1; break;
5352 case IDX_REMOVE: remove = 1; break;
5353 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5354 remove_timer_chgd = 1; break;
5355 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5356 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5357 case IDX_DEBUG_FILE: debug_file = optarg; break;
5358 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5359 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5360 case IDX_FORCE: force = 1; break;
5361 case IDX_SKIP: skip = atoll (optarg); break;
5362 case IDX_LIMIT: limit = atoll (optarg); break;
5363 case IDX_KEYSPACE: keyspace = 1; break;
5364 case IDX_BENCHMARK: benchmark = 1; break;
5365 case IDX_BENCHMARK_MODE: benchmark_mode = atoi (optarg); break;
5366 case IDX_RESTORE: break;
5367 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5368 case IDX_STATUS: status = 1; break;
5369 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5370 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5371 case IDX_LOOPBACK: loopback = 1; break;
5372 case IDX_WEAK_HASH_THRESHOLD:
5373 weak_hash_threshold = atoi (optarg); break;
5374 //case IDX_SESSION: session = optarg; break;
5375 case IDX_SESSION: break;
5376 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5377 hash_mode_chgd = 1; break;
5378 case IDX_RUNTIME: runtime = atoi (optarg);
5379 runtime_chgd = 1; break;
5380 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5381 attack_mode_chgd = 1; break;
5382 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5383 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5384 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5385 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5386 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5387 rp_gen_seed_chgd = 1; break;
5388 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5389 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5390 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5391 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5392 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5393 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5394 case IDX_OUTFILE: outfile = optarg; break;
5395 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5396 outfile_format_chgd = 1; break;
5397 case IDX_OUTFILE_AUTOHEX_DISABLE:
5398 outfile_autohex = 0; break;
5399 case IDX_OUTFILE_CHECK_TIMER:
5400 outfile_check_timer = atoi (optarg); break;
5401 case IDX_HEX_CHARSET: hex_charset = 1; break;
5402 case IDX_HEX_SALT: hex_salt = 1; break;
5403 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5404 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5405 case IDX_GPU_DEVICES: gpu_devices = optarg; break;
5406 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg); break;
5407 case IDX_GPU_ACCEL: gpu_accel = atoi (optarg);
5408 gpu_accel_chgd = 1; break;
5409 case IDX_GPU_LOOPS: gpu_loops = atoi (optarg);
5410 gpu_loops_chgd = 1; break;
5411 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5412 case IDX_GPU_TEMP_ABORT: gpu_temp_abort_chgd = 1;
5413 gpu_temp_abort = atoi (optarg); break;
5414 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain_chgd = 1;
5415 gpu_temp_retain = atoi (optarg); break;
5416 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5417 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5418 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5419 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5420 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5421 case IDX_SEPARATOR: separator = optarg[0]; break;
5422 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5423 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5424 case IDX_INCREMENT: increment = 1; break;
5425 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5426 increment_min_chgd = 1; break;
5427 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5428 increment_max_chgd = 1; break;
5429 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5430 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5431 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5432 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5433
5434 default:
5435 log_error ("ERROR: Invalid argument specified");
5436 return (-1);
5437 }
5438 }
5439
5440 if (optopt != 0)
5441 {
5442 log_error ("ERROR: Invalid argument specified");
5443
5444 return (-1);
5445 }
5446
5447 /**
5448 * Inform user things getting started,
5449 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5450 * - we do not need to check algorithm_pos
5451 */
5452
5453 if (quiet == 0)
5454 {
5455 if (benchmark == 1)
5456 {
5457 log_info ("%s v%.2f starting in benchmark-mode...", PROGNAME, (float) VERSION_BIN / 100);
5458
5459 log_info ("");
5460 }
5461 else if (restore == 1)
5462 {
5463 log_info ("%s v%.2f starting in restore-mode...", PROGNAME, (float) VERSION_BIN / 100);
5464
5465 log_info ("");
5466 }
5467 else
5468 {
5469 log_info ("%s v%.2f starting...", PROGNAME, (float) VERSION_BIN / 100);
5470
5471 log_info ("");
5472 }
5473 }
5474
5475 /**
5476 * sanity check
5477 */
5478
5479 if (attack_mode > 7)
5480 {
5481 log_error ("ERROR: Invalid attack-mode specified");
5482
5483 return (-1);
5484 }
5485
5486 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5487 {
5488 log_error ("ERROR: Invalid runtime specified");
5489
5490 return (-1);
5491 }
5492
5493 if (hash_mode_chgd && hash_mode > 12800) // just added to remove compiler warnings for hash_mode_chgd
5494 {
5495 log_error ("ERROR: Invalid hash-type specified");
5496
5497 return (-1);
5498 }
5499
5500 // renamed hash modes
5501
5502 if (hash_mode_chgd)
5503 {
5504 int n = -1;
5505
5506 switch (hash_mode)
5507 {
5508 case 123: n = 124;
5509 break;
5510 }
5511
5512 if (n >= 0)
5513 {
5514 log_error ("Old -m specified, use -m %d instead", n);
5515
5516 return (-1);
5517 }
5518 }
5519
5520 if (username == 1)
5521 {
5522 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5523 {
5524 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5525
5526 return (-1);
5527 }
5528 }
5529
5530 if (outfile_format > 16)
5531 {
5532 log_error ("ERROR: Invalid outfile-format specified");
5533
5534 return (-1);
5535 }
5536
5537 if (left == 1)
5538 {
5539 if (outfile_format_chgd == 1)
5540 {
5541 if (outfile_format > 1)
5542 {
5543 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5544
5545 return (-1);
5546 }
5547 }
5548 else
5549 {
5550 outfile_format = OUTFILE_FMT_HASH;
5551 }
5552 }
5553
5554 if (show == 1)
5555 {
5556 if (outfile_format_chgd == 1)
5557 {
5558 if ((outfile_format > 7) && (outfile_format < 16))
5559 {
5560 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
5561
5562 return (-1);
5563 }
5564 }
5565 }
5566
5567 if (increment_min < INCREMENT_MIN)
5568 {
5569 log_error ("ERROR: Invalid increment-min specified");
5570
5571 return (-1);
5572 }
5573
5574 if (increment_max > INCREMENT_MAX)
5575 {
5576 log_error ("ERROR: Invalid increment-max specified");
5577
5578 return (-1);
5579 }
5580
5581 if (increment_min > increment_max)
5582 {
5583 log_error ("ERROR: Invalid increment-min specified");
5584
5585 return (-1);
5586 }
5587
5588 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
5589 {
5590 log_error ("ERROR: increment is not allowed in attack-mode 0");
5591
5592 return (-1);
5593 }
5594
5595 if ((increment == 0) && (increment_min_chgd == 1))
5596 {
5597 log_error ("ERROR: increment-min is only supported together with increment switch");
5598
5599 return (-1);
5600 }
5601
5602 if ((increment == 0) && (increment_max_chgd == 1))
5603 {
5604 log_error ("ERROR: increment-max is only supported together with increment switch");
5605
5606 return (-1);
5607 }
5608
5609 if (rp_files_cnt && rp_gen)
5610 {
5611 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
5612
5613 return (-1);
5614 }
5615
5616 if (rp_files_cnt || rp_gen)
5617 {
5618 if (attack_mode != ATTACK_MODE_STRAIGHT)
5619 {
5620 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
5621
5622 return (-1);
5623 }
5624 }
5625
5626 if (rp_gen_func_min > rp_gen_func_max)
5627 {
5628 log_error ("ERROR: Invalid rp-gen-func-min specified");
5629
5630 return (-1);
5631 }
5632
5633 if (gpu_accel_chgd == 1)
5634 {
5635 if (workload_profile != WORKLOAD_PROFILE)
5636 {
5637 log_error ("ERROR: gpu-accel parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5638
5639 return (-1);
5640 }
5641
5642 if (gpu_accel < 1)
5643 {
5644 log_error ("ERROR: Invalid gpu-accel specified");
5645
5646 return (-1);
5647 }
5648
5649 if (gpu_accel > 800)
5650 {
5651 log_error ("ERROR: Invalid gpu-accel specified");
5652
5653 return (-1);
5654 }
5655 }
5656
5657 if (gpu_loops_chgd == 1)
5658 {
5659 if (workload_profile != WORKLOAD_PROFILE)
5660 {
5661 log_error ("ERROR: gpu-loops parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5662
5663 return (-1);
5664 }
5665
5666 if (gpu_loops < 1)
5667 {
5668 log_error ("ERROR: Invalid gpu-loops specified");
5669
5670 return (-1);
5671 }
5672
5673 if (gpu_loops > 1024)
5674 {
5675 log_error ("ERROR: Invalid gpu-loops specified");
5676
5677 return (-1);
5678 }
5679 }
5680
5681 if (benchmark == 1)
5682 {
5683 if (workload_profile != WORKLOAD_PROFILE)
5684 {
5685 log_error ("ERROR: Using the workload-profile in benchmark mode is not allowed");
5686
5687 return (-1);
5688 }
5689 }
5690
5691 if ((workload_profile < 1) || (workload_profile > 3))
5692 {
5693 log_error ("ERROR: workload-profile %i not available", workload_profile);
5694
5695 return (-1);
5696 }
5697
5698 if (show == 1 || left == 1)
5699 {
5700 attack_mode = ATTACK_MODE_NONE;
5701
5702 if (remove == 1)
5703 {
5704 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
5705
5706 return (-1);
5707 }
5708
5709 if (potfile_disable == 1)
5710 {
5711 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
5712
5713 return (-1);
5714 }
5715 }
5716
5717 uint attack_kern = ATTACK_KERN_NONE;
5718
5719 switch (attack_mode)
5720 {
5721 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
5722 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
5723 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
5724 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
5725 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
5726 }
5727
5728 if (benchmark == 0)
5729 {
5730 if (keyspace == 1)
5731 {
5732 int num_additional_params = 1;
5733
5734 if (attack_kern == ATTACK_KERN_COMBI)
5735 {
5736 num_additional_params = 2;
5737 }
5738
5739 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
5740
5741 if (keyspace_wordlist_specified == 0) optind--;
5742 }
5743
5744 if (attack_kern == ATTACK_KERN_NONE)
5745 {
5746 if ((optind + 1) != myargc)
5747 {
5748 usage_mini_print (myargv[0]);
5749
5750 return (-1);
5751 }
5752 }
5753 else if (attack_kern == ATTACK_KERN_STRAIGHT)
5754 {
5755 if ((optind + 1) > myargc)
5756 {
5757 usage_mini_print (myargv[0]);
5758
5759 return (-1);
5760 }
5761 }
5762 else if (attack_kern == ATTACK_KERN_COMBI)
5763 {
5764 if ((optind + 3) != myargc)
5765 {
5766 usage_mini_print (myargv[0]);
5767
5768 return (-1);
5769 }
5770 }
5771 else if (attack_kern == ATTACK_KERN_BF)
5772 {
5773 if ((optind + 1) > myargc)
5774 {
5775 usage_mini_print (myargv[0]);
5776
5777 return (-1);
5778 }
5779 }
5780 else
5781 {
5782 usage_mini_print (myargv[0]);
5783
5784 return (-1);
5785 }
5786 }
5787 else
5788 {
5789 if (myargv[optind] != 0)
5790 {
5791 log_error ("ERROR: Invalid argument for benchmark mode specified");
5792
5793 return (-1);
5794 }
5795
5796 if (attack_mode_chgd == 1)
5797 {
5798 if (attack_mode != ATTACK_MODE_BF)
5799 {
5800 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
5801
5802 return (-1);
5803 }
5804 }
5805
5806 if (benchmark_mode == 0)
5807 {
5808 // nothing to do
5809 }
5810 else if (benchmark_mode == 1)
5811 {
5812 if (gpu_accel_chgd == 1 || gpu_loops_chgd == 1)
5813 {
5814 log_error ("ERROR: Benchmark-mode 1 does not allow gpu-accel or gpu-loops changed");
5815
5816 return (-1);
5817 }
5818 }
5819 else
5820 {
5821 log_error ("ERROR: Benchmark-mode must be 0 or 1");
5822
5823 return (-1);
5824 }
5825 }
5826
5827 if (skip != 0 && limit != 0)
5828 {
5829 limit += skip;
5830 }
5831
5832 if (keyspace == 1)
5833 {
5834 if (show == 1)
5835 {
5836 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
5837
5838 return (-1);
5839 }
5840 else if (left == 1)
5841 {
5842 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
5843
5844 return (-1);
5845 }
5846
5847 potfile_disable = 1;
5848
5849 restore_disable = 1;
5850
5851 restore = 0;
5852
5853 weak_hash_threshold = 0;
5854
5855 quiet = 1;
5856 }
5857
5858 if (remove_timer_chgd == 1)
5859 {
5860 if (remove == 0)
5861 {
5862 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
5863
5864 return (-1);
5865 }
5866
5867 if (remove_timer < 1)
5868 {
5869 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
5870
5871 return (-1);
5872 }
5873 }
5874
5875 if (loopback == 1)
5876 {
5877 if (attack_mode == ATTACK_MODE_BF)
5878 {
5879 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
5880
5881 return (-1);
5882 }
5883 else if (attack_mode == ATTACK_MODE_STRAIGHT)
5884 {
5885 if ((rp_files_cnt == 0) && (rp_gen == 0))
5886 {
5887 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
5888
5889 return (-1);
5890 }
5891 }
5892 }
5893
5894 if (debug_mode > 0)
5895 {
5896 if (attack_mode != ATTACK_MODE_STRAIGHT)
5897 {
5898 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
5899
5900 return (-1);
5901 }
5902
5903 if ((rp_files_cnt == 0) && (rp_gen == 0))
5904 {
5905 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
5906
5907 return (-1);
5908 }
5909 }
5910
5911 if (debug_mode > 4)
5912 {
5913 log_error ("ERROR: Invalid debug-mode specified");
5914
5915 return (-1);
5916 }
5917
5918 if (debug_file != NULL)
5919 {
5920 if (debug_mode < 1)
5921 {
5922 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
5923
5924 return (-1);
5925 }
5926 }
5927
5928 if (induction_dir != NULL)
5929 {
5930 if (attack_mode == ATTACK_MODE_BF)
5931 {
5932 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
5933
5934 return (-1);
5935 }
5936 }
5937
5938 /**
5939 * induction directory
5940 */
5941
5942 char *induction_directory = NULL;
5943
5944 if (attack_mode != ATTACK_MODE_BF)
5945 {
5946 if (induction_dir == NULL)
5947 {
5948 induction_directory = (char *) mymalloc (session_size);
5949
5950 snprintf (induction_directory, session_size - 1, "%s.%s", session, INDUCT_DIR);
5951
5952 // create induction folder if it does not already exist
5953
5954 if (keyspace == 0)
5955 {
5956 if (rmdir (induction_directory) == -1)
5957 {
5958 if (errno == ENOENT)
5959 {
5960 // good, we can ignore
5961 }
5962 else if (errno == ENOTEMPTY)
5963 {
5964 char *induction_directory_mv = (char *) mymalloc (session_size);
5965
5966 snprintf (induction_directory_mv, session_size - 1, "%s.induct.%d", session, (int) proc_start);
5967
5968 if (rename (induction_directory, induction_directory_mv) != 0)
5969 {
5970 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
5971
5972 return (-1);
5973 }
5974 }
5975 else
5976 {
5977 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
5978
5979 return (-1);
5980 }
5981 }
5982
5983 #ifdef _WIN
5984 #define mkdir(name,mode) mkdir (name)
5985 #endif
5986
5987 if (mkdir (induction_directory, 0700) == -1)
5988 {
5989 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
5990
5991 return (-1);
5992 }
5993 }
5994 }
5995 else
5996 {
5997 induction_directory = induction_dir;
5998 }
5999 }
6000
6001 data.induction_directory = induction_directory;
6002
6003 /**
6004 * loopback
6005 */
6006
6007 size_t loopback_size = session_size + strlen (LOOPBACK_FILE) + 12;
6008
6009 char *loopback_file = (char *) mymalloc (loopback_size);
6010
6011 /**
6012 * outfile-check directory
6013 */
6014
6015 char *outfile_check_directory = NULL;
6016
6017 if (outfile_check_dir == NULL)
6018 {
6019 outfile_check_directory = (char *) mymalloc (session_size);
6020
6021 snprintf (outfile_check_directory, session_size - 1, "%s.%s", session, OUTFILES_DIR);
6022 }
6023 else
6024 {
6025 outfile_check_directory = outfile_check_dir;
6026 }
6027
6028 data.outfile_check_directory = outfile_check_directory;
6029
6030 if (keyspace == 0)
6031 {
6032 struct stat outfile_check_stat;
6033
6034 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6035 {
6036 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6037
6038 if (is_dir == 0)
6039 {
6040 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6041
6042 return (-1);
6043 }
6044 }
6045 else if (outfile_check_dir == NULL)
6046 {
6047 #ifdef _WIN
6048 #define mkdir(name,mode) mkdir (name)
6049 #endif
6050
6051 if (mkdir (outfile_check_directory, 0700) == -1)
6052 {
6053 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6054
6055 return (-1);
6056 }
6057 }
6058 }
6059
6060 /**
6061 * special other stuff
6062 */
6063
6064 if (hash_mode == 9710)
6065 {
6066 outfile_format = 5;
6067 outfile_format_chgd = 1;
6068 }
6069
6070 if (hash_mode == 9810)
6071 {
6072 outfile_format = 5;
6073 outfile_format_chgd = 1;
6074 }
6075
6076 if (hash_mode == 10410)
6077 {
6078 outfile_format = 5;
6079 outfile_format_chgd = 1;
6080 }
6081
6082 /**
6083 * store stuff
6084 */
6085
6086 data.hash_mode = hash_mode;
6087 data.restore = restore;
6088 data.restore_timer = restore_timer;
6089 data.restore_disable = restore_disable;
6090 data.status = status;
6091 data.status_timer = status_timer;
6092 data.status_automat = status_automat;
6093 data.loopback = loopback;
6094 data.runtime = runtime;
6095 data.remove = remove;
6096 data.remove_timer = remove_timer;
6097 data.debug_mode = debug_mode;
6098 data.debug_file = debug_file;
6099 data.username = username;
6100 data.quiet = quiet;
6101 data.outfile = outfile;
6102 data.outfile_format = outfile_format;
6103 data.outfile_autohex = outfile_autohex;
6104 data.hex_charset = hex_charset;
6105 data.hex_salt = hex_salt;
6106 data.hex_wordlist = hex_wordlist;
6107 data.separator = separator;
6108 data.rp_files = rp_files;
6109 data.rp_files_cnt = rp_files_cnt;
6110 data.rp_gen = rp_gen;
6111 data.rp_gen_seed = rp_gen_seed;
6112 data.force = force;
6113 data.benchmark = benchmark;
6114 data.skip = skip;
6115 data.limit = limit;
6116 data.powertune_enable = powertune_enable;
6117 data.logfile_disable = logfile_disable;
6118 data.truecrypt_keyfiles = truecrypt_keyfiles;
6119 data.scrypt_tmto = scrypt_tmto;
6120
6121 /**
6122 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
6123 */
6124
6125 #ifdef LINUX
6126
6127 char *resolved_path = realpath (myargv[0], NULL);
6128
6129 char *install_dir = get_install_dir (resolved_path);
6130 char *profile_dir = NULL;
6131 char *session_dir = NULL;
6132
6133 if (strcmp (install_dir, INSTALL_FOLDER) == 0)
6134 {
6135 struct passwd *pw = getpwuid (getuid ());
6136
6137 const char *homedir = pw->pw_dir;
6138
6139 profile_dir = get_profile_dir (homedir);
6140 session_dir = get_session_dir (profile_dir, session);
6141 }
6142 else
6143 {
6144 profile_dir = install_dir;
6145 session_dir = install_dir;
6146 }
6147
6148 myfree (resolved_path);
6149
6150 #else
6151
6152 char *install_dir = get_install_dir (myargv[0]);
6153 char *profile_dir = install_dir;
6154 char *session_dir = install_dir;
6155
6156 #endif
6157
6158 data.install_dir = install_dir;
6159 data.profile_dir = profile_dir;
6160 data.session_dir = session_dir;
6161
6162 /**
6163 * cpu affinity
6164 */
6165
6166 if (cpu_affinity)
6167 {
6168 set_cpu_affinity (cpu_affinity);
6169 }
6170
6171 if (rp_gen_seed_chgd == 0)
6172 {
6173 srand (proc_start);
6174 }
6175 else
6176 {
6177 srand (rp_gen_seed);
6178 }
6179
6180 /**
6181 * logfile init
6182 */
6183
6184 if (logfile_disable == 0)
6185 {
6186 size_t logfile_size = strlen (session) + 32;
6187
6188 char *logfile = (char *) mymalloc (logfile_size);
6189
6190 snprintf (logfile, logfile_size - 1, "%s.log", session);
6191
6192 data.logfile = logfile;
6193
6194 char *topid = logfile_generate_topid ();
6195
6196 data.topid = topid;
6197 }
6198
6199 // logfile_append() checks for logfile_disable internally to make it easier from here
6200
6201 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6202 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6203 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6204 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6205 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6206 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6207 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6208 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6209 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6210 #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));
6211
6212 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6213 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6214 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6215 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6216 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6217 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6218 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6219 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6220
6221 logfile_top_msg ("START");
6222
6223 logfile_top_uint (attack_mode);
6224 logfile_top_uint (attack_kern);
6225 logfile_top_uint (benchmark);
6226 logfile_top_uint (benchmark_mode);
6227 logfile_top_uint (bitmap_min);
6228 logfile_top_uint (bitmap_max);
6229 logfile_top_uint (debug_mode);
6230 logfile_top_uint (force);
6231 logfile_top_uint (gpu_accel);
6232 logfile_top_uint (gpu_loops);
6233 logfile_top_uint (gpu_temp_abort);
6234 logfile_top_uint (gpu_temp_disable);
6235 logfile_top_uint (gpu_temp_retain);
6236 logfile_top_uint (hash_mode);
6237 logfile_top_uint (hex_charset);
6238 logfile_top_uint (hex_salt);
6239 logfile_top_uint (hex_wordlist);
6240 logfile_top_uint (increment);
6241 logfile_top_uint (increment_max);
6242 logfile_top_uint (increment_min);
6243 logfile_top_uint (keyspace);
6244 logfile_top_uint (left);
6245 logfile_top_uint (logfile_disable);
6246 logfile_top_uint (loopback);
6247 logfile_top_uint (markov_classic);
6248 logfile_top_uint (markov_disable);
6249 logfile_top_uint (markov_threshold);
6250 logfile_top_uint (outfile_autohex);
6251 logfile_top_uint (outfile_check_timer);
6252 logfile_top_uint (outfile_format);
6253 logfile_top_uint (potfile_disable);
6254 logfile_top_uint (powertune_enable);
6255 logfile_top_uint (scrypt_tmto);
6256 logfile_top_uint (quiet);
6257 logfile_top_uint (remove);
6258 logfile_top_uint (remove_timer);
6259 logfile_top_uint (restore);
6260 logfile_top_uint (restore_disable);
6261 logfile_top_uint (restore_timer);
6262 logfile_top_uint (rp_gen);
6263 logfile_top_uint (rp_gen_func_max);
6264 logfile_top_uint (rp_gen_func_min);
6265 logfile_top_uint (rp_gen_seed);
6266 logfile_top_uint (runtime);
6267 logfile_top_uint (segment_size);
6268 logfile_top_uint (show);
6269 logfile_top_uint (status);
6270 logfile_top_uint (status_automat);
6271 logfile_top_uint (status_timer);
6272 logfile_top_uint (usage);
6273 logfile_top_uint (username);
6274 logfile_top_uint (version);
6275 logfile_top_uint (weak_hash_threshold);
6276 logfile_top_uint (workload_profile);
6277 logfile_top_uint64 (limit);
6278 logfile_top_uint64 (skip);
6279 logfile_top_char (separator);
6280 logfile_top_string (cpu_affinity);
6281 logfile_top_string (custom_charset_1);
6282 logfile_top_string (custom_charset_2);
6283 logfile_top_string (custom_charset_3);
6284 logfile_top_string (custom_charset_4);
6285 logfile_top_string (debug_file);
6286 logfile_top_string (gpu_devices);
6287 logfile_top_string (induction_dir);
6288 logfile_top_string (markov_hcstat);
6289 logfile_top_string (outfile);
6290 logfile_top_string (outfile_check_dir);
6291 logfile_top_string (rule_buf_l);
6292 logfile_top_string (rule_buf_r);
6293 logfile_top_string (session);
6294 logfile_top_string (truecrypt_keyfiles);
6295
6296 /**
6297 * devices
6298 */
6299
6300 uint gpu_devicemask = devices_to_devicemask (gpu_devices);
6301
6302 /**
6303 * benchmark
6304 */
6305
6306 if (benchmark == 1)
6307 {
6308 /**
6309 * disable useless stuff for benchmark
6310 */
6311
6312 restore_timer = 0;
6313 status_timer = 0;
6314 restore_disable = 1;
6315 potfile_disable = 1;
6316 weak_hash_threshold = 0;
6317
6318 data.restore_timer = restore_timer;
6319 data.status_timer = status_timer;
6320 data.restore_disable = restore_disable;
6321
6322 if (benchmark_mode == 1)
6323 {
6324 markov_disable = 1;
6325 }
6326
6327 /**
6328 * force attack mode to be bruteforce
6329 */
6330
6331 attack_mode = ATTACK_MODE_BF;
6332 attack_kern = ATTACK_KERN_BF;
6333
6334 if (runtime_chgd == 0)
6335 {
6336 runtime = 4;
6337
6338 if (benchmark_mode == 1) runtime = 17;
6339
6340 data.runtime = runtime;
6341 }
6342 }
6343
6344 /**
6345 * config
6346 */
6347
6348 uint hash_type = 0;
6349 uint salt_type = 0;
6350 uint attack_exec = 0;
6351 uint opts_type = 0;
6352 uint kern_type = 0;
6353 uint dgst_size = 0;
6354 uint esalt_size = 0;
6355 uint opti_type = 0;
6356 uint dgst_pos0 = -1;
6357 uint dgst_pos1 = -1;
6358 uint dgst_pos2 = -1;
6359 uint dgst_pos3 = -1;
6360
6361 int (*parse_func) (char *, uint, hash_t *);
6362 int (*sort_by_digest) (const void *, const void *);
6363
6364 uint algorithm_pos = 0;
6365 uint algorithm_max = 1;
6366
6367 uint *algorithms = default_benchmark_algorithms;
6368
6369 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6370
6371 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6372 {
6373 /*
6374 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6375 * the following algos are skipped entirely
6376 */
6377
6378 if (algorithm_pos > 0)
6379 {
6380 local_free (rd);
6381
6382 rd = init_restore (argc, argv);
6383
6384 data.rd = rd;
6385 }
6386
6387 /**
6388 * update hash_mode in case of multihash benchmark
6389 */
6390
6391 if (benchmark == 1)
6392 {
6393 if (hash_mode_chgd == 0)
6394 {
6395 hash_mode = algorithms[algorithm_pos];
6396
6397 data.hash_mode = hash_mode;
6398 }
6399
6400 quiet = 1;
6401
6402 data.quiet = quiet;
6403 }
6404
6405 switch (hash_mode)
6406 {
6407 case 0: hash_type = HASH_TYPE_MD5;
6408 salt_type = SALT_TYPE_NONE;
6409 attack_exec = ATTACK_EXEC_ON_GPU;
6410 opts_type = OPTS_TYPE_PT_GENERATE_LE
6411 | OPTS_TYPE_PT_ADD80
6412 | OPTS_TYPE_PT_ADDBITS14;
6413 kern_type = KERN_TYPE_MD5;
6414 dgst_size = DGST_SIZE_4_4;
6415 parse_func = md5_parse_hash;
6416 sort_by_digest = sort_by_digest_4_4;
6417 opti_type = OPTI_TYPE_ZERO_BYTE
6418 | OPTI_TYPE_PRECOMPUTE_INIT
6419 | OPTI_TYPE_PRECOMPUTE_MERKLE
6420 | OPTI_TYPE_MEET_IN_MIDDLE
6421 | OPTI_TYPE_EARLY_SKIP
6422 | OPTI_TYPE_NOT_ITERATED
6423 | OPTI_TYPE_NOT_SALTED
6424 | OPTI_TYPE_RAW_HASH;
6425 dgst_pos0 = 0;
6426 dgst_pos1 = 3;
6427 dgst_pos2 = 2;
6428 dgst_pos3 = 1;
6429 break;
6430
6431 case 10: hash_type = HASH_TYPE_MD5;
6432 salt_type = SALT_TYPE_INTERN;
6433 attack_exec = ATTACK_EXEC_ON_GPU;
6434 opts_type = OPTS_TYPE_PT_GENERATE_LE
6435 | OPTS_TYPE_ST_ADD80
6436 | OPTS_TYPE_ST_ADDBITS14;
6437 kern_type = KERN_TYPE_MD5_PWSLT;
6438 dgst_size = DGST_SIZE_4_4;
6439 parse_func = md5s_parse_hash;
6440 sort_by_digest = sort_by_digest_4_4;
6441 opti_type = OPTI_TYPE_ZERO_BYTE
6442 | OPTI_TYPE_PRECOMPUTE_INIT
6443 | OPTI_TYPE_PRECOMPUTE_MERKLE
6444 | OPTI_TYPE_MEET_IN_MIDDLE
6445 | OPTI_TYPE_EARLY_SKIP
6446 | OPTI_TYPE_NOT_ITERATED
6447 | OPTI_TYPE_APPENDED_SALT
6448 | OPTI_TYPE_RAW_HASH;
6449 dgst_pos0 = 0;
6450 dgst_pos1 = 3;
6451 dgst_pos2 = 2;
6452 dgst_pos3 = 1;
6453 break;
6454
6455 case 11: hash_type = HASH_TYPE_MD5;
6456 salt_type = SALT_TYPE_INTERN;
6457 attack_exec = ATTACK_EXEC_ON_GPU;
6458 opts_type = OPTS_TYPE_PT_GENERATE_LE
6459 | OPTS_TYPE_ST_ADD80
6460 | OPTS_TYPE_ST_ADDBITS14;
6461 kern_type = KERN_TYPE_MD5_PWSLT;
6462 dgst_size = DGST_SIZE_4_4;
6463 parse_func = joomla_parse_hash;
6464 sort_by_digest = sort_by_digest_4_4;
6465 opti_type = OPTI_TYPE_ZERO_BYTE
6466 | OPTI_TYPE_PRECOMPUTE_INIT
6467 | OPTI_TYPE_PRECOMPUTE_MERKLE
6468 | OPTI_TYPE_MEET_IN_MIDDLE
6469 | OPTI_TYPE_EARLY_SKIP
6470 | OPTI_TYPE_NOT_ITERATED
6471 | OPTI_TYPE_APPENDED_SALT
6472 | OPTI_TYPE_RAW_HASH;
6473 dgst_pos0 = 0;
6474 dgst_pos1 = 3;
6475 dgst_pos2 = 2;
6476 dgst_pos3 = 1;
6477 break;
6478
6479 case 12: hash_type = HASH_TYPE_MD5;
6480 salt_type = SALT_TYPE_INTERN;
6481 attack_exec = ATTACK_EXEC_ON_GPU;
6482 opts_type = OPTS_TYPE_PT_GENERATE_LE
6483 | OPTS_TYPE_ST_ADD80
6484 | OPTS_TYPE_ST_ADDBITS14;
6485 kern_type = KERN_TYPE_MD5_PWSLT;
6486 dgst_size = DGST_SIZE_4_4;
6487 parse_func = postgresql_parse_hash;
6488 sort_by_digest = sort_by_digest_4_4;
6489 opti_type = OPTI_TYPE_ZERO_BYTE
6490 | OPTI_TYPE_PRECOMPUTE_INIT
6491 | OPTI_TYPE_PRECOMPUTE_MERKLE
6492 | OPTI_TYPE_MEET_IN_MIDDLE
6493 | OPTI_TYPE_EARLY_SKIP
6494 | OPTI_TYPE_NOT_ITERATED
6495 | OPTI_TYPE_APPENDED_SALT
6496 | OPTI_TYPE_RAW_HASH;
6497 dgst_pos0 = 0;
6498 dgst_pos1 = 3;
6499 dgst_pos2 = 2;
6500 dgst_pos3 = 1;
6501 break;
6502
6503 case 20: hash_type = HASH_TYPE_MD5;
6504 salt_type = SALT_TYPE_INTERN;
6505 attack_exec = ATTACK_EXEC_ON_GPU;
6506 opts_type = OPTS_TYPE_PT_GENERATE_LE
6507 | OPTS_TYPE_PT_ADD80
6508 | OPTS_TYPE_PT_ADDBITS14;
6509 kern_type = KERN_TYPE_MD5_SLTPW;
6510 dgst_size = DGST_SIZE_4_4;
6511 parse_func = md5s_parse_hash;
6512 sort_by_digest = sort_by_digest_4_4;
6513 opti_type = OPTI_TYPE_ZERO_BYTE
6514 | OPTI_TYPE_PRECOMPUTE_INIT
6515 | OPTI_TYPE_PRECOMPUTE_MERKLE
6516 | OPTI_TYPE_EARLY_SKIP
6517 | OPTI_TYPE_NOT_ITERATED
6518 | OPTI_TYPE_PREPENDED_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 21: 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_PT_ADD80
6531 | OPTS_TYPE_PT_ADDBITS14;
6532 kern_type = KERN_TYPE_MD5_SLTPW;
6533 dgst_size = DGST_SIZE_4_4;
6534 parse_func = osc_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_EARLY_SKIP
6540 | OPTI_TYPE_NOT_ITERATED
6541 | OPTI_TYPE_PREPENDED_SALT
6542 | OPTI_TYPE_RAW_HASH;
6543 dgst_pos0 = 0;
6544 dgst_pos1 = 3;
6545 dgst_pos2 = 2;
6546 dgst_pos3 = 1;
6547 break;
6548
6549 case 22: hash_type = HASH_TYPE_MD5;
6550 salt_type = SALT_TYPE_EMBEDDED;
6551 attack_exec = ATTACK_EXEC_ON_GPU;
6552 opts_type = OPTS_TYPE_PT_GENERATE_LE
6553 | OPTS_TYPE_PT_ADD80
6554 | OPTS_TYPE_PT_ADDBITS14;
6555 kern_type = KERN_TYPE_MD5_SLTPW;
6556 dgst_size = DGST_SIZE_4_4;
6557 parse_func = netscreen_parse_hash;
6558 sort_by_digest = sort_by_digest_4_4;
6559 opti_type = OPTI_TYPE_ZERO_BYTE
6560 | OPTI_TYPE_PRECOMPUTE_INIT
6561 | OPTI_TYPE_PRECOMPUTE_MERKLE
6562 | OPTI_TYPE_EARLY_SKIP
6563 | OPTI_TYPE_NOT_ITERATED
6564 | OPTI_TYPE_PREPENDED_SALT
6565 | OPTI_TYPE_RAW_HASH;
6566 dgst_pos0 = 0;
6567 dgst_pos1 = 3;
6568 dgst_pos2 = 2;
6569 dgst_pos3 = 1;
6570 break;
6571
6572 case 23: hash_type = HASH_TYPE_MD5;
6573 salt_type = SALT_TYPE_EMBEDDED;
6574 attack_exec = ATTACK_EXEC_ON_GPU;
6575 opts_type = OPTS_TYPE_PT_GENERATE_LE
6576 | OPTS_TYPE_PT_ADD80
6577 | OPTS_TYPE_PT_ADDBITS14;
6578 kern_type = KERN_TYPE_MD5_SLTPW;
6579 dgst_size = DGST_SIZE_4_4;
6580 parse_func = skype_parse_hash;
6581 sort_by_digest = sort_by_digest_4_4;
6582 opti_type = OPTI_TYPE_ZERO_BYTE
6583 | OPTI_TYPE_PRECOMPUTE_INIT
6584 | OPTI_TYPE_PRECOMPUTE_MERKLE
6585 | OPTI_TYPE_EARLY_SKIP
6586 | OPTI_TYPE_NOT_ITERATED
6587 | OPTI_TYPE_PREPENDED_SALT
6588 | OPTI_TYPE_RAW_HASH;
6589 dgst_pos0 = 0;
6590 dgst_pos1 = 3;
6591 dgst_pos2 = 2;
6592 dgst_pos3 = 1;
6593 break;
6594
6595 case 30: hash_type = HASH_TYPE_MD5;
6596 salt_type = SALT_TYPE_INTERN;
6597 attack_exec = ATTACK_EXEC_ON_GPU;
6598 opts_type = OPTS_TYPE_PT_GENERATE_LE
6599 | OPTS_TYPE_PT_UNICODE
6600 | OPTS_TYPE_ST_ADD80
6601 | OPTS_TYPE_ST_ADDBITS14;
6602 kern_type = KERN_TYPE_MD5_PWUSLT;
6603 dgst_size = DGST_SIZE_4_4;
6604 parse_func = md5s_parse_hash;
6605 sort_by_digest = sort_by_digest_4_4;
6606 opti_type = OPTI_TYPE_ZERO_BYTE
6607 | OPTI_TYPE_PRECOMPUTE_INIT
6608 | OPTI_TYPE_PRECOMPUTE_MERKLE
6609 | OPTI_TYPE_MEET_IN_MIDDLE
6610 | OPTI_TYPE_EARLY_SKIP
6611 | OPTI_TYPE_NOT_ITERATED
6612 | OPTI_TYPE_APPENDED_SALT
6613 | OPTI_TYPE_RAW_HASH;
6614 dgst_pos0 = 0;
6615 dgst_pos1 = 3;
6616 dgst_pos2 = 2;
6617 dgst_pos3 = 1;
6618 break;
6619
6620 case 40: hash_type = HASH_TYPE_MD5;
6621 salt_type = SALT_TYPE_INTERN;
6622 attack_exec = ATTACK_EXEC_ON_GPU;
6623 opts_type = OPTS_TYPE_PT_GENERATE_LE
6624 | OPTS_TYPE_PT_ADD80
6625 | OPTS_TYPE_PT_ADDBITS14
6626 | OPTS_TYPE_PT_UNICODE;
6627 kern_type = KERN_TYPE_MD5_SLTPWU;
6628 dgst_size = DGST_SIZE_4_4;
6629 parse_func = md5s_parse_hash;
6630 sort_by_digest = sort_by_digest_4_4;
6631 opti_type = OPTI_TYPE_ZERO_BYTE
6632 | OPTI_TYPE_PRECOMPUTE_INIT
6633 | OPTI_TYPE_PRECOMPUTE_MERKLE
6634 | OPTI_TYPE_EARLY_SKIP
6635 | OPTI_TYPE_NOT_ITERATED
6636 | OPTI_TYPE_PREPENDED_SALT
6637 | OPTI_TYPE_RAW_HASH;
6638 dgst_pos0 = 0;
6639 dgst_pos1 = 3;
6640 dgst_pos2 = 2;
6641 dgst_pos3 = 1;
6642 break;
6643
6644 case 50: hash_type = HASH_TYPE_MD5;
6645 salt_type = SALT_TYPE_INTERN;
6646 attack_exec = ATTACK_EXEC_ON_GPU;
6647 opts_type = OPTS_TYPE_PT_GENERATE_LE
6648 | OPTS_TYPE_ST_ADD80
6649 | OPTS_TYPE_ST_ADDBITS14;
6650 kern_type = KERN_TYPE_HMACMD5_PW;
6651 dgst_size = DGST_SIZE_4_4;
6652 parse_func = hmacmd5_parse_hash;
6653 sort_by_digest = sort_by_digest_4_4;
6654 opti_type = OPTI_TYPE_ZERO_BYTE
6655 | OPTI_TYPE_NOT_ITERATED;
6656 dgst_pos0 = 0;
6657 dgst_pos1 = 3;
6658 dgst_pos2 = 2;
6659 dgst_pos3 = 1;
6660 break;
6661
6662 case 60: hash_type = HASH_TYPE_MD5;
6663 salt_type = SALT_TYPE_INTERN;
6664 attack_exec = ATTACK_EXEC_ON_GPU;
6665 opts_type = OPTS_TYPE_PT_GENERATE_LE
6666 | OPTS_TYPE_PT_ADD80
6667 | OPTS_TYPE_PT_ADDBITS14;
6668 kern_type = KERN_TYPE_HMACMD5_SLT;
6669 dgst_size = DGST_SIZE_4_4;
6670 parse_func = hmacmd5_parse_hash;
6671 sort_by_digest = sort_by_digest_4_4;
6672 opti_type = OPTI_TYPE_ZERO_BYTE
6673 | OPTI_TYPE_NOT_ITERATED;
6674 dgst_pos0 = 0;
6675 dgst_pos1 = 3;
6676 dgst_pos2 = 2;
6677 dgst_pos3 = 1;
6678 break;
6679
6680 case 100: hash_type = HASH_TYPE_SHA1;
6681 salt_type = SALT_TYPE_NONE;
6682 attack_exec = ATTACK_EXEC_ON_GPU;
6683 opts_type = OPTS_TYPE_PT_GENERATE_BE
6684 | OPTS_TYPE_PT_ADD80
6685 | OPTS_TYPE_PT_ADDBITS15;
6686 kern_type = KERN_TYPE_SHA1;
6687 dgst_size = DGST_SIZE_4_5;
6688 parse_func = sha1_parse_hash;
6689 sort_by_digest = sort_by_digest_4_5;
6690 opti_type = OPTI_TYPE_ZERO_BYTE
6691 | OPTI_TYPE_PRECOMPUTE_INIT
6692 | OPTI_TYPE_PRECOMPUTE_MERKLE
6693 | OPTI_TYPE_EARLY_SKIP
6694 | OPTI_TYPE_NOT_ITERATED
6695 | OPTI_TYPE_NOT_SALTED
6696 | OPTI_TYPE_RAW_HASH;
6697 dgst_pos0 = 3;
6698 dgst_pos1 = 4;
6699 dgst_pos2 = 2;
6700 dgst_pos3 = 1;
6701 break;
6702
6703 case 101: hash_type = HASH_TYPE_SHA1;
6704 salt_type = SALT_TYPE_NONE;
6705 attack_exec = ATTACK_EXEC_ON_GPU;
6706 opts_type = OPTS_TYPE_PT_GENERATE_BE
6707 | OPTS_TYPE_PT_ADD80
6708 | OPTS_TYPE_PT_ADDBITS15;
6709 kern_type = KERN_TYPE_SHA1;
6710 dgst_size = DGST_SIZE_4_5;
6711 parse_func = sha1b64_parse_hash;
6712 sort_by_digest = sort_by_digest_4_5;
6713 opti_type = OPTI_TYPE_ZERO_BYTE
6714 | OPTI_TYPE_PRECOMPUTE_INIT
6715 | OPTI_TYPE_PRECOMPUTE_MERKLE
6716 | OPTI_TYPE_EARLY_SKIP
6717 | OPTI_TYPE_NOT_ITERATED
6718 | OPTI_TYPE_NOT_SALTED
6719 | OPTI_TYPE_RAW_HASH;
6720 dgst_pos0 = 3;
6721 dgst_pos1 = 4;
6722 dgst_pos2 = 2;
6723 dgst_pos3 = 1;
6724 break;
6725
6726 case 110: hash_type = HASH_TYPE_SHA1;
6727 salt_type = SALT_TYPE_INTERN;
6728 attack_exec = ATTACK_EXEC_ON_GPU;
6729 opts_type = OPTS_TYPE_PT_GENERATE_BE
6730 | OPTS_TYPE_ST_ADD80
6731 | OPTS_TYPE_ST_ADDBITS15;
6732 kern_type = KERN_TYPE_SHA1_PWSLT;
6733 dgst_size = DGST_SIZE_4_5;
6734 parse_func = sha1s_parse_hash;
6735 sort_by_digest = sort_by_digest_4_5;
6736 opti_type = OPTI_TYPE_ZERO_BYTE
6737 | OPTI_TYPE_PRECOMPUTE_INIT
6738 | OPTI_TYPE_PRECOMPUTE_MERKLE
6739 | OPTI_TYPE_EARLY_SKIP
6740 | OPTI_TYPE_NOT_ITERATED
6741 | OPTI_TYPE_APPENDED_SALT
6742 | OPTI_TYPE_RAW_HASH;
6743 dgst_pos0 = 3;
6744 dgst_pos1 = 4;
6745 dgst_pos2 = 2;
6746 dgst_pos3 = 1;
6747 break;
6748
6749 case 111: hash_type = HASH_TYPE_SHA1;
6750 salt_type = SALT_TYPE_EMBEDDED;
6751 attack_exec = ATTACK_EXEC_ON_GPU;
6752 opts_type = OPTS_TYPE_PT_GENERATE_BE
6753 | OPTS_TYPE_ST_ADD80
6754 | OPTS_TYPE_ST_ADDBITS15;
6755 kern_type = KERN_TYPE_SHA1_PWSLT;
6756 dgst_size = DGST_SIZE_4_5;
6757 parse_func = sha1b64s_parse_hash;
6758 sort_by_digest = sort_by_digest_4_5;
6759 opti_type = OPTI_TYPE_ZERO_BYTE
6760 | OPTI_TYPE_PRECOMPUTE_INIT
6761 | OPTI_TYPE_PRECOMPUTE_MERKLE
6762 | OPTI_TYPE_EARLY_SKIP
6763 | OPTI_TYPE_NOT_ITERATED
6764 | OPTI_TYPE_APPENDED_SALT
6765 | OPTI_TYPE_RAW_HASH;
6766 dgst_pos0 = 3;
6767 dgst_pos1 = 4;
6768 dgst_pos2 = 2;
6769 dgst_pos3 = 1;
6770 break;
6771
6772 case 112: hash_type = HASH_TYPE_SHA1;
6773 salt_type = SALT_TYPE_INTERN;
6774 attack_exec = ATTACK_EXEC_ON_GPU;
6775 opts_type = OPTS_TYPE_PT_GENERATE_BE
6776 | OPTS_TYPE_ST_ADD80
6777 | OPTS_TYPE_ST_ADDBITS15
6778 | OPTS_TYPE_ST_HEX;
6779 kern_type = KERN_TYPE_SHA1_PWSLT;
6780 dgst_size = DGST_SIZE_4_5;
6781 parse_func = oracles_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 120: hash_type = HASH_TYPE_SHA1;
6797 salt_type = SALT_TYPE_INTERN;
6798 attack_exec = ATTACK_EXEC_ON_GPU;
6799 opts_type = OPTS_TYPE_PT_GENERATE_BE
6800 | OPTS_TYPE_PT_ADD80
6801 | OPTS_TYPE_PT_ADDBITS15;
6802 kern_type = KERN_TYPE_SHA1_SLTPW;
6803 dgst_size = DGST_SIZE_4_5;
6804 parse_func = sha1s_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_PREPENDED_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 121: 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_PT_ADD80
6824 | OPTS_TYPE_PT_ADDBITS15
6825 | OPTS_TYPE_ST_LOWER;
6826 kern_type = KERN_TYPE_SHA1_SLTPW;
6827 dgst_size = DGST_SIZE_4_5;
6828 parse_func = smf_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_PREPENDED_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 122: hash_type = HASH_TYPE_SHA1;
6844 salt_type = SALT_TYPE_EMBEDDED;
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 | OPTS_TYPE_ST_HEX;
6850 kern_type = KERN_TYPE_SHA1_SLTPW;
6851 dgst_size = DGST_SIZE_4_5;
6852 parse_func = osx1_parse_hash;
6853 sort_by_digest = sort_by_digest_4_5;
6854 opti_type = OPTI_TYPE_ZERO_BYTE
6855 | OPTI_TYPE_PRECOMPUTE_INIT
6856 | OPTI_TYPE_PRECOMPUTE_MERKLE
6857 | OPTI_TYPE_EARLY_SKIP
6858 | OPTI_TYPE_NOT_ITERATED
6859 | OPTI_TYPE_PREPENDED_SALT
6860 | OPTI_TYPE_RAW_HASH;
6861 dgst_pos0 = 3;
6862 dgst_pos1 = 4;
6863 dgst_pos2 = 2;
6864 dgst_pos3 = 1;
6865 break;
6866
6867 case 124: hash_type = HASH_TYPE_SHA1;
6868 salt_type = SALT_TYPE_EMBEDDED;
6869 attack_exec = ATTACK_EXEC_ON_GPU;
6870 opts_type = OPTS_TYPE_PT_GENERATE_BE
6871 | OPTS_TYPE_PT_ADD80
6872 | OPTS_TYPE_PT_ADDBITS15;
6873 kern_type = KERN_TYPE_SHA1_SLTPW;
6874 dgst_size = DGST_SIZE_4_5;
6875 parse_func = djangosha1_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 130: hash_type = HASH_TYPE_SHA1;
6891 salt_type = SALT_TYPE_INTERN;
6892 attack_exec = ATTACK_EXEC_ON_GPU;
6893 opts_type = OPTS_TYPE_PT_GENERATE_BE
6894 | OPTS_TYPE_PT_UNICODE
6895 | OPTS_TYPE_ST_ADD80
6896 | OPTS_TYPE_ST_ADDBITS15;
6897 kern_type = KERN_TYPE_SHA1_PWUSLT;
6898 dgst_size = DGST_SIZE_4_5;
6899 parse_func = sha1s_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_APPENDED_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 131: 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_UNICODE
6919 | OPTS_TYPE_PT_UPPER
6920 | OPTS_TYPE_ST_ADD80
6921 | OPTS_TYPE_ST_ADDBITS15
6922 | OPTS_TYPE_ST_HEX;
6923 kern_type = KERN_TYPE_SHA1_PWUSLT;
6924 dgst_size = DGST_SIZE_4_5;
6925 parse_func = mssql2000_parse_hash;
6926 sort_by_digest = sort_by_digest_4_5;
6927 opti_type = OPTI_TYPE_ZERO_BYTE
6928 | OPTI_TYPE_PRECOMPUTE_INIT
6929 | OPTI_TYPE_PRECOMPUTE_MERKLE
6930 | OPTI_TYPE_EARLY_SKIP
6931 | OPTI_TYPE_NOT_ITERATED
6932 | OPTI_TYPE_APPENDED_SALT
6933 | OPTI_TYPE_RAW_HASH;
6934 dgst_pos0 = 3;
6935 dgst_pos1 = 4;
6936 dgst_pos2 = 2;
6937 dgst_pos3 = 1;
6938 break;
6939
6940 case 132: hash_type = HASH_TYPE_SHA1;
6941 salt_type = SALT_TYPE_EMBEDDED;
6942 attack_exec = ATTACK_EXEC_ON_GPU;
6943 opts_type = OPTS_TYPE_PT_GENERATE_BE
6944 | OPTS_TYPE_PT_UNICODE
6945 | OPTS_TYPE_ST_ADD80
6946 | OPTS_TYPE_ST_ADDBITS15
6947 | OPTS_TYPE_ST_HEX;
6948 kern_type = KERN_TYPE_SHA1_PWUSLT;
6949 dgst_size = DGST_SIZE_4_5;
6950 parse_func = mssql2005_parse_hash;
6951 sort_by_digest = sort_by_digest_4_5;
6952 opti_type = OPTI_TYPE_ZERO_BYTE
6953 | OPTI_TYPE_PRECOMPUTE_INIT
6954 | OPTI_TYPE_PRECOMPUTE_MERKLE
6955 | OPTI_TYPE_EARLY_SKIP
6956 | OPTI_TYPE_NOT_ITERATED
6957 | OPTI_TYPE_APPENDED_SALT
6958 | OPTI_TYPE_RAW_HASH;
6959 dgst_pos0 = 3;
6960 dgst_pos1 = 4;
6961 dgst_pos2 = 2;
6962 dgst_pos3 = 1;
6963 break;
6964
6965 case 133: hash_type = HASH_TYPE_SHA1;
6966 salt_type = SALT_TYPE_EMBEDDED;
6967 attack_exec = ATTACK_EXEC_ON_GPU;
6968 opts_type = OPTS_TYPE_PT_GENERATE_BE
6969 | OPTS_TYPE_PT_UNICODE
6970 | OPTS_TYPE_ST_ADD80
6971 | OPTS_TYPE_ST_ADDBITS15;
6972 kern_type = KERN_TYPE_SHA1_PWUSLT;
6973 dgst_size = DGST_SIZE_4_5;
6974 parse_func = peoplesoft_parse_hash;
6975 sort_by_digest = sort_by_digest_4_5;
6976 opti_type = OPTI_TYPE_ZERO_BYTE
6977 | OPTI_TYPE_PRECOMPUTE_INIT
6978 | OPTI_TYPE_PRECOMPUTE_MERKLE
6979 | OPTI_TYPE_EARLY_SKIP
6980 | OPTI_TYPE_NOT_ITERATED
6981 | OPTI_TYPE_APPENDED_SALT
6982 | OPTI_TYPE_RAW_HASH;
6983 dgst_pos0 = 3;
6984 dgst_pos1 = 4;
6985 dgst_pos2 = 2;
6986 dgst_pos3 = 1;
6987 break;
6988
6989 case 140: hash_type = HASH_TYPE_SHA1;
6990 salt_type = SALT_TYPE_INTERN;
6991 attack_exec = ATTACK_EXEC_ON_GPU;
6992 opts_type = OPTS_TYPE_PT_GENERATE_BE
6993 | OPTS_TYPE_PT_ADD80
6994 | OPTS_TYPE_PT_ADDBITS15
6995 | OPTS_TYPE_PT_UNICODE;
6996 kern_type = KERN_TYPE_SHA1_SLTPWU;
6997 dgst_size = DGST_SIZE_4_5;
6998 parse_func = sha1s_parse_hash;
6999 sort_by_digest = sort_by_digest_4_5;
7000 opti_type = OPTI_TYPE_ZERO_BYTE
7001 | OPTI_TYPE_PRECOMPUTE_INIT
7002 | OPTI_TYPE_PRECOMPUTE_MERKLE
7003 | OPTI_TYPE_EARLY_SKIP
7004 | OPTI_TYPE_NOT_ITERATED
7005 | OPTI_TYPE_PREPENDED_SALT
7006 | OPTI_TYPE_RAW_HASH;
7007 dgst_pos0 = 3;
7008 dgst_pos1 = 4;
7009 dgst_pos2 = 2;
7010 dgst_pos3 = 1;
7011 break;
7012
7013 case 141: hash_type = HASH_TYPE_SHA1;
7014 salt_type = SALT_TYPE_EMBEDDED;
7015 attack_exec = ATTACK_EXEC_ON_GPU;
7016 opts_type = OPTS_TYPE_PT_GENERATE_BE
7017 | OPTS_TYPE_PT_ADD80
7018 | OPTS_TYPE_PT_ADDBITS15
7019 | OPTS_TYPE_PT_UNICODE
7020 | OPTS_TYPE_ST_BASE64;
7021 kern_type = KERN_TYPE_SHA1_SLTPWU;
7022 dgst_size = DGST_SIZE_4_5;
7023 parse_func = episerver_parse_hash;
7024 sort_by_digest = sort_by_digest_4_5;
7025 opti_type = OPTI_TYPE_ZERO_BYTE
7026 | OPTI_TYPE_PRECOMPUTE_INIT
7027 | OPTI_TYPE_PRECOMPUTE_MERKLE
7028 | OPTI_TYPE_EARLY_SKIP
7029 | OPTI_TYPE_NOT_ITERATED
7030 | OPTI_TYPE_PREPENDED_SALT
7031 | OPTI_TYPE_RAW_HASH;
7032 dgst_pos0 = 3;
7033 dgst_pos1 = 4;
7034 dgst_pos2 = 2;
7035 dgst_pos3 = 1;
7036 break;
7037
7038 case 150: hash_type = HASH_TYPE_SHA1;
7039 salt_type = SALT_TYPE_INTERN;
7040 attack_exec = ATTACK_EXEC_ON_GPU;
7041 opts_type = OPTS_TYPE_PT_GENERATE_BE
7042 | OPTS_TYPE_ST_ADD80
7043 | OPTS_TYPE_ST_ADDBITS15;
7044 kern_type = KERN_TYPE_HMACSHA1_PW;
7045 dgst_size = DGST_SIZE_4_5;
7046 parse_func = hmacsha1_parse_hash;
7047 sort_by_digest = sort_by_digest_4_5;
7048 opti_type = OPTI_TYPE_ZERO_BYTE
7049 | OPTI_TYPE_NOT_ITERATED;
7050 dgst_pos0 = 3;
7051 dgst_pos1 = 4;
7052 dgst_pos2 = 2;
7053 dgst_pos3 = 1;
7054 break;
7055
7056 case 160: hash_type = HASH_TYPE_SHA1;
7057 salt_type = SALT_TYPE_INTERN;
7058 attack_exec = ATTACK_EXEC_ON_GPU;
7059 opts_type = OPTS_TYPE_PT_GENERATE_BE
7060 | OPTS_TYPE_PT_ADD80
7061 | OPTS_TYPE_PT_ADDBITS15;
7062 kern_type = KERN_TYPE_HMACSHA1_SLT;
7063 dgst_size = DGST_SIZE_4_5;
7064 parse_func = hmacsha1_parse_hash;
7065 sort_by_digest = sort_by_digest_4_5;
7066 opti_type = OPTI_TYPE_ZERO_BYTE
7067 | OPTI_TYPE_NOT_ITERATED;
7068 dgst_pos0 = 3;
7069 dgst_pos1 = 4;
7070 dgst_pos2 = 2;
7071 dgst_pos3 = 1;
7072 break;
7073
7074 case 190: hash_type = HASH_TYPE_SHA1;
7075 salt_type = SALT_TYPE_NONE;
7076 attack_exec = ATTACK_EXEC_ON_GPU;
7077 opts_type = OPTS_TYPE_PT_GENERATE_BE
7078 | OPTS_TYPE_PT_ADD80
7079 | OPTS_TYPE_PT_ADDBITS15;
7080 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7081 dgst_size = DGST_SIZE_4_5;
7082 parse_func = sha1linkedin_parse_hash;
7083 sort_by_digest = sort_by_digest_4_5;
7084 opti_type = OPTI_TYPE_ZERO_BYTE
7085 | OPTI_TYPE_PRECOMPUTE_INIT
7086 | OPTI_TYPE_EARLY_SKIP
7087 | OPTI_TYPE_NOT_ITERATED
7088 | OPTI_TYPE_NOT_SALTED;
7089 dgst_pos0 = 0;
7090 dgst_pos1 = 4;
7091 dgst_pos2 = 3;
7092 dgst_pos3 = 2;
7093 break;
7094
7095 case 200: hash_type = HASH_TYPE_MYSQL;
7096 salt_type = SALT_TYPE_NONE;
7097 attack_exec = ATTACK_EXEC_ON_GPU;
7098 opts_type = 0;
7099 kern_type = KERN_TYPE_MYSQL;
7100 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7101 parse_func = mysql323_parse_hash;
7102 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7103 opti_type = OPTI_TYPE_ZERO_BYTE;
7104 dgst_pos0 = 0;
7105 dgst_pos1 = 1;
7106 dgst_pos2 = 2;
7107 dgst_pos3 = 3;
7108 break;
7109
7110 case 300: hash_type = HASH_TYPE_SHA1;
7111 salt_type = SALT_TYPE_NONE;
7112 attack_exec = ATTACK_EXEC_ON_GPU;
7113 opts_type = OPTS_TYPE_PT_GENERATE_BE
7114 | OPTS_TYPE_PT_ADD80
7115 | OPTS_TYPE_PT_ADDBITS15;
7116 kern_type = KERN_TYPE_MYSQL41;
7117 dgst_size = DGST_SIZE_4_5;
7118 parse_func = sha1_parse_hash;
7119 sort_by_digest = sort_by_digest_4_5;
7120 opti_type = OPTI_TYPE_ZERO_BYTE
7121 | OPTI_TYPE_PRECOMPUTE_INIT
7122 | OPTI_TYPE_PRECOMPUTE_MERKLE
7123 | OPTI_TYPE_EARLY_SKIP
7124 | OPTI_TYPE_NOT_ITERATED
7125 | OPTI_TYPE_NOT_SALTED;
7126 dgst_pos0 = 3;
7127 dgst_pos1 = 4;
7128 dgst_pos2 = 2;
7129 dgst_pos3 = 1;
7130 break;
7131
7132 case 400: hash_type = HASH_TYPE_MD5;
7133 salt_type = SALT_TYPE_EMBEDDED;
7134 attack_exec = ATTACK_EXEC_ON_CPU;
7135 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7136 kern_type = KERN_TYPE_PHPASS;
7137 dgst_size = DGST_SIZE_4_4;
7138 parse_func = phpass_parse_hash;
7139 sort_by_digest = sort_by_digest_4_4;
7140 opti_type = OPTI_TYPE_ZERO_BYTE;
7141 dgst_pos0 = 0;
7142 dgst_pos1 = 1;
7143 dgst_pos2 = 2;
7144 dgst_pos3 = 3;
7145 break;
7146
7147 case 500: hash_type = HASH_TYPE_MD5;
7148 salt_type = SALT_TYPE_EMBEDDED;
7149 attack_exec = ATTACK_EXEC_ON_CPU;
7150 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7151 kern_type = KERN_TYPE_MD5CRYPT;
7152 dgst_size = DGST_SIZE_4_4;
7153 parse_func = md5crypt_parse_hash;
7154 sort_by_digest = sort_by_digest_4_4;
7155 opti_type = OPTI_TYPE_ZERO_BYTE;
7156 dgst_pos0 = 0;
7157 dgst_pos1 = 1;
7158 dgst_pos2 = 2;
7159 dgst_pos3 = 3;
7160 break;
7161
7162 case 501: hash_type = HASH_TYPE_MD5;
7163 salt_type = SALT_TYPE_EMBEDDED;
7164 attack_exec = ATTACK_EXEC_ON_CPU;
7165 opts_type = OPTS_TYPE_PT_GENERATE_LE
7166 | OPTS_TYPE_HASH_COPY;
7167 kern_type = KERN_TYPE_MD5CRYPT;
7168 dgst_size = DGST_SIZE_4_4;
7169 parse_func = juniper_parse_hash;
7170 sort_by_digest = sort_by_digest_4_4;
7171 opti_type = OPTI_TYPE_ZERO_BYTE;
7172 dgst_pos0 = 0;
7173 dgst_pos1 = 1;
7174 dgst_pos2 = 2;
7175 dgst_pos3 = 3;
7176 break;
7177
7178 case 900: hash_type = HASH_TYPE_MD4;
7179 salt_type = SALT_TYPE_NONE;
7180 attack_exec = ATTACK_EXEC_ON_GPU;
7181 opts_type = OPTS_TYPE_PT_GENERATE_LE
7182 | OPTS_TYPE_PT_ADD80
7183 | OPTS_TYPE_PT_ADDBITS14;
7184 kern_type = KERN_TYPE_MD4;
7185 dgst_size = DGST_SIZE_4_4;
7186 parse_func = md4_parse_hash;
7187 sort_by_digest = sort_by_digest_4_4;
7188 opti_type = OPTI_TYPE_ZERO_BYTE
7189 | OPTI_TYPE_PRECOMPUTE_INIT
7190 | OPTI_TYPE_PRECOMPUTE_MERKLE
7191 | OPTI_TYPE_MEET_IN_MIDDLE
7192 | OPTI_TYPE_EARLY_SKIP
7193 | OPTI_TYPE_NOT_ITERATED
7194 | OPTI_TYPE_NOT_SALTED
7195 | OPTI_TYPE_RAW_HASH;
7196 dgst_pos0 = 0;
7197 dgst_pos1 = 3;
7198 dgst_pos2 = 2;
7199 dgst_pos3 = 1;
7200 break;
7201
7202 case 1000: hash_type = HASH_TYPE_MD4;
7203 salt_type = SALT_TYPE_NONE;
7204 attack_exec = ATTACK_EXEC_ON_GPU;
7205 opts_type = OPTS_TYPE_PT_GENERATE_LE
7206 | OPTS_TYPE_PT_ADD80
7207 | OPTS_TYPE_PT_ADDBITS14
7208 | OPTS_TYPE_PT_UNICODE;
7209 kern_type = KERN_TYPE_MD4_PWU;
7210 dgst_size = DGST_SIZE_4_4;
7211 parse_func = md4_parse_hash;
7212 sort_by_digest = sort_by_digest_4_4;
7213 opti_type = OPTI_TYPE_ZERO_BYTE
7214 | OPTI_TYPE_PRECOMPUTE_INIT
7215 | OPTI_TYPE_PRECOMPUTE_MERKLE
7216 | OPTI_TYPE_MEET_IN_MIDDLE
7217 | OPTI_TYPE_EARLY_SKIP
7218 | OPTI_TYPE_NOT_ITERATED
7219 | OPTI_TYPE_NOT_SALTED
7220 | OPTI_TYPE_RAW_HASH;
7221 dgst_pos0 = 0;
7222 dgst_pos1 = 3;
7223 dgst_pos2 = 2;
7224 dgst_pos3 = 1;
7225 break;
7226
7227 case 1100: hash_type = HASH_TYPE_MD4;
7228 salt_type = SALT_TYPE_INTERN;
7229 attack_exec = ATTACK_EXEC_ON_GPU;
7230 opts_type = OPTS_TYPE_PT_GENERATE_LE
7231 | OPTS_TYPE_PT_ADD80
7232 | OPTS_TYPE_PT_ADDBITS14
7233 | OPTS_TYPE_PT_UNICODE
7234 | OPTS_TYPE_ST_ADD80
7235 | OPTS_TYPE_ST_UNICODE
7236 | OPTS_TYPE_ST_LOWER;
7237 kern_type = KERN_TYPE_MD44_PWUSLT;
7238 dgst_size = DGST_SIZE_4_4;
7239 parse_func = dcc_parse_hash;
7240 sort_by_digest = sort_by_digest_4_4;
7241 opti_type = OPTI_TYPE_ZERO_BYTE
7242 | OPTI_TYPE_PRECOMPUTE_INIT
7243 | OPTI_TYPE_PRECOMPUTE_MERKLE
7244 | OPTI_TYPE_EARLY_SKIP
7245 | OPTI_TYPE_NOT_ITERATED;
7246 dgst_pos0 = 0;
7247 dgst_pos1 = 3;
7248 dgst_pos2 = 2;
7249 dgst_pos3 = 1;
7250 break;
7251
7252 case 1400: hash_type = HASH_TYPE_SHA256;
7253 salt_type = SALT_TYPE_NONE;
7254 attack_exec = ATTACK_EXEC_ON_GPU;
7255 opts_type = OPTS_TYPE_PT_GENERATE_BE
7256 | OPTS_TYPE_PT_ADD80
7257 | OPTS_TYPE_PT_ADDBITS15;
7258 kern_type = KERN_TYPE_SHA256;
7259 dgst_size = DGST_SIZE_4_8;
7260 parse_func = sha256_parse_hash;
7261 sort_by_digest = sort_by_digest_4_8;
7262 opti_type = OPTI_TYPE_ZERO_BYTE
7263 | OPTI_TYPE_PRECOMPUTE_INIT
7264 | OPTI_TYPE_PRECOMPUTE_MERKLE
7265 | OPTI_TYPE_EARLY_SKIP
7266 | OPTI_TYPE_NOT_ITERATED
7267 | OPTI_TYPE_NOT_SALTED
7268 | OPTI_TYPE_RAW_HASH;
7269 dgst_pos0 = 3;
7270 dgst_pos1 = 7;
7271 dgst_pos2 = 2;
7272 dgst_pos3 = 6;
7273 break;
7274
7275 case 1410: hash_type = HASH_TYPE_SHA256;
7276 salt_type = SALT_TYPE_INTERN;
7277 attack_exec = ATTACK_EXEC_ON_GPU;
7278 opts_type = OPTS_TYPE_PT_GENERATE_BE
7279 | OPTS_TYPE_ST_ADD80
7280 | OPTS_TYPE_ST_ADDBITS15;
7281 kern_type = KERN_TYPE_SHA256_PWSLT;
7282 dgst_size = DGST_SIZE_4_8;
7283 parse_func = sha256s_parse_hash;
7284 sort_by_digest = sort_by_digest_4_8;
7285 opti_type = OPTI_TYPE_ZERO_BYTE
7286 | OPTI_TYPE_PRECOMPUTE_INIT
7287 | OPTI_TYPE_PRECOMPUTE_MERKLE
7288 | OPTI_TYPE_EARLY_SKIP
7289 | OPTI_TYPE_NOT_ITERATED
7290 | OPTI_TYPE_APPENDED_SALT
7291 | OPTI_TYPE_RAW_HASH;
7292 dgst_pos0 = 3;
7293 dgst_pos1 = 7;
7294 dgst_pos2 = 2;
7295 dgst_pos3 = 6;
7296 break;
7297
7298 case 1420: hash_type = HASH_TYPE_SHA256;
7299 salt_type = SALT_TYPE_INTERN;
7300 attack_exec = ATTACK_EXEC_ON_GPU;
7301 opts_type = OPTS_TYPE_PT_GENERATE_BE
7302 | OPTS_TYPE_PT_ADD80
7303 | OPTS_TYPE_PT_ADDBITS15;
7304 kern_type = KERN_TYPE_SHA256_SLTPW;
7305 dgst_size = DGST_SIZE_4_8;
7306 parse_func = sha256s_parse_hash;
7307 sort_by_digest = sort_by_digest_4_8;
7308 opti_type = OPTI_TYPE_ZERO_BYTE
7309 | OPTI_TYPE_PRECOMPUTE_INIT
7310 | OPTI_TYPE_PRECOMPUTE_MERKLE
7311 | OPTI_TYPE_EARLY_SKIP
7312 | OPTI_TYPE_NOT_ITERATED
7313 | OPTI_TYPE_PREPENDED_SALT
7314 | OPTI_TYPE_RAW_HASH;
7315 dgst_pos0 = 3;
7316 dgst_pos1 = 7;
7317 dgst_pos2 = 2;
7318 dgst_pos3 = 6;
7319 break;
7320
7321 case 1421: hash_type = HASH_TYPE_SHA256;
7322 salt_type = SALT_TYPE_EMBEDDED;
7323 attack_exec = ATTACK_EXEC_ON_GPU;
7324 opts_type = OPTS_TYPE_PT_GENERATE_BE
7325 | OPTS_TYPE_PT_ADD80
7326 | OPTS_TYPE_PT_ADDBITS15;
7327 kern_type = KERN_TYPE_SHA256_SLTPW;
7328 dgst_size = DGST_SIZE_4_8;
7329 parse_func = hmailserver_parse_hash;
7330 sort_by_digest = sort_by_digest_4_8;
7331 opti_type = OPTI_TYPE_ZERO_BYTE
7332 | OPTI_TYPE_PRECOMPUTE_INIT
7333 | OPTI_TYPE_PRECOMPUTE_MERKLE
7334 | OPTI_TYPE_EARLY_SKIP
7335 | OPTI_TYPE_NOT_ITERATED
7336 | OPTI_TYPE_PREPENDED_SALT
7337 | OPTI_TYPE_RAW_HASH;
7338 dgst_pos0 = 3;
7339 dgst_pos1 = 7;
7340 dgst_pos2 = 2;
7341 dgst_pos3 = 6;
7342 break;
7343
7344 case 1430: hash_type = HASH_TYPE_SHA256;
7345 salt_type = SALT_TYPE_INTERN;
7346 attack_exec = ATTACK_EXEC_ON_GPU;
7347 opts_type = OPTS_TYPE_PT_GENERATE_BE
7348 | OPTS_TYPE_PT_UNICODE
7349 | OPTS_TYPE_ST_ADD80
7350 | OPTS_TYPE_ST_ADDBITS15;
7351 kern_type = KERN_TYPE_SHA256_PWUSLT;
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_APPENDED_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 1440: hash_type = HASH_TYPE_SHA256;
7369 salt_type = SALT_TYPE_INTERN;
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 | OPTS_TYPE_PT_UNICODE;
7375 kern_type = KERN_TYPE_SHA256_SLTPWU;
7376 dgst_size = DGST_SIZE_4_8;
7377 parse_func = sha256s_parse_hash;
7378 sort_by_digest = sort_by_digest_4_8;
7379 opti_type = OPTI_TYPE_ZERO_BYTE
7380 | OPTI_TYPE_PRECOMPUTE_INIT
7381 | OPTI_TYPE_PRECOMPUTE_MERKLE
7382 | OPTI_TYPE_EARLY_SKIP
7383 | OPTI_TYPE_NOT_ITERATED
7384 | OPTI_TYPE_PREPENDED_SALT
7385 | OPTI_TYPE_RAW_HASH;
7386 dgst_pos0 = 3;
7387 dgst_pos1 = 7;
7388 dgst_pos2 = 2;
7389 dgst_pos3 = 6;
7390 break;
7391
7392 case 1441: hash_type = HASH_TYPE_SHA256;
7393 salt_type = SALT_TYPE_EMBEDDED;
7394 attack_exec = ATTACK_EXEC_ON_GPU;
7395 opts_type = OPTS_TYPE_PT_GENERATE_BE
7396 | OPTS_TYPE_PT_ADD80
7397 | OPTS_TYPE_PT_ADDBITS15
7398 | OPTS_TYPE_PT_UNICODE
7399 | OPTS_TYPE_ST_BASE64;
7400 kern_type = KERN_TYPE_SHA256_SLTPWU;
7401 dgst_size = DGST_SIZE_4_8;
7402 parse_func = episerver4_parse_hash;
7403 sort_by_digest = sort_by_digest_4_8;
7404 opti_type = OPTI_TYPE_ZERO_BYTE
7405 | OPTI_TYPE_PRECOMPUTE_INIT
7406 | OPTI_TYPE_PRECOMPUTE_MERKLE
7407 | OPTI_TYPE_EARLY_SKIP
7408 | OPTI_TYPE_NOT_ITERATED
7409 | OPTI_TYPE_PREPENDED_SALT
7410 | OPTI_TYPE_RAW_HASH;
7411 dgst_pos0 = 3;
7412 dgst_pos1 = 7;
7413 dgst_pos2 = 2;
7414 dgst_pos3 = 6;
7415 break;
7416
7417 case 1450: hash_type = HASH_TYPE_SHA256;
7418 salt_type = SALT_TYPE_INTERN;
7419 attack_exec = ATTACK_EXEC_ON_GPU;
7420 opts_type = OPTS_TYPE_PT_GENERATE_BE
7421 | OPTS_TYPE_ST_ADD80;
7422 kern_type = KERN_TYPE_HMACSHA256_PW;
7423 dgst_size = DGST_SIZE_4_8;
7424 parse_func = hmacsha256_parse_hash;
7425 sort_by_digest = sort_by_digest_4_8;
7426 opti_type = OPTI_TYPE_ZERO_BYTE
7427 | OPTI_TYPE_NOT_ITERATED;
7428 dgst_pos0 = 3;
7429 dgst_pos1 = 7;
7430 dgst_pos2 = 2;
7431 dgst_pos3 = 6;
7432 break;
7433
7434 case 1460: hash_type = HASH_TYPE_SHA256;
7435 salt_type = SALT_TYPE_INTERN;
7436 attack_exec = ATTACK_EXEC_ON_GPU;
7437 opts_type = OPTS_TYPE_PT_GENERATE_BE
7438 | OPTS_TYPE_PT_ADD80
7439 | OPTS_TYPE_PT_ADDBITS15;
7440 kern_type = KERN_TYPE_HMACSHA256_SLT;
7441 dgst_size = DGST_SIZE_4_8;
7442 parse_func = hmacsha256_parse_hash;
7443 sort_by_digest = sort_by_digest_4_8;
7444 opti_type = OPTI_TYPE_ZERO_BYTE
7445 | OPTI_TYPE_NOT_ITERATED;
7446 dgst_pos0 = 3;
7447 dgst_pos1 = 7;
7448 dgst_pos2 = 2;
7449 dgst_pos3 = 6;
7450 break;
7451
7452 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7453 salt_type = SALT_TYPE_EMBEDDED;
7454 attack_exec = ATTACK_EXEC_ON_GPU;
7455 opts_type = OPTS_TYPE_PT_GENERATE_LE
7456 | OPTS_TYPE_PT_BITSLICE;
7457 kern_type = KERN_TYPE_DESCRYPT;
7458 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7459 parse_func = descrypt_parse_hash;
7460 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7461 opti_type = OPTI_TYPE_ZERO_BYTE
7462 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7463 dgst_pos0 = 0;
7464 dgst_pos1 = 1;
7465 dgst_pos2 = 2;
7466 dgst_pos3 = 3;
7467 break;
7468
7469 case 1600: hash_type = HASH_TYPE_MD5;
7470 salt_type = SALT_TYPE_EMBEDDED;
7471 attack_exec = ATTACK_EXEC_ON_CPU;
7472 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7473 kern_type = KERN_TYPE_APR1CRYPT;
7474 dgst_size = DGST_SIZE_4_4;
7475 parse_func = md5apr1_parse_hash;
7476 sort_by_digest = sort_by_digest_4_4;
7477 opti_type = OPTI_TYPE_ZERO_BYTE;
7478 dgst_pos0 = 0;
7479 dgst_pos1 = 1;
7480 dgst_pos2 = 2;
7481 dgst_pos3 = 3;
7482 break;
7483
7484 case 1700: hash_type = HASH_TYPE_SHA512;
7485 salt_type = SALT_TYPE_NONE;
7486 attack_exec = ATTACK_EXEC_ON_GPU;
7487 opts_type = OPTS_TYPE_PT_GENERATE_BE
7488 | OPTS_TYPE_PT_ADD80
7489 | OPTS_TYPE_PT_ADDBITS15;
7490 kern_type = KERN_TYPE_SHA512;
7491 dgst_size = DGST_SIZE_8_8;
7492 parse_func = sha512_parse_hash;
7493 sort_by_digest = sort_by_digest_8_8;
7494 opti_type = OPTI_TYPE_ZERO_BYTE
7495 | OPTI_TYPE_PRECOMPUTE_INIT
7496 | OPTI_TYPE_PRECOMPUTE_MERKLE
7497 | OPTI_TYPE_EARLY_SKIP
7498 | OPTI_TYPE_NOT_ITERATED
7499 | OPTI_TYPE_NOT_SALTED
7500 | OPTI_TYPE_RAW_HASH;
7501 dgst_pos0 = 14;
7502 dgst_pos1 = 15;
7503 dgst_pos2 = 6;
7504 dgst_pos3 = 7;
7505 break;
7506
7507 case 1710: hash_type = HASH_TYPE_SHA512;
7508 salt_type = SALT_TYPE_INTERN;
7509 attack_exec = ATTACK_EXEC_ON_GPU;
7510 opts_type = OPTS_TYPE_PT_GENERATE_BE
7511 | OPTS_TYPE_ST_ADD80
7512 | OPTS_TYPE_ST_ADDBITS15;
7513 kern_type = KERN_TYPE_SHA512_PWSLT;
7514 dgst_size = DGST_SIZE_8_8;
7515 parse_func = sha512s_parse_hash;
7516 sort_by_digest = sort_by_digest_8_8;
7517 opti_type = OPTI_TYPE_ZERO_BYTE
7518 | OPTI_TYPE_PRECOMPUTE_INIT
7519 | OPTI_TYPE_PRECOMPUTE_MERKLE
7520 | OPTI_TYPE_EARLY_SKIP
7521 | OPTI_TYPE_NOT_ITERATED
7522 | OPTI_TYPE_APPENDED_SALT
7523 | OPTI_TYPE_RAW_HASH;
7524 dgst_pos0 = 14;
7525 dgst_pos1 = 15;
7526 dgst_pos2 = 6;
7527 dgst_pos3 = 7;
7528 break;
7529
7530 case 1711: hash_type = HASH_TYPE_SHA512;
7531 salt_type = SALT_TYPE_EMBEDDED;
7532 attack_exec = ATTACK_EXEC_ON_GPU;
7533 opts_type = OPTS_TYPE_PT_GENERATE_BE
7534 | OPTS_TYPE_ST_ADD80
7535 | OPTS_TYPE_ST_ADDBITS15;
7536 kern_type = KERN_TYPE_SHA512_PWSLT;
7537 dgst_size = DGST_SIZE_8_8;
7538 parse_func = sha512b64s_parse_hash;
7539 sort_by_digest = sort_by_digest_8_8;
7540 opti_type = OPTI_TYPE_ZERO_BYTE
7541 | OPTI_TYPE_PRECOMPUTE_INIT
7542 | OPTI_TYPE_PRECOMPUTE_MERKLE
7543 | OPTI_TYPE_EARLY_SKIP
7544 | OPTI_TYPE_NOT_ITERATED
7545 | OPTI_TYPE_APPENDED_SALT
7546 | OPTI_TYPE_RAW_HASH;
7547 dgst_pos0 = 14;
7548 dgst_pos1 = 15;
7549 dgst_pos2 = 6;
7550 dgst_pos3 = 7;
7551 break;
7552
7553 case 1720: hash_type = HASH_TYPE_SHA512;
7554 salt_type = SALT_TYPE_INTERN;
7555 attack_exec = ATTACK_EXEC_ON_GPU;
7556 opts_type = OPTS_TYPE_PT_GENERATE_BE
7557 | OPTS_TYPE_PT_ADD80
7558 | OPTS_TYPE_PT_ADDBITS15;
7559 kern_type = KERN_TYPE_SHA512_SLTPW;
7560 dgst_size = DGST_SIZE_8_8;
7561 parse_func = sha512s_parse_hash;
7562 sort_by_digest = sort_by_digest_8_8;
7563 opti_type = OPTI_TYPE_ZERO_BYTE
7564 | OPTI_TYPE_PRECOMPUTE_INIT
7565 | OPTI_TYPE_PRECOMPUTE_MERKLE
7566 | OPTI_TYPE_EARLY_SKIP
7567 | OPTI_TYPE_NOT_ITERATED
7568 | OPTI_TYPE_PREPENDED_SALT
7569 | OPTI_TYPE_RAW_HASH;
7570 dgst_pos0 = 14;
7571 dgst_pos1 = 15;
7572 dgst_pos2 = 6;
7573 dgst_pos3 = 7;
7574 break;
7575
7576 case 1722: hash_type = HASH_TYPE_SHA512;
7577 salt_type = SALT_TYPE_EMBEDDED;
7578 attack_exec = ATTACK_EXEC_ON_GPU;
7579 opts_type = OPTS_TYPE_PT_GENERATE_BE
7580 | OPTS_TYPE_PT_ADD80
7581 | OPTS_TYPE_PT_ADDBITS15
7582 | OPTS_TYPE_ST_HEX;
7583 kern_type = KERN_TYPE_SHA512_SLTPW;
7584 dgst_size = DGST_SIZE_8_8;
7585 parse_func = osx512_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_PREPENDED_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 1730: 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_UNICODE
7605 | OPTS_TYPE_ST_ADD80
7606 | OPTS_TYPE_ST_ADDBITS15;
7607 kern_type = KERN_TYPE_SHA512_PWSLTU;
7608 dgst_size = DGST_SIZE_8_8;
7609 parse_func = sha512s_parse_hash;
7610 sort_by_digest = sort_by_digest_8_8;
7611 opti_type = OPTI_TYPE_ZERO_BYTE
7612 | OPTI_TYPE_PRECOMPUTE_INIT
7613 | OPTI_TYPE_PRECOMPUTE_MERKLE
7614 | OPTI_TYPE_EARLY_SKIP
7615 | OPTI_TYPE_NOT_ITERATED
7616 | OPTI_TYPE_APPENDED_SALT
7617 | OPTI_TYPE_RAW_HASH;
7618 dgst_pos0 = 14;
7619 dgst_pos1 = 15;
7620 dgst_pos2 = 6;
7621 dgst_pos3 = 7;
7622 break;
7623
7624 case 1731: hash_type = HASH_TYPE_SHA512;
7625 salt_type = SALT_TYPE_EMBEDDED;
7626 attack_exec = ATTACK_EXEC_ON_GPU;
7627 opts_type = OPTS_TYPE_PT_GENERATE_BE
7628 | OPTS_TYPE_PT_UNICODE
7629 | OPTS_TYPE_ST_ADD80
7630 | OPTS_TYPE_ST_ADDBITS15
7631 | OPTS_TYPE_ST_HEX;
7632 kern_type = KERN_TYPE_SHA512_PWSLTU;
7633 dgst_size = DGST_SIZE_8_8;
7634 parse_func = mssql2012_parse_hash;
7635 sort_by_digest = sort_by_digest_8_8;
7636 opti_type = OPTI_TYPE_ZERO_BYTE
7637 | OPTI_TYPE_PRECOMPUTE_INIT
7638 | OPTI_TYPE_PRECOMPUTE_MERKLE
7639 | OPTI_TYPE_EARLY_SKIP
7640 | OPTI_TYPE_NOT_ITERATED
7641 | OPTI_TYPE_APPENDED_SALT
7642 | OPTI_TYPE_RAW_HASH;
7643 dgst_pos0 = 14;
7644 dgst_pos1 = 15;
7645 dgst_pos2 = 6;
7646 dgst_pos3 = 7;
7647 break;
7648
7649 case 1740: hash_type = HASH_TYPE_SHA512;
7650 salt_type = SALT_TYPE_INTERN;
7651 attack_exec = ATTACK_EXEC_ON_GPU;
7652 opts_type = OPTS_TYPE_PT_GENERATE_BE
7653 | OPTS_TYPE_PT_ADD80
7654 | OPTS_TYPE_PT_ADDBITS15
7655 | OPTS_TYPE_PT_UNICODE;
7656 kern_type = KERN_TYPE_SHA512_SLTPWU;
7657 dgst_size = DGST_SIZE_8_8;
7658 parse_func = sha512s_parse_hash;
7659 sort_by_digest = sort_by_digest_8_8;
7660 opti_type = OPTI_TYPE_ZERO_BYTE
7661 | OPTI_TYPE_PRECOMPUTE_INIT
7662 | OPTI_TYPE_PRECOMPUTE_MERKLE
7663 | OPTI_TYPE_EARLY_SKIP
7664 | OPTI_TYPE_NOT_ITERATED
7665 | OPTI_TYPE_PREPENDED_SALT
7666 | OPTI_TYPE_RAW_HASH;
7667 dgst_pos0 = 14;
7668 dgst_pos1 = 15;
7669 dgst_pos2 = 6;
7670 dgst_pos3 = 7;
7671 break;
7672
7673 case 1750: hash_type = HASH_TYPE_SHA512;
7674 salt_type = SALT_TYPE_INTERN;
7675 attack_exec = ATTACK_EXEC_ON_GPU;
7676 opts_type = OPTS_TYPE_PT_GENERATE_BE
7677 | OPTS_TYPE_ST_ADD80;
7678 kern_type = KERN_TYPE_HMACSHA512_PW;
7679 dgst_size = DGST_SIZE_8_8;
7680 parse_func = hmacsha512_parse_hash;
7681 sort_by_digest = sort_by_digest_8_8;
7682 opti_type = OPTI_TYPE_ZERO_BYTE
7683 | OPTI_TYPE_NOT_ITERATED;
7684 dgst_pos0 = 14;
7685 dgst_pos1 = 15;
7686 dgst_pos2 = 6;
7687 dgst_pos3 = 7;
7688 break;
7689
7690 case 1760: hash_type = HASH_TYPE_SHA512;
7691 salt_type = SALT_TYPE_INTERN;
7692 attack_exec = ATTACK_EXEC_ON_GPU;
7693 opts_type = OPTS_TYPE_PT_GENERATE_BE
7694 | OPTS_TYPE_PT_ADD80
7695 | OPTS_TYPE_PT_ADDBITS15;
7696 kern_type = KERN_TYPE_HMACSHA512_SLT;
7697 dgst_size = DGST_SIZE_8_8;
7698 parse_func = hmacsha512_parse_hash;
7699 sort_by_digest = sort_by_digest_8_8;
7700 opti_type = OPTI_TYPE_ZERO_BYTE
7701 | OPTI_TYPE_NOT_ITERATED;
7702 dgst_pos0 = 14;
7703 dgst_pos1 = 15;
7704 dgst_pos2 = 6;
7705 dgst_pos3 = 7;
7706 break;
7707
7708 case 1800: hash_type = HASH_TYPE_SHA512;
7709 salt_type = SALT_TYPE_EMBEDDED;
7710 attack_exec = ATTACK_EXEC_ON_CPU;
7711 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7712 kern_type = KERN_TYPE_SHA512CRYPT;
7713 dgst_size = DGST_SIZE_8_8;
7714 parse_func = sha512crypt_parse_hash;
7715 sort_by_digest = sort_by_digest_8_8;
7716 opti_type = OPTI_TYPE_ZERO_BYTE;
7717 dgst_pos0 = 0;
7718 dgst_pos1 = 1;
7719 dgst_pos2 = 2;
7720 dgst_pos3 = 3;
7721 break;
7722
7723 case 2100: hash_type = HASH_TYPE_DCC2;
7724 salt_type = SALT_TYPE_EMBEDDED;
7725 attack_exec = ATTACK_EXEC_ON_CPU;
7726 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
7727 | OPTS_TYPE_ST_LOWER
7728 | OPTS_TYPE_ST_UNICODE;
7729 kern_type = KERN_TYPE_DCC2;
7730 dgst_size = DGST_SIZE_4_4;
7731 parse_func = dcc2_parse_hash;
7732 sort_by_digest = sort_by_digest_4_4;
7733 opti_type = OPTI_TYPE_ZERO_BYTE;
7734 dgst_pos0 = 0;
7735 dgst_pos1 = 1;
7736 dgst_pos2 = 2;
7737 dgst_pos3 = 3;
7738 break;
7739
7740 case 2400: hash_type = HASH_TYPE_MD5;
7741 salt_type = SALT_TYPE_NONE;
7742 attack_exec = ATTACK_EXEC_ON_GPU;
7743 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7744 kern_type = KERN_TYPE_MD5PIX;
7745 dgst_size = DGST_SIZE_4_4;
7746 parse_func = md5pix_parse_hash;
7747 sort_by_digest = sort_by_digest_4_4;
7748 opti_type = OPTI_TYPE_ZERO_BYTE
7749 | OPTI_TYPE_PRECOMPUTE_INIT
7750 | OPTI_TYPE_PRECOMPUTE_MERKLE
7751 | OPTI_TYPE_EARLY_SKIP
7752 | OPTI_TYPE_NOT_ITERATED
7753 | OPTI_TYPE_NOT_SALTED;
7754 dgst_pos0 = 0;
7755 dgst_pos1 = 3;
7756 dgst_pos2 = 2;
7757 dgst_pos3 = 1;
7758 break;
7759
7760 case 2410: hash_type = HASH_TYPE_MD5;
7761 salt_type = SALT_TYPE_INTERN;
7762 attack_exec = ATTACK_EXEC_ON_GPU;
7763 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7764 kern_type = KERN_TYPE_MD5ASA;
7765 dgst_size = DGST_SIZE_4_4;
7766 parse_func = md5asa_parse_hash;
7767 sort_by_digest = sort_by_digest_4_4;
7768 opti_type = OPTI_TYPE_ZERO_BYTE
7769 | OPTI_TYPE_PRECOMPUTE_INIT
7770 | OPTI_TYPE_PRECOMPUTE_MERKLE
7771 | OPTI_TYPE_EARLY_SKIP
7772 | OPTI_TYPE_NOT_ITERATED;
7773 dgst_pos0 = 0;
7774 dgst_pos1 = 3;
7775 dgst_pos2 = 2;
7776 dgst_pos3 = 1;
7777 break;
7778
7779 case 2500: hash_type = HASH_TYPE_WPA;
7780 salt_type = SALT_TYPE_EMBEDDED;
7781 attack_exec = ATTACK_EXEC_ON_CPU;
7782 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7783 kern_type = KERN_TYPE_WPA;
7784 dgst_size = DGST_SIZE_4_4;
7785 parse_func = wpa_parse_hash;
7786 sort_by_digest = sort_by_digest_4_4;
7787 opti_type = OPTI_TYPE_ZERO_BYTE;
7788 dgst_pos0 = 0;
7789 dgst_pos1 = 1;
7790 dgst_pos2 = 2;
7791 dgst_pos3 = 3;
7792 break;
7793
7794 case 2600: hash_type = HASH_TYPE_MD5;
7795 salt_type = SALT_TYPE_VIRTUAL;
7796 attack_exec = ATTACK_EXEC_ON_GPU;
7797 opts_type = OPTS_TYPE_PT_GENERATE_LE
7798 | OPTS_TYPE_PT_ADD80
7799 | OPTS_TYPE_PT_ADDBITS14
7800 | OPTS_TYPE_ST_ADD80;
7801 kern_type = KERN_TYPE_MD55_PWSLT1;
7802 dgst_size = DGST_SIZE_4_4;
7803 parse_func = md5md5_parse_hash;
7804 sort_by_digest = sort_by_digest_4_4;
7805 opti_type = OPTI_TYPE_ZERO_BYTE
7806 | OPTI_TYPE_PRECOMPUTE_INIT
7807 | OPTI_TYPE_PRECOMPUTE_MERKLE
7808 | OPTI_TYPE_EARLY_SKIP;
7809 dgst_pos0 = 0;
7810 dgst_pos1 = 3;
7811 dgst_pos2 = 2;
7812 dgst_pos3 = 1;
7813 break;
7814
7815 case 2611: hash_type = HASH_TYPE_MD5;
7816 salt_type = SALT_TYPE_INTERN;
7817 attack_exec = ATTACK_EXEC_ON_GPU;
7818 opts_type = OPTS_TYPE_PT_GENERATE_LE
7819 | OPTS_TYPE_PT_ADD80
7820 | OPTS_TYPE_PT_ADDBITS14
7821 | OPTS_TYPE_ST_ADD80;
7822 kern_type = KERN_TYPE_MD55_PWSLT1;
7823 dgst_size = DGST_SIZE_4_4;
7824 parse_func = vb3_parse_hash;
7825 sort_by_digest = sort_by_digest_4_4;
7826 opti_type = OPTI_TYPE_ZERO_BYTE
7827 | OPTI_TYPE_PRECOMPUTE_INIT
7828 | OPTI_TYPE_PRECOMPUTE_MERKLE
7829 | OPTI_TYPE_EARLY_SKIP;
7830 dgst_pos0 = 0;
7831 dgst_pos1 = 3;
7832 dgst_pos2 = 2;
7833 dgst_pos3 = 1;
7834 break;
7835
7836 case 2612: hash_type = HASH_TYPE_MD5;
7837 salt_type = SALT_TYPE_EMBEDDED;
7838 attack_exec = ATTACK_EXEC_ON_GPU;
7839 opts_type = OPTS_TYPE_PT_GENERATE_LE
7840 | OPTS_TYPE_PT_ADD80
7841 | OPTS_TYPE_PT_ADDBITS14
7842 | OPTS_TYPE_ST_ADD80
7843 | OPTS_TYPE_ST_HEX;
7844 kern_type = KERN_TYPE_MD55_PWSLT1;
7845 dgst_size = DGST_SIZE_4_4;
7846 parse_func = phps_parse_hash;
7847 sort_by_digest = sort_by_digest_4_4;
7848 opti_type = OPTI_TYPE_ZERO_BYTE
7849 | OPTI_TYPE_PRECOMPUTE_INIT
7850 | OPTI_TYPE_PRECOMPUTE_MERKLE
7851 | OPTI_TYPE_EARLY_SKIP;
7852 dgst_pos0 = 0;
7853 dgst_pos1 = 3;
7854 dgst_pos2 = 2;
7855 dgst_pos3 = 1;
7856 break;
7857
7858 case 2711: hash_type = HASH_TYPE_MD5;
7859 salt_type = SALT_TYPE_INTERN;
7860 attack_exec = ATTACK_EXEC_ON_GPU;
7861 opts_type = OPTS_TYPE_PT_GENERATE_LE
7862 | OPTS_TYPE_PT_ADD80
7863 | OPTS_TYPE_PT_ADDBITS14
7864 | OPTS_TYPE_ST_ADD80;
7865 kern_type = KERN_TYPE_MD55_PWSLT2;
7866 dgst_size = DGST_SIZE_4_4;
7867 parse_func = vb30_parse_hash;
7868 sort_by_digest = sort_by_digest_4_4;
7869 opti_type = OPTI_TYPE_ZERO_BYTE
7870 | OPTI_TYPE_PRECOMPUTE_INIT
7871 | OPTI_TYPE_EARLY_SKIP;
7872 dgst_pos0 = 0;
7873 dgst_pos1 = 3;
7874 dgst_pos2 = 2;
7875 dgst_pos3 = 1;
7876 break;
7877
7878 case 2811: hash_type = HASH_TYPE_MD5;
7879 salt_type = SALT_TYPE_INTERN;
7880 attack_exec = ATTACK_EXEC_ON_GPU;
7881 opts_type = OPTS_TYPE_PT_GENERATE_LE
7882 | OPTS_TYPE_PT_ADD80
7883 | OPTS_TYPE_PT_ADDBITS14;
7884 kern_type = KERN_TYPE_MD55_SLTPW;
7885 dgst_size = DGST_SIZE_4_4;
7886 parse_func = ipb2_parse_hash;
7887 sort_by_digest = sort_by_digest_4_4;
7888 opti_type = OPTI_TYPE_ZERO_BYTE
7889 | OPTI_TYPE_PRECOMPUTE_INIT
7890 | OPTI_TYPE_EARLY_SKIP;
7891 dgst_pos0 = 0;
7892 dgst_pos1 = 3;
7893 dgst_pos2 = 2;
7894 dgst_pos3 = 1;
7895 break;
7896
7897 case 3000: hash_type = HASH_TYPE_LM;
7898 salt_type = SALT_TYPE_NONE;
7899 attack_exec = ATTACK_EXEC_ON_GPU;
7900 opts_type = OPTS_TYPE_PT_GENERATE_LE
7901 | OPTS_TYPE_PT_UPPER
7902 | OPTS_TYPE_PT_BITSLICE;
7903 kern_type = KERN_TYPE_LM;
7904 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7905 parse_func = lm_parse_hash;
7906 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7907 opti_type = OPTI_TYPE_ZERO_BYTE
7908 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7909 dgst_pos0 = 0;
7910 dgst_pos1 = 1;
7911 dgst_pos2 = 2;
7912 dgst_pos3 = 3;
7913 break;
7914
7915 case 3100: hash_type = HASH_TYPE_ORACLEH;
7916 salt_type = SALT_TYPE_INTERN;
7917 attack_exec = ATTACK_EXEC_ON_GPU;
7918 opts_type = OPTS_TYPE_PT_GENERATE_LE
7919 | OPTS_TYPE_PT_UPPER
7920 | OPTS_TYPE_ST_UPPER;
7921 kern_type = KERN_TYPE_ORACLEH;
7922 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7923 parse_func = oracleh_parse_hash;
7924 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7925 opti_type = OPTI_TYPE_ZERO_BYTE;
7926 dgst_pos0 = 0;
7927 dgst_pos1 = 1;
7928 dgst_pos2 = 2;
7929 dgst_pos3 = 3;
7930 break;
7931
7932 case 3200: hash_type = HASH_TYPE_BCRYPT;
7933 salt_type = SALT_TYPE_EMBEDDED;
7934 attack_exec = ATTACK_EXEC_ON_CPU;
7935 opts_type = OPTS_TYPE_PT_GENERATE_LE
7936 | OPTS_TYPE_ST_GENERATE_LE;
7937 kern_type = KERN_TYPE_BCRYPT;
7938 dgst_size = DGST_SIZE_4_6;
7939 parse_func = bcrypt_parse_hash;
7940 sort_by_digest = sort_by_digest_4_6;
7941 opti_type = OPTI_TYPE_ZERO_BYTE;
7942 dgst_pos0 = 0;
7943 dgst_pos1 = 1;
7944 dgst_pos2 = 2;
7945 dgst_pos3 = 3;
7946 break;
7947
7948 case 3710: hash_type = HASH_TYPE_MD5;
7949 salt_type = SALT_TYPE_INTERN;
7950 attack_exec = ATTACK_EXEC_ON_GPU;
7951 opts_type = OPTS_TYPE_PT_GENERATE_LE
7952 | OPTS_TYPE_PT_ADD80
7953 | OPTS_TYPE_PT_ADDBITS14;
7954 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
7955 dgst_size = DGST_SIZE_4_4;
7956 parse_func = md5s_parse_hash;
7957 sort_by_digest = sort_by_digest_4_4;
7958 opti_type = OPTI_TYPE_ZERO_BYTE
7959 | OPTI_TYPE_PRECOMPUTE_INIT
7960 | OPTI_TYPE_PRECOMPUTE_MERKLE
7961 | OPTI_TYPE_EARLY_SKIP;
7962 dgst_pos0 = 0;
7963 dgst_pos1 = 3;
7964 dgst_pos2 = 2;
7965 dgst_pos3 = 1;
7966 break;
7967
7968 case 3711: hash_type = HASH_TYPE_MD5;
7969 salt_type = SALT_TYPE_EMBEDDED;
7970 attack_exec = ATTACK_EXEC_ON_GPU;
7971 opts_type = OPTS_TYPE_PT_GENERATE_LE
7972 | OPTS_TYPE_PT_ADD80
7973 | OPTS_TYPE_PT_ADDBITS14;
7974 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
7975 dgst_size = DGST_SIZE_4_4;
7976 parse_func = mediawiki_b_parse_hash;
7977 sort_by_digest = sort_by_digest_4_4;
7978 opti_type = OPTI_TYPE_ZERO_BYTE
7979 | OPTI_TYPE_PRECOMPUTE_INIT
7980 | OPTI_TYPE_PRECOMPUTE_MERKLE
7981 | OPTI_TYPE_EARLY_SKIP;
7982 dgst_pos0 = 0;
7983 dgst_pos1 = 3;
7984 dgst_pos2 = 2;
7985 dgst_pos3 = 1;
7986 break;
7987
7988 case 3800: hash_type = HASH_TYPE_MD5;
7989 salt_type = SALT_TYPE_INTERN;
7990 attack_exec = ATTACK_EXEC_ON_GPU;
7991 opts_type = OPTS_TYPE_PT_GENERATE_LE
7992 | OPTS_TYPE_ST_ADDBITS14;
7993 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
7994 dgst_size = DGST_SIZE_4_4;
7995 parse_func = md5s_parse_hash;
7996 sort_by_digest = sort_by_digest_4_4;
7997 opti_type = OPTI_TYPE_ZERO_BYTE
7998 | OPTI_TYPE_PRECOMPUTE_INIT
7999 | OPTI_TYPE_PRECOMPUTE_MERKLE
8000 | OPTI_TYPE_EARLY_SKIP
8001 | OPTI_TYPE_NOT_ITERATED
8002 | OPTI_TYPE_RAW_HASH;
8003 dgst_pos0 = 0;
8004 dgst_pos1 = 3;
8005 dgst_pos2 = 2;
8006 dgst_pos3 = 1;
8007 break;
8008
8009 case 4300: hash_type = HASH_TYPE_MD5;
8010 salt_type = SALT_TYPE_VIRTUAL;
8011 attack_exec = ATTACK_EXEC_ON_GPU;
8012 opts_type = OPTS_TYPE_PT_GENERATE_LE
8013 | OPTS_TYPE_PT_ADD80
8014 | OPTS_TYPE_PT_ADDBITS14
8015 | OPTS_TYPE_ST_ADD80;
8016 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8017 dgst_size = DGST_SIZE_4_4;
8018 parse_func = md5md5_parse_hash;
8019 sort_by_digest = sort_by_digest_4_4;
8020 opti_type = OPTI_TYPE_ZERO_BYTE
8021 | OPTI_TYPE_PRECOMPUTE_INIT
8022 | OPTI_TYPE_PRECOMPUTE_MERKLE
8023 | OPTI_TYPE_EARLY_SKIP;
8024 dgst_pos0 = 0;
8025 dgst_pos1 = 3;
8026 dgst_pos2 = 2;
8027 dgst_pos3 = 1;
8028 break;
8029
8030
8031 case 4400: hash_type = HASH_TYPE_MD5;
8032 salt_type = SALT_TYPE_NONE;
8033 attack_exec = ATTACK_EXEC_ON_GPU;
8034 opts_type = OPTS_TYPE_PT_GENERATE_BE
8035 | OPTS_TYPE_PT_ADD80
8036 | OPTS_TYPE_PT_ADDBITS15;
8037 kern_type = KERN_TYPE_MD5_SHA1;
8038 dgst_size = DGST_SIZE_4_4;
8039 parse_func = md5_parse_hash;
8040 sort_by_digest = sort_by_digest_4_4;
8041 opti_type = OPTI_TYPE_ZERO_BYTE
8042 | OPTI_TYPE_PRECOMPUTE_INIT
8043 | OPTI_TYPE_PRECOMPUTE_MERKLE
8044 | OPTI_TYPE_EARLY_SKIP
8045 | OPTI_TYPE_NOT_ITERATED
8046 | OPTI_TYPE_NOT_SALTED
8047 | OPTI_TYPE_RAW_HASH;
8048 dgst_pos0 = 0;
8049 dgst_pos1 = 3;
8050 dgst_pos2 = 2;
8051 dgst_pos3 = 1;
8052 break;
8053
8054 case 4500: hash_type = HASH_TYPE_SHA1;
8055 salt_type = SALT_TYPE_NONE;
8056 attack_exec = ATTACK_EXEC_ON_GPU;
8057 opts_type = OPTS_TYPE_PT_GENERATE_BE
8058 | OPTS_TYPE_PT_ADD80
8059 | OPTS_TYPE_PT_ADDBITS15;
8060 kern_type = KERN_TYPE_SHA11;
8061 dgst_size = DGST_SIZE_4_5;
8062 parse_func = sha1_parse_hash;
8063 sort_by_digest = sort_by_digest_4_5;
8064 opti_type = OPTI_TYPE_ZERO_BYTE
8065 | OPTI_TYPE_PRECOMPUTE_INIT
8066 | OPTI_TYPE_PRECOMPUTE_MERKLE
8067 | OPTI_TYPE_EARLY_SKIP
8068 | OPTI_TYPE_NOT_SALTED;
8069 dgst_pos0 = 3;
8070 dgst_pos1 = 4;
8071 dgst_pos2 = 2;
8072 dgst_pos3 = 1;
8073 break;
8074
8075 case 4700: hash_type = HASH_TYPE_SHA1;
8076 salt_type = SALT_TYPE_NONE;
8077 attack_exec = ATTACK_EXEC_ON_GPU;
8078 opts_type = OPTS_TYPE_PT_GENERATE_LE
8079 | OPTS_TYPE_PT_ADD80
8080 | OPTS_TYPE_PT_ADDBITS14;
8081 kern_type = KERN_TYPE_SHA1_MD5;
8082 dgst_size = DGST_SIZE_4_5;
8083 parse_func = sha1_parse_hash;
8084 sort_by_digest = sort_by_digest_4_5;
8085 opti_type = OPTI_TYPE_ZERO_BYTE
8086 | OPTI_TYPE_PRECOMPUTE_INIT
8087 | OPTI_TYPE_PRECOMPUTE_MERKLE
8088 | OPTI_TYPE_EARLY_SKIP
8089 | OPTI_TYPE_NOT_ITERATED
8090 | OPTI_TYPE_NOT_SALTED
8091 | OPTI_TYPE_RAW_HASH;
8092 dgst_pos0 = 3;
8093 dgst_pos1 = 4;
8094 dgst_pos2 = 2;
8095 dgst_pos3 = 1;
8096 break;
8097
8098 case 4800: hash_type = HASH_TYPE_MD5;
8099 salt_type = SALT_TYPE_EMBEDDED;
8100 attack_exec = ATTACK_EXEC_ON_GPU;
8101 opts_type = OPTS_TYPE_PT_GENERATE_LE
8102 | OPTS_TYPE_PT_ADDBITS14;
8103 kern_type = KERN_TYPE_MD5_CHAP;
8104 dgst_size = DGST_SIZE_4_4;
8105 parse_func = chap_parse_hash;
8106 sort_by_digest = sort_by_digest_4_4;
8107 opti_type = OPTI_TYPE_ZERO_BYTE
8108 | OPTI_TYPE_PRECOMPUTE_INIT
8109 | OPTI_TYPE_PRECOMPUTE_MERKLE
8110 | OPTI_TYPE_MEET_IN_MIDDLE
8111 | OPTI_TYPE_EARLY_SKIP
8112 | OPTI_TYPE_NOT_ITERATED
8113 | OPTI_TYPE_RAW_HASH;
8114 dgst_pos0 = 0;
8115 dgst_pos1 = 3;
8116 dgst_pos2 = 2;
8117 dgst_pos3 = 1;
8118 break;
8119
8120 case 4900: hash_type = HASH_TYPE_SHA1;
8121 salt_type = SALT_TYPE_INTERN;
8122 attack_exec = ATTACK_EXEC_ON_GPU;
8123 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8124 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8125 dgst_size = DGST_SIZE_4_5;
8126 parse_func = sha1s_parse_hash;
8127 sort_by_digest = sort_by_digest_4_5;
8128 opti_type = OPTI_TYPE_ZERO_BYTE
8129 | OPTI_TYPE_PRECOMPUTE_INIT
8130 | OPTI_TYPE_PRECOMPUTE_MERKLE
8131 | OPTI_TYPE_EARLY_SKIP;
8132 dgst_pos0 = 3;
8133 dgst_pos1 = 4;
8134 dgst_pos2 = 2;
8135 dgst_pos3 = 1;
8136 break;
8137
8138 case 5000: hash_type = HASH_TYPE_KECCAK;
8139 salt_type = SALT_TYPE_EMBEDDED;
8140 attack_exec = ATTACK_EXEC_ON_GPU;
8141 opts_type = OPTS_TYPE_PT_GENERATE_LE
8142 | OPTS_TYPE_PT_ADD01;
8143 kern_type = KERN_TYPE_KECCAK;
8144 dgst_size = DGST_SIZE_8_25;
8145 parse_func = keccak_parse_hash;
8146 sort_by_digest = sort_by_digest_8_25;
8147 opti_type = OPTI_TYPE_ZERO_BYTE
8148 | OPTI_TYPE_RAW_HASH;
8149 dgst_pos0 = 2;
8150 dgst_pos1 = 3;
8151 dgst_pos2 = 4;
8152 dgst_pos3 = 5;
8153 break;
8154
8155 case 5100: hash_type = HASH_TYPE_MD5H;
8156 salt_type = SALT_TYPE_NONE;
8157 attack_exec = ATTACK_EXEC_ON_GPU;
8158 opts_type = OPTS_TYPE_PT_GENERATE_LE
8159 | OPTS_TYPE_PT_ADD80
8160 | OPTS_TYPE_PT_ADDBITS14;
8161 kern_type = KERN_TYPE_MD5H;
8162 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8163 parse_func = md5half_parse_hash;
8164 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8165 opti_type = OPTI_TYPE_ZERO_BYTE
8166 | OPTI_TYPE_RAW_HASH;
8167 dgst_pos0 = 0;
8168 dgst_pos1 = 1;
8169 dgst_pos2 = 2;
8170 dgst_pos3 = 3;
8171 break;
8172
8173 case 5200: hash_type = HASH_TYPE_SHA256;
8174 salt_type = SALT_TYPE_EMBEDDED;
8175 attack_exec = ATTACK_EXEC_ON_CPU;
8176 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8177 kern_type = KERN_TYPE_PSAFE3;
8178 dgst_size = DGST_SIZE_4_8;
8179 parse_func = psafe3_parse_hash;
8180 sort_by_digest = sort_by_digest_4_8;
8181 opti_type = OPTI_TYPE_ZERO_BYTE;
8182 dgst_pos0 = 0;
8183 dgst_pos1 = 1;
8184 dgst_pos2 = 2;
8185 dgst_pos3 = 3;
8186 break;
8187
8188 case 5300: hash_type = HASH_TYPE_MD5;
8189 salt_type = SALT_TYPE_EMBEDDED;
8190 attack_exec = ATTACK_EXEC_ON_GPU;
8191 opts_type = OPTS_TYPE_PT_GENERATE_LE
8192 | OPTS_TYPE_ST_ADD80;
8193 kern_type = KERN_TYPE_IKEPSK_MD5;
8194 dgst_size = DGST_SIZE_4_4;
8195 parse_func = ikepsk_md5_parse_hash;
8196 sort_by_digest = sort_by_digest_4_4;
8197 opti_type = OPTI_TYPE_ZERO_BYTE;
8198 dgst_pos0 = 0;
8199 dgst_pos1 = 3;
8200 dgst_pos2 = 2;
8201 dgst_pos3 = 1;
8202 break;
8203
8204 case 5400: hash_type = HASH_TYPE_SHA1;
8205 salt_type = SALT_TYPE_EMBEDDED;
8206 attack_exec = ATTACK_EXEC_ON_GPU;
8207 opts_type = OPTS_TYPE_PT_GENERATE_BE
8208 | OPTS_TYPE_ST_ADD80;
8209 kern_type = KERN_TYPE_IKEPSK_SHA1;
8210 dgst_size = DGST_SIZE_4_5;
8211 parse_func = ikepsk_sha1_parse_hash;
8212 sort_by_digest = sort_by_digest_4_5;
8213 opti_type = OPTI_TYPE_ZERO_BYTE;
8214 dgst_pos0 = 3;
8215 dgst_pos1 = 4;
8216 dgst_pos2 = 2;
8217 dgst_pos3 = 1;
8218 break;
8219
8220 case 5500: hash_type = HASH_TYPE_NETNTLM;
8221 salt_type = SALT_TYPE_EMBEDDED;
8222 attack_exec = ATTACK_EXEC_ON_GPU;
8223 opts_type = OPTS_TYPE_PT_GENERATE_LE
8224 | OPTS_TYPE_PT_ADD80
8225 | OPTS_TYPE_PT_ADDBITS14
8226 | OPTS_TYPE_PT_UNICODE
8227 | OPTS_TYPE_ST_HEX;
8228 kern_type = KERN_TYPE_NETNTLMv1;
8229 dgst_size = DGST_SIZE_4_4;
8230 parse_func = netntlmv1_parse_hash;
8231 sort_by_digest = sort_by_digest_4_4;
8232 opti_type = OPTI_TYPE_ZERO_BYTE
8233 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8234 dgst_pos0 = 0;
8235 dgst_pos1 = 1;
8236 dgst_pos2 = 2;
8237 dgst_pos3 = 3;
8238 break;
8239
8240 case 5600: hash_type = HASH_TYPE_MD5;
8241 salt_type = SALT_TYPE_EMBEDDED;
8242 attack_exec = ATTACK_EXEC_ON_GPU;
8243 opts_type = OPTS_TYPE_PT_GENERATE_LE
8244 | OPTS_TYPE_PT_ADD80
8245 | OPTS_TYPE_PT_ADDBITS14
8246 | OPTS_TYPE_PT_UNICODE;
8247 kern_type = KERN_TYPE_NETNTLMv2;
8248 dgst_size = DGST_SIZE_4_4;
8249 parse_func = netntlmv2_parse_hash;
8250 sort_by_digest = sort_by_digest_4_4;
8251 opti_type = OPTI_TYPE_ZERO_BYTE;
8252 dgst_pos0 = 0;
8253 dgst_pos1 = 3;
8254 dgst_pos2 = 2;
8255 dgst_pos3 = 1;
8256 break;
8257
8258 case 5700: hash_type = HASH_TYPE_SHA256;
8259 salt_type = SALT_TYPE_NONE;
8260 attack_exec = ATTACK_EXEC_ON_GPU;
8261 opts_type = OPTS_TYPE_PT_GENERATE_BE
8262 | OPTS_TYPE_PT_ADD80
8263 | OPTS_TYPE_PT_ADDBITS15;
8264 kern_type = KERN_TYPE_SHA256;
8265 dgst_size = DGST_SIZE_4_8;
8266 parse_func = cisco4_parse_hash;
8267 sort_by_digest = sort_by_digest_4_8;
8268 opti_type = OPTI_TYPE_ZERO_BYTE
8269 | OPTI_TYPE_PRECOMPUTE_INIT
8270 | OPTI_TYPE_PRECOMPUTE_MERKLE
8271 | OPTI_TYPE_EARLY_SKIP
8272 | OPTI_TYPE_NOT_ITERATED
8273 | OPTI_TYPE_NOT_SALTED
8274 | OPTI_TYPE_RAW_HASH;
8275 dgst_pos0 = 3;
8276 dgst_pos1 = 7;
8277 dgst_pos2 = 2;
8278 dgst_pos3 = 6;
8279 break;
8280
8281 case 5800: hash_type = HASH_TYPE_SHA1;
8282 salt_type = SALT_TYPE_INTERN;
8283 attack_exec = ATTACK_EXEC_ON_CPU;
8284 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8285 | OPTS_TYPE_ST_ADD80;
8286 kern_type = KERN_TYPE_ANDROIDPIN;
8287 dgst_size = DGST_SIZE_4_5;
8288 parse_func = androidpin_parse_hash;
8289 sort_by_digest = sort_by_digest_4_5;
8290 opti_type = OPTI_TYPE_ZERO_BYTE;
8291 dgst_pos0 = 0;
8292 dgst_pos1 = 1;
8293 dgst_pos2 = 2;
8294 dgst_pos3 = 3;
8295 break;
8296
8297 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8298 salt_type = SALT_TYPE_NONE;
8299 attack_exec = ATTACK_EXEC_ON_GPU;
8300 opts_type = OPTS_TYPE_PT_GENERATE_LE
8301 | OPTS_TYPE_PT_ADD80;
8302 kern_type = KERN_TYPE_RIPEMD160;
8303 dgst_size = DGST_SIZE_4_5;
8304 parse_func = ripemd160_parse_hash;
8305 sort_by_digest = sort_by_digest_4_5;
8306 opti_type = OPTI_TYPE_ZERO_BYTE;
8307 dgst_pos0 = 0;
8308 dgst_pos1 = 1;
8309 dgst_pos2 = 2;
8310 dgst_pos3 = 3;
8311 break;
8312
8313 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8314 salt_type = SALT_TYPE_NONE;
8315 attack_exec = ATTACK_EXEC_ON_GPU;
8316 opts_type = OPTS_TYPE_PT_GENERATE_BE
8317 | OPTS_TYPE_PT_ADD80;
8318 kern_type = KERN_TYPE_WHIRLPOOL;
8319 dgst_size = DGST_SIZE_4_16;
8320 parse_func = whirlpool_parse_hash;
8321 sort_by_digest = sort_by_digest_4_16;
8322 opti_type = OPTI_TYPE_ZERO_BYTE;
8323 dgst_pos0 = 0;
8324 dgst_pos1 = 1;
8325 dgst_pos2 = 2;
8326 dgst_pos3 = 3;
8327 break;
8328
8329 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8330 salt_type = SALT_TYPE_EMBEDDED;
8331 attack_exec = ATTACK_EXEC_ON_CPU;
8332 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8333 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8334 dgst_size = DGST_SIZE_4_5;
8335 parse_func = truecrypt_parse_hash_2k;
8336 sort_by_digest = sort_by_digest_4_5;
8337 opti_type = OPTI_TYPE_ZERO_BYTE;
8338 dgst_pos0 = 0;
8339 dgst_pos1 = 1;
8340 dgst_pos2 = 2;
8341 dgst_pos3 = 3;
8342 break;
8343
8344 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8345 salt_type = SALT_TYPE_EMBEDDED;
8346 attack_exec = ATTACK_EXEC_ON_CPU;
8347 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8348 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8349 dgst_size = DGST_SIZE_4_5;
8350 parse_func = truecrypt_parse_hash_2k;
8351 sort_by_digest = sort_by_digest_4_5;
8352 opti_type = OPTI_TYPE_ZERO_BYTE;
8353 dgst_pos0 = 0;
8354 dgst_pos1 = 1;
8355 dgst_pos2 = 2;
8356 dgst_pos3 = 3;
8357 break;
8358
8359 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8360 salt_type = SALT_TYPE_EMBEDDED;
8361 attack_exec = ATTACK_EXEC_ON_CPU;
8362 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8363 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8364 dgst_size = DGST_SIZE_4_5;
8365 parse_func = truecrypt_parse_hash_2k;
8366 sort_by_digest = sort_by_digest_4_5;
8367 opti_type = OPTI_TYPE_ZERO_BYTE;
8368 dgst_pos0 = 0;
8369 dgst_pos1 = 1;
8370 dgst_pos2 = 2;
8371 dgst_pos3 = 3;
8372 break;
8373
8374 case 6221: hash_type = HASH_TYPE_SHA512;
8375 salt_type = SALT_TYPE_EMBEDDED;
8376 attack_exec = ATTACK_EXEC_ON_CPU;
8377 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8378 kern_type = KERN_TYPE_TCSHA512_XTS512;
8379 dgst_size = DGST_SIZE_8_8;
8380 parse_func = truecrypt_parse_hash_1k;
8381 sort_by_digest = sort_by_digest_8_8;
8382 opti_type = OPTI_TYPE_ZERO_BYTE;
8383 dgst_pos0 = 0;
8384 dgst_pos1 = 1;
8385 dgst_pos2 = 2;
8386 dgst_pos3 = 3;
8387 break;
8388
8389 case 6222: hash_type = HASH_TYPE_SHA512;
8390 salt_type = SALT_TYPE_EMBEDDED;
8391 attack_exec = ATTACK_EXEC_ON_CPU;
8392 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8393 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8394 dgst_size = DGST_SIZE_8_8;
8395 parse_func = truecrypt_parse_hash_1k;
8396 sort_by_digest = sort_by_digest_8_8;
8397 opti_type = OPTI_TYPE_ZERO_BYTE;
8398 dgst_pos0 = 0;
8399 dgst_pos1 = 1;
8400 dgst_pos2 = 2;
8401 dgst_pos3 = 3;
8402 break;
8403
8404 case 6223: hash_type = HASH_TYPE_SHA512;
8405 salt_type = SALT_TYPE_EMBEDDED;
8406 attack_exec = ATTACK_EXEC_ON_CPU;
8407 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8408 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8409 dgst_size = DGST_SIZE_8_8;
8410 parse_func = truecrypt_parse_hash_1k;
8411 sort_by_digest = sort_by_digest_8_8;
8412 opti_type = OPTI_TYPE_ZERO_BYTE;
8413 dgst_pos0 = 0;
8414 dgst_pos1 = 1;
8415 dgst_pos2 = 2;
8416 dgst_pos3 = 3;
8417 break;
8418
8419 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8420 salt_type = SALT_TYPE_EMBEDDED;
8421 attack_exec = ATTACK_EXEC_ON_CPU;
8422 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8423 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8424 dgst_size = DGST_SIZE_4_8;
8425 parse_func = truecrypt_parse_hash_1k;
8426 sort_by_digest = sort_by_digest_4_8;
8427 opti_type = OPTI_TYPE_ZERO_BYTE;
8428 dgst_pos0 = 0;
8429 dgst_pos1 = 1;
8430 dgst_pos2 = 2;
8431 dgst_pos3 = 3;
8432 break;
8433
8434 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8435 salt_type = SALT_TYPE_EMBEDDED;
8436 attack_exec = ATTACK_EXEC_ON_CPU;
8437 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8438 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8439 dgst_size = DGST_SIZE_4_8;
8440 parse_func = truecrypt_parse_hash_1k;
8441 sort_by_digest = sort_by_digest_4_8;
8442 opti_type = OPTI_TYPE_ZERO_BYTE;
8443 dgst_pos0 = 0;
8444 dgst_pos1 = 1;
8445 dgst_pos2 = 2;
8446 dgst_pos3 = 3;
8447 break;
8448
8449 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8450 salt_type = SALT_TYPE_EMBEDDED;
8451 attack_exec = ATTACK_EXEC_ON_CPU;
8452 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8453 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8454 dgst_size = DGST_SIZE_4_8;
8455 parse_func = truecrypt_parse_hash_1k;
8456 sort_by_digest = sort_by_digest_4_8;
8457 opti_type = OPTI_TYPE_ZERO_BYTE;
8458 dgst_pos0 = 0;
8459 dgst_pos1 = 1;
8460 dgst_pos2 = 2;
8461 dgst_pos3 = 3;
8462 break;
8463
8464 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8465 salt_type = SALT_TYPE_EMBEDDED;
8466 attack_exec = ATTACK_EXEC_ON_CPU;
8467 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8468 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8469 dgst_size = DGST_SIZE_4_5;
8470 parse_func = truecrypt_parse_hash_1k;
8471 sort_by_digest = sort_by_digest_4_5;
8472 opti_type = OPTI_TYPE_ZERO_BYTE;
8473 dgst_pos0 = 0;
8474 dgst_pos1 = 1;
8475 dgst_pos2 = 2;
8476 dgst_pos3 = 3;
8477 break;
8478
8479 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8480 salt_type = SALT_TYPE_EMBEDDED;
8481 attack_exec = ATTACK_EXEC_ON_CPU;
8482 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8483 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8484 dgst_size = DGST_SIZE_4_5;
8485 parse_func = truecrypt_parse_hash_1k;
8486 sort_by_digest = sort_by_digest_4_5;
8487 opti_type = OPTI_TYPE_ZERO_BYTE;
8488 dgst_pos0 = 0;
8489 dgst_pos1 = 1;
8490 dgst_pos2 = 2;
8491 dgst_pos3 = 3;
8492 break;
8493
8494 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8495 salt_type = SALT_TYPE_EMBEDDED;
8496 attack_exec = ATTACK_EXEC_ON_CPU;
8497 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8498 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8499 dgst_size = DGST_SIZE_4_5;
8500 parse_func = truecrypt_parse_hash_1k;
8501 sort_by_digest = sort_by_digest_4_5;
8502 opti_type = OPTI_TYPE_ZERO_BYTE;
8503 dgst_pos0 = 0;
8504 dgst_pos1 = 1;
8505 dgst_pos2 = 2;
8506 dgst_pos3 = 3;
8507 break;
8508
8509 case 6300: hash_type = HASH_TYPE_MD5;
8510 salt_type = SALT_TYPE_EMBEDDED;
8511 attack_exec = ATTACK_EXEC_ON_CPU;
8512 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8513 kern_type = KERN_TYPE_MD5AIX;
8514 dgst_size = DGST_SIZE_4_4;
8515 parse_func = md5aix_parse_hash;
8516 sort_by_digest = sort_by_digest_4_4;
8517 opti_type = OPTI_TYPE_ZERO_BYTE;
8518 dgst_pos0 = 0;
8519 dgst_pos1 = 1;
8520 dgst_pos2 = 2;
8521 dgst_pos3 = 3;
8522 break;
8523
8524 case 6400: hash_type = HASH_TYPE_SHA256;
8525 salt_type = SALT_TYPE_EMBEDDED;
8526 attack_exec = ATTACK_EXEC_ON_CPU;
8527 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8528 kern_type = KERN_TYPE_SHA256AIX;
8529 dgst_size = DGST_SIZE_4_8;
8530 parse_func = sha256aix_parse_hash;
8531 sort_by_digest = sort_by_digest_4_8;
8532 opti_type = OPTI_TYPE_ZERO_BYTE;
8533 dgst_pos0 = 0;
8534 dgst_pos1 = 1;
8535 dgst_pos2 = 2;
8536 dgst_pos3 = 3;
8537 break;
8538
8539 case 6500: hash_type = HASH_TYPE_SHA512;
8540 salt_type = SALT_TYPE_EMBEDDED;
8541 attack_exec = ATTACK_EXEC_ON_CPU;
8542 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8543 kern_type = KERN_TYPE_SHA512AIX;
8544 dgst_size = DGST_SIZE_8_8;
8545 parse_func = sha512aix_parse_hash;
8546 sort_by_digest = sort_by_digest_8_8;
8547 opti_type = OPTI_TYPE_ZERO_BYTE;
8548 dgst_pos0 = 0;
8549 dgst_pos1 = 1;
8550 dgst_pos2 = 2;
8551 dgst_pos3 = 3;
8552 break;
8553
8554 case 6600: hash_type = HASH_TYPE_AES;
8555 salt_type = SALT_TYPE_EMBEDDED;
8556 attack_exec = ATTACK_EXEC_ON_CPU;
8557 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8558 kern_type = KERN_TYPE_AGILEKEY;
8559 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8560 parse_func = agilekey_parse_hash;
8561 sort_by_digest = sort_by_digest_4_5;
8562 opti_type = OPTI_TYPE_ZERO_BYTE;
8563 dgst_pos0 = 0;
8564 dgst_pos1 = 1;
8565 dgst_pos2 = 2;
8566 dgst_pos3 = 3;
8567 break;
8568
8569 case 6700: hash_type = HASH_TYPE_SHA1;
8570 salt_type = SALT_TYPE_EMBEDDED;
8571 attack_exec = ATTACK_EXEC_ON_CPU;
8572 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8573 kern_type = KERN_TYPE_SHA1AIX;
8574 dgst_size = DGST_SIZE_4_5;
8575 parse_func = sha1aix_parse_hash;
8576 sort_by_digest = sort_by_digest_4_5;
8577 opti_type = OPTI_TYPE_ZERO_BYTE;
8578 dgst_pos0 = 0;
8579 dgst_pos1 = 1;
8580 dgst_pos2 = 2;
8581 dgst_pos3 = 3;
8582 break;
8583
8584 case 6800: hash_type = HASH_TYPE_AES;
8585 salt_type = SALT_TYPE_EMBEDDED;
8586 attack_exec = ATTACK_EXEC_ON_CPU;
8587 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8588 kern_type = KERN_TYPE_LASTPASS;
8589 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
8590 parse_func = lastpass_parse_hash;
8591 sort_by_digest = sort_by_digest_4_8;
8592 opti_type = OPTI_TYPE_ZERO_BYTE;
8593 dgst_pos0 = 0;
8594 dgst_pos1 = 1;
8595 dgst_pos2 = 2;
8596 dgst_pos3 = 3;
8597 break;
8598
8599 case 6900: hash_type = HASH_TYPE_GOST;
8600 salt_type = SALT_TYPE_NONE;
8601 attack_exec = ATTACK_EXEC_ON_GPU;
8602 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8603 kern_type = KERN_TYPE_GOST;
8604 dgst_size = DGST_SIZE_4_8;
8605 parse_func = gost_parse_hash;
8606 sort_by_digest = sort_by_digest_4_8;
8607 opti_type = OPTI_TYPE_ZERO_BYTE;
8608 dgst_pos0 = 0;
8609 dgst_pos1 = 1;
8610 dgst_pos2 = 2;
8611 dgst_pos3 = 3;
8612 break;
8613
8614 case 7100: hash_type = HASH_TYPE_SHA512;
8615 salt_type = SALT_TYPE_EMBEDDED;
8616 attack_exec = ATTACK_EXEC_ON_CPU;
8617 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8618 kern_type = KERN_TYPE_PBKDF2_SHA512;
8619 dgst_size = DGST_SIZE_8_16;
8620 parse_func = sha512osx_parse_hash;
8621 sort_by_digest = sort_by_digest_8_16;
8622 opti_type = OPTI_TYPE_ZERO_BYTE;
8623 dgst_pos0 = 0;
8624 dgst_pos1 = 1;
8625 dgst_pos2 = 2;
8626 dgst_pos3 = 3;
8627 break;
8628
8629 case 7200: hash_type = HASH_TYPE_SHA512;
8630 salt_type = SALT_TYPE_EMBEDDED;
8631 attack_exec = ATTACK_EXEC_ON_CPU;
8632 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8633 kern_type = KERN_TYPE_PBKDF2_SHA512;
8634 dgst_size = DGST_SIZE_8_16;
8635 parse_func = sha512grub_parse_hash;
8636 sort_by_digest = sort_by_digest_8_16;
8637 opti_type = OPTI_TYPE_ZERO_BYTE;
8638 dgst_pos0 = 0;
8639 dgst_pos1 = 1;
8640 dgst_pos2 = 2;
8641 dgst_pos3 = 3;
8642 break;
8643
8644 case 7300: hash_type = HASH_TYPE_SHA1;
8645 salt_type = SALT_TYPE_EMBEDDED;
8646 attack_exec = ATTACK_EXEC_ON_GPU;
8647 opts_type = OPTS_TYPE_PT_GENERATE_BE
8648 | OPTS_TYPE_ST_ADD80
8649 | OPTS_TYPE_ST_ADDBITS15;
8650 kern_type = KERN_TYPE_RAKP;
8651 dgst_size = DGST_SIZE_4_5;
8652 parse_func = rakp_parse_hash;
8653 sort_by_digest = sort_by_digest_4_5;
8654 opti_type = OPTI_TYPE_ZERO_BYTE
8655 | OPTI_TYPE_NOT_ITERATED;
8656 dgst_pos0 = 3;
8657 dgst_pos1 = 4;
8658 dgst_pos2 = 2;
8659 dgst_pos3 = 1;
8660 break;
8661
8662 case 7400: hash_type = HASH_TYPE_SHA256;
8663 salt_type = SALT_TYPE_EMBEDDED;
8664 attack_exec = ATTACK_EXEC_ON_CPU;
8665 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8666 kern_type = KERN_TYPE_SHA256CRYPT;
8667 dgst_size = DGST_SIZE_4_8;
8668 parse_func = sha256crypt_parse_hash;
8669 sort_by_digest = sort_by_digest_4_8;
8670 opti_type = OPTI_TYPE_ZERO_BYTE;
8671 dgst_pos0 = 0;
8672 dgst_pos1 = 1;
8673 dgst_pos2 = 2;
8674 dgst_pos3 = 3;
8675 break;
8676
8677 case 7500: hash_type = HASH_TYPE_KRB5PA;
8678 salt_type = SALT_TYPE_EMBEDDED;
8679 attack_exec = ATTACK_EXEC_ON_GPU;
8680 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8681 kern_type = KERN_TYPE_KRB5PA;
8682 dgst_size = DGST_SIZE_4_4;
8683 parse_func = krb5pa_parse_hash;
8684 sort_by_digest = sort_by_digest_4_4;
8685 opti_type = OPTI_TYPE_ZERO_BYTE
8686 | OPTI_TYPE_NOT_ITERATED;
8687 dgst_pos0 = 3;
8688 dgst_pos1 = 7;
8689 dgst_pos2 = 2;
8690 dgst_pos3 = 6;
8691 break;
8692
8693 case 7600: hash_type = HASH_TYPE_SHA1;
8694 salt_type = SALT_TYPE_INTERN;
8695 attack_exec = ATTACK_EXEC_ON_GPU;
8696 opts_type = OPTS_TYPE_PT_GENERATE_BE
8697 | OPTS_TYPE_PT_ADD80
8698 | OPTS_TYPE_PT_ADDBITS15;
8699 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
8700 dgst_size = DGST_SIZE_4_5;
8701 parse_func = redmine_parse_hash;
8702 sort_by_digest = sort_by_digest_4_5;
8703 opti_type = OPTI_TYPE_ZERO_BYTE
8704 | OPTI_TYPE_PRECOMPUTE_INIT
8705 | OPTI_TYPE_EARLY_SKIP
8706 | OPTI_TYPE_NOT_ITERATED
8707 | OPTI_TYPE_PREPENDED_SALT;
8708 dgst_pos0 = 3;
8709 dgst_pos1 = 4;
8710 dgst_pos2 = 2;
8711 dgst_pos3 = 1;
8712 break;
8713
8714 case 7700: hash_type = HASH_TYPE_SAPB;
8715 salt_type = SALT_TYPE_EMBEDDED;
8716 attack_exec = ATTACK_EXEC_ON_GPU;
8717 opts_type = OPTS_TYPE_PT_GENERATE_LE
8718 | OPTS_TYPE_PT_UPPER
8719 | OPTS_TYPE_ST_UPPER;
8720 kern_type = KERN_TYPE_SAPB;
8721 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8722 parse_func = sapb_parse_hash;
8723 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8724 opti_type = OPTI_TYPE_ZERO_BYTE
8725 | OPTI_TYPE_PRECOMPUTE_INIT
8726 | OPTI_TYPE_NOT_ITERATED;
8727 dgst_pos0 = 0;
8728 dgst_pos1 = 1;
8729 dgst_pos2 = 2;
8730 dgst_pos3 = 3;
8731 break;
8732
8733 case 7800: hash_type = HASH_TYPE_SAPG;
8734 salt_type = SALT_TYPE_EMBEDDED;
8735 attack_exec = ATTACK_EXEC_ON_GPU;
8736 opts_type = OPTS_TYPE_PT_GENERATE_BE
8737 | OPTS_TYPE_ST_ADD80
8738 | OPTS_TYPE_ST_UPPER;
8739 kern_type = KERN_TYPE_SAPG;
8740 dgst_size = DGST_SIZE_4_5;
8741 parse_func = sapg_parse_hash;
8742 sort_by_digest = sort_by_digest_4_5;
8743 opti_type = OPTI_TYPE_ZERO_BYTE
8744 | OPTI_TYPE_PRECOMPUTE_INIT
8745 | OPTI_TYPE_NOT_ITERATED;
8746 dgst_pos0 = 3;
8747 dgst_pos1 = 4;
8748 dgst_pos2 = 2;
8749 dgst_pos3 = 1;
8750 break;
8751
8752 case 7900: hash_type = HASH_TYPE_SHA512;
8753 salt_type = SALT_TYPE_EMBEDDED;
8754 attack_exec = ATTACK_EXEC_ON_CPU;
8755 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8756 kern_type = KERN_TYPE_DRUPAL7;
8757 dgst_size = DGST_SIZE_8_8;
8758 parse_func = drupal7_parse_hash;
8759 sort_by_digest = sort_by_digest_8_8;
8760 opti_type = OPTI_TYPE_ZERO_BYTE;
8761 dgst_pos0 = 0;
8762 dgst_pos1 = 1;
8763 dgst_pos2 = 2;
8764 dgst_pos3 = 3;
8765 break;
8766
8767 case 8000: hash_type = HASH_TYPE_SHA256;
8768 salt_type = SALT_TYPE_EMBEDDED;
8769 attack_exec = ATTACK_EXEC_ON_GPU;
8770 opts_type = OPTS_TYPE_PT_GENERATE_BE
8771 | OPTS_TYPE_PT_UNICODE
8772 | OPTS_TYPE_ST_ADD80
8773 | OPTS_TYPE_ST_HEX;
8774 kern_type = KERN_TYPE_SYBASEASE;
8775 dgst_size = DGST_SIZE_4_8;
8776 parse_func = sybasease_parse_hash;
8777 sort_by_digest = sort_by_digest_4_8;
8778 opti_type = OPTI_TYPE_ZERO_BYTE
8779 | OPTI_TYPE_PRECOMPUTE_INIT
8780 | OPTI_TYPE_EARLY_SKIP
8781 | OPTI_TYPE_NOT_ITERATED
8782 | OPTI_TYPE_RAW_HASH;
8783 dgst_pos0 = 3;
8784 dgst_pos1 = 7;
8785 dgst_pos2 = 2;
8786 dgst_pos3 = 6;
8787 break;
8788
8789 case 8100: hash_type = HASH_TYPE_SHA1;
8790 salt_type = SALT_TYPE_EMBEDDED;
8791 attack_exec = ATTACK_EXEC_ON_GPU;
8792 opts_type = OPTS_TYPE_PT_GENERATE_BE;
8793 kern_type = KERN_TYPE_NETSCALER;
8794 dgst_size = DGST_SIZE_4_5;
8795 parse_func = netscaler_parse_hash;
8796 sort_by_digest = sort_by_digest_4_5;
8797 opti_type = OPTI_TYPE_ZERO_BYTE
8798 | OPTI_TYPE_PRECOMPUTE_INIT
8799 | OPTI_TYPE_PRECOMPUTE_MERKLE
8800 | OPTI_TYPE_EARLY_SKIP
8801 | OPTI_TYPE_NOT_ITERATED
8802 | OPTI_TYPE_PREPENDED_SALT
8803 | OPTI_TYPE_RAW_HASH;
8804 dgst_pos0 = 3;
8805 dgst_pos1 = 4;
8806 dgst_pos2 = 2;
8807 dgst_pos3 = 1;
8808 break;
8809
8810 case 8200: hash_type = HASH_TYPE_SHA256;
8811 salt_type = SALT_TYPE_EMBEDDED;
8812 attack_exec = ATTACK_EXEC_ON_CPU;
8813 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8814 kern_type = KERN_TYPE_CLOUDKEY;
8815 dgst_size = DGST_SIZE_4_8;
8816 parse_func = cloudkey_parse_hash;
8817 sort_by_digest = sort_by_digest_4_8;
8818 opti_type = OPTI_TYPE_ZERO_BYTE;
8819 dgst_pos0 = 0;
8820 dgst_pos1 = 1;
8821 dgst_pos2 = 2;
8822 dgst_pos3 = 3;
8823 break;
8824
8825 case 8300: hash_type = HASH_TYPE_SHA1;
8826 salt_type = SALT_TYPE_EMBEDDED;
8827 attack_exec = ATTACK_EXEC_ON_GPU;
8828 opts_type = OPTS_TYPE_PT_GENERATE_LE
8829 | OPTS_TYPE_ST_HEX
8830 | OPTS_TYPE_ST_ADD80;
8831 kern_type = KERN_TYPE_NSEC3;
8832 dgst_size = DGST_SIZE_4_5;
8833 parse_func = nsec3_parse_hash;
8834 sort_by_digest = sort_by_digest_4_5;
8835 opti_type = OPTI_TYPE_ZERO_BYTE;
8836 dgst_pos0 = 3;
8837 dgst_pos1 = 4;
8838 dgst_pos2 = 2;
8839 dgst_pos3 = 1;
8840 break;
8841
8842 case 8400: hash_type = HASH_TYPE_SHA1;
8843 salt_type = SALT_TYPE_INTERN;
8844 attack_exec = ATTACK_EXEC_ON_GPU;
8845 opts_type = OPTS_TYPE_PT_GENERATE_BE
8846 | OPTS_TYPE_PT_ADD80
8847 | OPTS_TYPE_PT_ADDBITS15;
8848 kern_type = KERN_TYPE_WBB3;
8849 dgst_size = DGST_SIZE_4_5;
8850 parse_func = wbb3_parse_hash;
8851 sort_by_digest = sort_by_digest_4_5;
8852 opti_type = OPTI_TYPE_ZERO_BYTE
8853 | OPTI_TYPE_PRECOMPUTE_INIT
8854 | OPTI_TYPE_NOT_ITERATED;
8855 dgst_pos0 = 3;
8856 dgst_pos1 = 4;
8857 dgst_pos2 = 2;
8858 dgst_pos3 = 1;
8859 break;
8860
8861 case 8500: hash_type = HASH_TYPE_DESRACF;
8862 salt_type = SALT_TYPE_EMBEDDED;
8863 attack_exec = ATTACK_EXEC_ON_GPU;
8864 opts_type = OPTS_TYPE_PT_GENERATE_LE
8865 | OPTS_TYPE_ST_UPPER;
8866 kern_type = KERN_TYPE_RACF;
8867 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8868 parse_func = racf_parse_hash;
8869 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8870 opti_type = OPTI_TYPE_ZERO_BYTE
8871 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8872 dgst_pos0 = 0;
8873 dgst_pos1 = 1;
8874 dgst_pos2 = 2;
8875 dgst_pos3 = 3;
8876 break;
8877
8878 case 8600: hash_type = HASH_TYPE_LOTUS5;
8879 salt_type = SALT_TYPE_NONE;
8880 attack_exec = ATTACK_EXEC_ON_GPU;
8881 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8882 kern_type = KERN_TYPE_LOTUS5;
8883 dgst_size = DGST_SIZE_4_4;
8884 parse_func = lotus5_parse_hash;
8885 sort_by_digest = sort_by_digest_4_4;
8886 opti_type = OPTI_TYPE_EARLY_SKIP
8887 | OPTI_TYPE_NOT_ITERATED
8888 | OPTI_TYPE_NOT_SALTED
8889 | OPTI_TYPE_RAW_HASH;
8890 dgst_pos0 = 0;
8891 dgst_pos1 = 1;
8892 dgst_pos2 = 2;
8893 dgst_pos3 = 3;
8894 break;
8895
8896 case 8700: hash_type = HASH_TYPE_LOTUS6;
8897 salt_type = SALT_TYPE_EMBEDDED;
8898 attack_exec = ATTACK_EXEC_ON_GPU;
8899 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8900 kern_type = KERN_TYPE_LOTUS6;
8901 dgst_size = DGST_SIZE_4_4;
8902 parse_func = lotus6_parse_hash;
8903 sort_by_digest = sort_by_digest_4_4;
8904 opti_type = OPTI_TYPE_EARLY_SKIP
8905 | OPTI_TYPE_NOT_ITERATED
8906 | OPTI_TYPE_RAW_HASH;
8907 dgst_pos0 = 0;
8908 dgst_pos1 = 1;
8909 dgst_pos2 = 2;
8910 dgst_pos3 = 3;
8911 break;
8912
8913 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
8914 salt_type = SALT_TYPE_EMBEDDED;
8915 attack_exec = ATTACK_EXEC_ON_CPU;
8916 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8917 kern_type = KERN_TYPE_ANDROIDFDE;
8918 dgst_size = DGST_SIZE_4_4;
8919 parse_func = androidfde_parse_hash;
8920 sort_by_digest = sort_by_digest_4_4;
8921 opti_type = OPTI_TYPE_ZERO_BYTE;
8922 dgst_pos0 = 0;
8923 dgst_pos1 = 1;
8924 dgst_pos2 = 2;
8925 dgst_pos3 = 3;
8926 break;
8927
8928 case 8900: hash_type = HASH_TYPE_SCRYPT;
8929 salt_type = SALT_TYPE_EMBEDDED;
8930 attack_exec = ATTACK_EXEC_ON_CPU;
8931 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8932 kern_type = KERN_TYPE_SCRYPT;
8933 dgst_size = DGST_SIZE_4_8;
8934 parse_func = scrypt_parse_hash;
8935 sort_by_digest = sort_by_digest_4_8;
8936 opti_type = OPTI_TYPE_ZERO_BYTE;
8937 dgst_pos0 = 0;
8938 dgst_pos1 = 1;
8939 dgst_pos2 = 2;
8940 dgst_pos3 = 3;
8941 break;
8942
8943 case 9000: hash_type = HASH_TYPE_SHA1;
8944 salt_type = SALT_TYPE_EMBEDDED;
8945 attack_exec = ATTACK_EXEC_ON_CPU;
8946 opts_type = OPTS_TYPE_PT_GENERATE_LE
8947 | OPTS_TYPE_ST_GENERATE_LE;
8948 kern_type = KERN_TYPE_PSAFE2;
8949 dgst_size = DGST_SIZE_4_5;
8950 parse_func = psafe2_parse_hash;
8951 sort_by_digest = sort_by_digest_4_5;
8952 opti_type = OPTI_TYPE_ZERO_BYTE;
8953 dgst_pos0 = 0;
8954 dgst_pos1 = 1;
8955 dgst_pos2 = 2;
8956 dgst_pos3 = 3;
8957 break;
8958
8959 case 9100: hash_type = HASH_TYPE_LOTUS8;
8960 salt_type = SALT_TYPE_EMBEDDED;
8961 attack_exec = ATTACK_EXEC_ON_CPU;
8962 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8963 kern_type = KERN_TYPE_LOTUS8;
8964 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8965 parse_func = lotus8_parse_hash;
8966 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8967 opti_type = OPTI_TYPE_ZERO_BYTE;
8968 dgst_pos0 = 0;
8969 dgst_pos1 = 1;
8970 dgst_pos2 = 2;
8971 dgst_pos3 = 3;
8972 break;
8973
8974 case 9200: hash_type = HASH_TYPE_SHA256;
8975 salt_type = SALT_TYPE_EMBEDDED;
8976 attack_exec = ATTACK_EXEC_ON_CPU;
8977 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8978 kern_type = KERN_TYPE_PBKDF2_SHA256;
8979 dgst_size = DGST_SIZE_4_32;
8980 parse_func = cisco8_parse_hash;
8981 sort_by_digest = sort_by_digest_4_32;
8982 opti_type = OPTI_TYPE_ZERO_BYTE;
8983 dgst_pos0 = 0;
8984 dgst_pos1 = 1;
8985 dgst_pos2 = 2;
8986 dgst_pos3 = 3;
8987 break;
8988
8989 case 9300: hash_type = HASH_TYPE_SCRYPT;
8990 salt_type = SALT_TYPE_EMBEDDED;
8991 attack_exec = ATTACK_EXEC_ON_CPU;
8992 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8993 kern_type = KERN_TYPE_SCRYPT;
8994 dgst_size = DGST_SIZE_4_8;
8995 parse_func = cisco9_parse_hash;
8996 sort_by_digest = sort_by_digest_4_8;
8997 opti_type = OPTI_TYPE_ZERO_BYTE;
8998 dgst_pos0 = 0;
8999 dgst_pos1 = 1;
9000 dgst_pos2 = 2;
9001 dgst_pos3 = 3;
9002 break;
9003
9004 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9005 salt_type = SALT_TYPE_EMBEDDED;
9006 attack_exec = ATTACK_EXEC_ON_CPU;
9007 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9008 kern_type = KERN_TYPE_OFFICE2007;
9009 dgst_size = DGST_SIZE_4_4;
9010 parse_func = office2007_parse_hash;
9011 sort_by_digest = sort_by_digest_4_4;
9012 opti_type = OPTI_TYPE_ZERO_BYTE;
9013 dgst_pos0 = 0;
9014 dgst_pos1 = 1;
9015 dgst_pos2 = 2;
9016 dgst_pos3 = 3;
9017 break;
9018
9019 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9020 salt_type = SALT_TYPE_EMBEDDED;
9021 attack_exec = ATTACK_EXEC_ON_CPU;
9022 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9023 kern_type = KERN_TYPE_OFFICE2010;
9024 dgst_size = DGST_SIZE_4_4;
9025 parse_func = office2010_parse_hash;
9026 sort_by_digest = sort_by_digest_4_4;
9027 opti_type = OPTI_TYPE_ZERO_BYTE;
9028 dgst_pos0 = 0;
9029 dgst_pos1 = 1;
9030 dgst_pos2 = 2;
9031 dgst_pos3 = 3;
9032 break;
9033
9034 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9035 salt_type = SALT_TYPE_EMBEDDED;
9036 attack_exec = ATTACK_EXEC_ON_CPU;
9037 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9038 kern_type = KERN_TYPE_OFFICE2013;
9039 dgst_size = DGST_SIZE_4_4;
9040 parse_func = office2013_parse_hash;
9041 sort_by_digest = sort_by_digest_4_4;
9042 opti_type = OPTI_TYPE_ZERO_BYTE;
9043 dgst_pos0 = 0;
9044 dgst_pos1 = 1;
9045 dgst_pos2 = 2;
9046 dgst_pos3 = 3;
9047 break;
9048
9049 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9050 salt_type = SALT_TYPE_EMBEDDED;
9051 attack_exec = ATTACK_EXEC_ON_GPU;
9052 opts_type = OPTS_TYPE_PT_GENERATE_LE
9053 | OPTS_TYPE_PT_ADD80
9054 | OPTS_TYPE_PT_UNICODE;
9055 kern_type = KERN_TYPE_OLDOFFICE01;
9056 dgst_size = DGST_SIZE_4_4;
9057 parse_func = oldoffice01_parse_hash;
9058 sort_by_digest = sort_by_digest_4_4;
9059 opti_type = OPTI_TYPE_ZERO_BYTE
9060 | OPTI_TYPE_PRECOMPUTE_INIT
9061 | OPTI_TYPE_NOT_ITERATED;
9062 dgst_pos0 = 0;
9063 dgst_pos1 = 1;
9064 dgst_pos2 = 2;
9065 dgst_pos3 = 3;
9066 break;
9067
9068 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9069 salt_type = SALT_TYPE_EMBEDDED;
9070 attack_exec = ATTACK_EXEC_ON_GPU;
9071 opts_type = OPTS_TYPE_PT_GENERATE_LE
9072 | OPTS_TYPE_PT_ADD80;
9073 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9074 dgst_size = DGST_SIZE_4_4;
9075 parse_func = oldoffice01cm1_parse_hash;
9076 sort_by_digest = sort_by_digest_4_4;
9077 opti_type = OPTI_TYPE_ZERO_BYTE
9078 | OPTI_TYPE_PRECOMPUTE_INIT
9079 | OPTI_TYPE_NOT_ITERATED;
9080 dgst_pos0 = 0;
9081 dgst_pos1 = 1;
9082 dgst_pos2 = 2;
9083 dgst_pos3 = 3;
9084 break;
9085
9086 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9087 salt_type = SALT_TYPE_EMBEDDED;
9088 attack_exec = ATTACK_EXEC_ON_GPU;
9089 opts_type = OPTS_TYPE_PT_GENERATE_LE
9090 | OPTS_TYPE_PT_ADD80
9091 | OPTS_TYPE_PT_UNICODE
9092 | OPTS_TYPE_PT_NEVERCRACK;
9093 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9094 dgst_size = DGST_SIZE_4_4;
9095 parse_func = oldoffice01cm2_parse_hash;
9096 sort_by_digest = sort_by_digest_4_4;
9097 opti_type = OPTI_TYPE_ZERO_BYTE
9098 | OPTI_TYPE_PRECOMPUTE_INIT
9099 | OPTI_TYPE_NOT_ITERATED;
9100 dgst_pos0 = 0;
9101 dgst_pos1 = 1;
9102 dgst_pos2 = 2;
9103 dgst_pos3 = 3;
9104 break;
9105
9106 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9107 salt_type = SALT_TYPE_EMBEDDED;
9108 attack_exec = ATTACK_EXEC_ON_GPU;
9109 opts_type = OPTS_TYPE_PT_GENERATE_BE
9110 | OPTS_TYPE_PT_ADD80
9111 | OPTS_TYPE_PT_UNICODE;
9112 kern_type = KERN_TYPE_OLDOFFICE34;
9113 dgst_size = DGST_SIZE_4_4;
9114 parse_func = oldoffice34_parse_hash;
9115 sort_by_digest = sort_by_digest_4_4;
9116 opti_type = OPTI_TYPE_ZERO_BYTE
9117 | OPTI_TYPE_PRECOMPUTE_INIT
9118 | OPTI_TYPE_NOT_ITERATED;
9119 dgst_pos0 = 0;
9120 dgst_pos1 = 1;
9121 dgst_pos2 = 2;
9122 dgst_pos3 = 3;
9123 break;
9124
9125 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9126 salt_type = SALT_TYPE_EMBEDDED;
9127 attack_exec = ATTACK_EXEC_ON_GPU;
9128 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9129 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9130 dgst_size = DGST_SIZE_4_4;
9131 parse_func = oldoffice34cm1_parse_hash;
9132 sort_by_digest = sort_by_digest_4_4;
9133 opti_type = OPTI_TYPE_ZERO_BYTE
9134 | OPTI_TYPE_PRECOMPUTE_INIT
9135 | OPTI_TYPE_NOT_ITERATED;
9136 dgst_pos0 = 0;
9137 dgst_pos1 = 1;
9138 dgst_pos2 = 2;
9139 dgst_pos3 = 3;
9140 break;
9141
9142 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9143 salt_type = SALT_TYPE_EMBEDDED;
9144 attack_exec = ATTACK_EXEC_ON_GPU;
9145 opts_type = OPTS_TYPE_PT_GENERATE_BE
9146 | OPTS_TYPE_PT_ADD80
9147 | OPTS_TYPE_PT_UNICODE
9148 | OPTS_TYPE_PT_NEVERCRACK;
9149 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9150 dgst_size = DGST_SIZE_4_4;
9151 parse_func = oldoffice34cm2_parse_hash;
9152 sort_by_digest = sort_by_digest_4_4;
9153 opti_type = OPTI_TYPE_ZERO_BYTE
9154 | OPTI_TYPE_PRECOMPUTE_INIT
9155 | OPTI_TYPE_NOT_ITERATED;
9156 dgst_pos0 = 0;
9157 dgst_pos1 = 1;
9158 dgst_pos2 = 2;
9159 dgst_pos3 = 3;
9160 break;
9161
9162 case 9900: hash_type = HASH_TYPE_MD5;
9163 salt_type = SALT_TYPE_NONE;
9164 attack_exec = ATTACK_EXEC_ON_GPU;
9165 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9166 kern_type = KERN_TYPE_RADMIN2;
9167 dgst_size = DGST_SIZE_4_4;
9168 parse_func = radmin2_parse_hash;
9169 sort_by_digest = sort_by_digest_4_4;
9170 opti_type = OPTI_TYPE_ZERO_BYTE
9171 | OPTI_TYPE_PRECOMPUTE_INIT
9172 | OPTI_TYPE_EARLY_SKIP
9173 | OPTI_TYPE_NOT_ITERATED
9174 | OPTI_TYPE_NOT_SALTED;
9175 dgst_pos0 = 0;
9176 dgst_pos1 = 3;
9177 dgst_pos2 = 2;
9178 dgst_pos3 = 1;
9179 break;
9180
9181 case 10000: hash_type = HASH_TYPE_SHA256;
9182 salt_type = SALT_TYPE_EMBEDDED;
9183 attack_exec = ATTACK_EXEC_ON_CPU;
9184 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9185 kern_type = KERN_TYPE_PBKDF2_SHA256;
9186 dgst_size = DGST_SIZE_4_32;
9187 parse_func = djangopbkdf2_parse_hash;
9188 sort_by_digest = sort_by_digest_4_32;
9189 opti_type = OPTI_TYPE_ZERO_BYTE;
9190 dgst_pos0 = 0;
9191 dgst_pos1 = 1;
9192 dgst_pos2 = 2;
9193 dgst_pos3 = 3;
9194 break;
9195
9196 case 10100: hash_type = HASH_TYPE_SIPHASH;
9197 salt_type = SALT_TYPE_EMBEDDED;
9198 attack_exec = ATTACK_EXEC_ON_GPU;
9199 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9200 kern_type = KERN_TYPE_SIPHASH;
9201 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9202 parse_func = siphash_parse_hash;
9203 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9204 opti_type = OPTI_TYPE_ZERO_BYTE
9205 | OPTI_TYPE_NOT_ITERATED
9206 | OPTI_TYPE_RAW_HASH;
9207 dgst_pos0 = 0;
9208 dgst_pos1 = 1;
9209 dgst_pos2 = 2;
9210 dgst_pos3 = 3;
9211 break;
9212
9213 case 10200: hash_type = HASH_TYPE_MD5;
9214 salt_type = SALT_TYPE_EMBEDDED;
9215 attack_exec = ATTACK_EXEC_ON_GPU;
9216 opts_type = OPTS_TYPE_PT_GENERATE_LE
9217 | OPTS_TYPE_ST_ADD80
9218 | OPTS_TYPE_ST_ADDBITS14;
9219 kern_type = KERN_TYPE_HMACMD5_PW;
9220 dgst_size = DGST_SIZE_4_4;
9221 parse_func = crammd5_parse_hash;
9222 sort_by_digest = sort_by_digest_4_4;
9223 opti_type = OPTI_TYPE_ZERO_BYTE
9224 | OPTI_TYPE_NOT_ITERATED;
9225 dgst_pos0 = 0;
9226 dgst_pos1 = 3;
9227 dgst_pos2 = 2;
9228 dgst_pos3 = 1;
9229 break;
9230
9231 case 10300: hash_type = HASH_TYPE_SHA1;
9232 salt_type = SALT_TYPE_EMBEDDED;
9233 attack_exec = ATTACK_EXEC_ON_CPU;
9234 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9235 kern_type = KERN_TYPE_SAPH_SHA1;
9236 dgst_size = DGST_SIZE_4_5;
9237 parse_func = saph_sha1_parse_hash;
9238 sort_by_digest = sort_by_digest_4_5;
9239 opti_type = OPTI_TYPE_ZERO_BYTE;
9240 dgst_pos0 = 0;
9241 dgst_pos1 = 1;
9242 dgst_pos2 = 2;
9243 dgst_pos3 = 3;
9244 break;
9245
9246 case 10400: hash_type = HASH_TYPE_PDFU16;
9247 salt_type = SALT_TYPE_EMBEDDED;
9248 attack_exec = ATTACK_EXEC_ON_GPU;
9249 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9250 kern_type = KERN_TYPE_PDF11;
9251 dgst_size = DGST_SIZE_4_4;
9252 parse_func = pdf11_parse_hash;
9253 sort_by_digest = sort_by_digest_4_4;
9254 opti_type = OPTI_TYPE_ZERO_BYTE
9255 | OPTI_TYPE_NOT_ITERATED;
9256 dgst_pos0 = 0;
9257 dgst_pos1 = 1;
9258 dgst_pos2 = 2;
9259 dgst_pos3 = 3;
9260 break;
9261
9262 case 10410: hash_type = HASH_TYPE_PDFU16;
9263 salt_type = SALT_TYPE_EMBEDDED;
9264 attack_exec = ATTACK_EXEC_ON_GPU;
9265 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9266 kern_type = KERN_TYPE_PDF11CM1;
9267 dgst_size = DGST_SIZE_4_4;
9268 parse_func = pdf11cm1_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 = 1;
9274 dgst_pos2 = 2;
9275 dgst_pos3 = 3;
9276 break;
9277
9278 case 10420: hash_type = HASH_TYPE_PDFU16;
9279 salt_type = SALT_TYPE_EMBEDDED;
9280 attack_exec = ATTACK_EXEC_ON_GPU;
9281 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9282 kern_type = KERN_TYPE_PDF11CM2;
9283 dgst_size = DGST_SIZE_4_4;
9284 parse_func = pdf11cm2_parse_hash;
9285 sort_by_digest = sort_by_digest_4_4;
9286 opti_type = OPTI_TYPE_ZERO_BYTE
9287 | OPTI_TYPE_NOT_ITERATED;
9288 dgst_pos0 = 0;
9289 dgst_pos1 = 1;
9290 dgst_pos2 = 2;
9291 dgst_pos3 = 3;
9292 break;
9293
9294 case 10500: hash_type = HASH_TYPE_PDFU16;
9295 salt_type = SALT_TYPE_EMBEDDED;
9296 attack_exec = ATTACK_EXEC_ON_CPU;
9297 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9298 kern_type = KERN_TYPE_PDF14;
9299 dgst_size = DGST_SIZE_4_4;
9300 parse_func = pdf14_parse_hash;
9301 sort_by_digest = sort_by_digest_4_4;
9302 opti_type = OPTI_TYPE_ZERO_BYTE
9303 | OPTI_TYPE_NOT_ITERATED;
9304 dgst_pos0 = 0;
9305 dgst_pos1 = 1;
9306 dgst_pos2 = 2;
9307 dgst_pos3 = 3;
9308 break;
9309
9310 case 10600: hash_type = HASH_TYPE_SHA256;
9311 salt_type = SALT_TYPE_EMBEDDED;
9312 attack_exec = ATTACK_EXEC_ON_GPU;
9313 opts_type = OPTS_TYPE_PT_GENERATE_BE
9314 | OPTS_TYPE_ST_ADD80
9315 | OPTS_TYPE_ST_ADDBITS15
9316 | OPTS_TYPE_HASH_COPY;
9317 kern_type = KERN_TYPE_SHA256_PWSLT;
9318 dgst_size = DGST_SIZE_4_8;
9319 parse_func = pdf17l3_parse_hash;
9320 sort_by_digest = sort_by_digest_4_8;
9321 opti_type = OPTI_TYPE_ZERO_BYTE
9322 | OPTI_TYPE_PRECOMPUTE_INIT
9323 | OPTI_TYPE_PRECOMPUTE_MERKLE
9324 | OPTI_TYPE_EARLY_SKIP
9325 | OPTI_TYPE_NOT_ITERATED
9326 | OPTI_TYPE_APPENDED_SALT
9327 | OPTI_TYPE_RAW_HASH;
9328 dgst_pos0 = 3;
9329 dgst_pos1 = 7;
9330 dgst_pos2 = 2;
9331 dgst_pos3 = 6;
9332 break;
9333
9334 case 10700: hash_type = HASH_TYPE_PDFU32;
9335 salt_type = SALT_TYPE_EMBEDDED;
9336 attack_exec = ATTACK_EXEC_ON_CPU;
9337 opts_type = OPTS_TYPE_PT_GENERATE_LE
9338 | OPTS_TYPE_HASH_COPY;
9339 kern_type = KERN_TYPE_PDF17L8;
9340 dgst_size = DGST_SIZE_4_8;
9341 parse_func = pdf17l8_parse_hash;
9342 sort_by_digest = sort_by_digest_4_8;
9343 opti_type = OPTI_TYPE_ZERO_BYTE
9344 | OPTI_TYPE_NOT_ITERATED;
9345 dgst_pos0 = 0;
9346 dgst_pos1 = 1;
9347 dgst_pos2 = 2;
9348 dgst_pos3 = 3;
9349 break;
9350
9351 case 10800: hash_type = HASH_TYPE_SHA384;
9352 salt_type = SALT_TYPE_NONE;
9353 attack_exec = ATTACK_EXEC_ON_GPU;
9354 opts_type = OPTS_TYPE_PT_GENERATE_BE
9355 | OPTS_TYPE_PT_ADD80
9356 | OPTS_TYPE_PT_ADDBITS15;
9357 kern_type = KERN_TYPE_SHA384;
9358 dgst_size = DGST_SIZE_8_8;
9359 parse_func = sha384_parse_hash;
9360 sort_by_digest = sort_by_digest_8_8;
9361 opti_type = OPTI_TYPE_ZERO_BYTE
9362 | OPTI_TYPE_PRECOMPUTE_INIT
9363 | OPTI_TYPE_PRECOMPUTE_MERKLE
9364 | OPTI_TYPE_EARLY_SKIP
9365 | OPTI_TYPE_NOT_ITERATED
9366 | OPTI_TYPE_NOT_SALTED
9367 | OPTI_TYPE_RAW_HASH;
9368 dgst_pos0 = 6;
9369 dgst_pos1 = 7;
9370 dgst_pos2 = 4;
9371 dgst_pos3 = 5;
9372 break;
9373
9374 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9375 salt_type = SALT_TYPE_EMBEDDED;
9376 attack_exec = ATTACK_EXEC_ON_CPU;
9377 opts_type = OPTS_TYPE_PT_GENERATE_LE
9378 | OPTS_TYPE_ST_BASE64
9379 | OPTS_TYPE_HASH_COPY;
9380 kern_type = KERN_TYPE_PBKDF2_SHA256;
9381 dgst_size = DGST_SIZE_4_32;
9382 parse_func = pbkdf2_sha256_parse_hash;
9383 sort_by_digest = sort_by_digest_4_32;
9384 opti_type = OPTI_TYPE_ZERO_BYTE;
9385 dgst_pos0 = 0;
9386 dgst_pos1 = 1;
9387 dgst_pos2 = 2;
9388 dgst_pos3 = 3;
9389 break;
9390
9391 case 11000: hash_type = HASH_TYPE_MD5;
9392 salt_type = SALT_TYPE_INTERN;
9393 attack_exec = ATTACK_EXEC_ON_GPU;
9394 opts_type = OPTS_TYPE_PT_GENERATE_LE
9395 | OPTS_TYPE_PT_ADD80;
9396 kern_type = KERN_TYPE_PRESTASHOP;
9397 dgst_size = DGST_SIZE_4_4;
9398 parse_func = prestashop_parse_hash;
9399 sort_by_digest = sort_by_digest_4_4;
9400 opti_type = OPTI_TYPE_ZERO_BYTE
9401 | OPTI_TYPE_PRECOMPUTE_INIT
9402 | OPTI_TYPE_NOT_ITERATED
9403 | OPTI_TYPE_PREPENDED_SALT;
9404 dgst_pos0 = 0;
9405 dgst_pos1 = 3;
9406 dgst_pos2 = 2;
9407 dgst_pos3 = 1;
9408 break;
9409
9410 case 11100: hash_type = HASH_TYPE_MD5;
9411 salt_type = SALT_TYPE_EMBEDDED;
9412 attack_exec = ATTACK_EXEC_ON_GPU;
9413 opts_type = OPTS_TYPE_PT_GENERATE_LE
9414 | OPTS_TYPE_ST_ADD80;
9415 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9416 dgst_size = DGST_SIZE_4_4;
9417 parse_func = postgresql_auth_parse_hash;
9418 sort_by_digest = sort_by_digest_4_4;
9419 opti_type = OPTI_TYPE_ZERO_BYTE
9420 | OPTI_TYPE_PRECOMPUTE_INIT
9421 | OPTI_TYPE_PRECOMPUTE_MERKLE
9422 | OPTI_TYPE_EARLY_SKIP;
9423 dgst_pos0 = 0;
9424 dgst_pos1 = 3;
9425 dgst_pos2 = 2;
9426 dgst_pos3 = 1;
9427 break;
9428
9429 case 11200: hash_type = HASH_TYPE_SHA1;
9430 salt_type = SALT_TYPE_EMBEDDED;
9431 attack_exec = ATTACK_EXEC_ON_GPU;
9432 opts_type = OPTS_TYPE_PT_GENERATE_BE
9433 | OPTS_TYPE_PT_ADD80
9434 | OPTS_TYPE_ST_HEX;
9435 kern_type = KERN_TYPE_MYSQL_AUTH;
9436 dgst_size = DGST_SIZE_4_5;
9437 parse_func = mysql_auth_parse_hash;
9438 sort_by_digest = sort_by_digest_4_5;
9439 opti_type = OPTI_TYPE_ZERO_BYTE
9440 | OPTI_TYPE_EARLY_SKIP;
9441 dgst_pos0 = 3;
9442 dgst_pos1 = 4;
9443 dgst_pos2 = 2;
9444 dgst_pos3 = 1;
9445 break;
9446
9447 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9448 salt_type = SALT_TYPE_EMBEDDED;
9449 attack_exec = ATTACK_EXEC_ON_CPU;
9450 opts_type = OPTS_TYPE_PT_GENERATE_LE
9451 | OPTS_TYPE_ST_HEX
9452 | OPTS_TYPE_ST_ADD80;
9453 kern_type = KERN_TYPE_BITCOIN_WALLET;
9454 dgst_size = DGST_SIZE_4_4;
9455 parse_func = bitcoin_wallet_parse_hash;
9456 sort_by_digest = sort_by_digest_4_4;
9457 opti_type = OPTI_TYPE_ZERO_BYTE;
9458 dgst_pos0 = 0;
9459 dgst_pos1 = 1;
9460 dgst_pos2 = 2;
9461 dgst_pos3 = 3;
9462 break;
9463
9464 case 11400: hash_type = HASH_TYPE_MD5;
9465 salt_type = SALT_TYPE_EMBEDDED;
9466 attack_exec = ATTACK_EXEC_ON_GPU;
9467 opts_type = OPTS_TYPE_PT_GENERATE_LE
9468 | OPTS_TYPE_PT_ADD80
9469 | OPTS_TYPE_HASH_COPY;
9470 kern_type = KERN_TYPE_SIP_AUTH;
9471 dgst_size = DGST_SIZE_4_4;
9472 parse_func = sip_auth_parse_hash;
9473 sort_by_digest = sort_by_digest_4_4;
9474 opti_type = OPTI_TYPE_ZERO_BYTE;
9475 dgst_pos0 = 0;
9476 dgst_pos1 = 3;
9477 dgst_pos2 = 2;
9478 dgst_pos3 = 1;
9479 break;
9480
9481 case 11500: hash_type = HASH_TYPE_CRC32;
9482 salt_type = SALT_TYPE_INTERN;
9483 attack_exec = ATTACK_EXEC_ON_GPU;
9484 opts_type = OPTS_TYPE_PT_GENERATE_LE
9485 | OPTS_TYPE_ST_GENERATE_LE
9486 | OPTS_TYPE_ST_HEX;
9487 kern_type = KERN_TYPE_CRC32;
9488 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9489 parse_func = crc32_parse_hash;
9490 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9491 opti_type = OPTI_TYPE_ZERO_BYTE;
9492 dgst_pos0 = 0;
9493 dgst_pos1 = 1;
9494 dgst_pos2 = 2;
9495 dgst_pos3 = 3;
9496 break;
9497
9498 case 11600: hash_type = HASH_TYPE_AES;
9499 salt_type = SALT_TYPE_EMBEDDED;
9500 attack_exec = ATTACK_EXEC_ON_CPU;
9501 opts_type = OPTS_TYPE_PT_GENERATE_LE
9502 | OPTS_TYPE_PT_NEVERCRACK;
9503 kern_type = KERN_TYPE_SEVEN_ZIP;
9504 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9505 parse_func = seven_zip_parse_hash;
9506 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9507 opti_type = OPTI_TYPE_ZERO_BYTE;
9508 dgst_pos0 = 0;
9509 dgst_pos1 = 1;
9510 dgst_pos2 = 2;
9511 dgst_pos3 = 3;
9512 break;
9513
9514 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9515 salt_type = SALT_TYPE_NONE;
9516 attack_exec = ATTACK_EXEC_ON_GPU;
9517 opts_type = OPTS_TYPE_PT_GENERATE_LE
9518 | OPTS_TYPE_PT_ADD01;
9519 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9520 dgst_size = DGST_SIZE_4_8;
9521 parse_func = gost2012sbog_256_parse_hash;
9522 sort_by_digest = sort_by_digest_4_8;
9523 opti_type = OPTI_TYPE_ZERO_BYTE;
9524 dgst_pos0 = 0;
9525 dgst_pos1 = 1;
9526 dgst_pos2 = 2;
9527 dgst_pos3 = 3;
9528 break;
9529
9530 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9531 salt_type = SALT_TYPE_NONE;
9532 attack_exec = ATTACK_EXEC_ON_GPU;
9533 opts_type = OPTS_TYPE_PT_GENERATE_LE
9534 | OPTS_TYPE_PT_ADD01;
9535 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9536 dgst_size = DGST_SIZE_4_16;
9537 parse_func = gost2012sbog_512_parse_hash;
9538 sort_by_digest = sort_by_digest_4_16;
9539 opti_type = OPTI_TYPE_ZERO_BYTE;
9540 dgst_pos0 = 0;
9541 dgst_pos1 = 1;
9542 dgst_pos2 = 2;
9543 dgst_pos3 = 3;
9544 break;
9545
9546 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9547 salt_type = SALT_TYPE_EMBEDDED;
9548 attack_exec = ATTACK_EXEC_ON_CPU;
9549 opts_type = OPTS_TYPE_PT_GENERATE_LE
9550 | OPTS_TYPE_ST_BASE64
9551 | OPTS_TYPE_HASH_COPY;
9552 kern_type = KERN_TYPE_PBKDF2_MD5;
9553 dgst_size = DGST_SIZE_4_32;
9554 parse_func = pbkdf2_md5_parse_hash;
9555 sort_by_digest = sort_by_digest_4_32;
9556 opti_type = OPTI_TYPE_ZERO_BYTE;
9557 dgst_pos0 = 0;
9558 dgst_pos1 = 1;
9559 dgst_pos2 = 2;
9560 dgst_pos3 = 3;
9561 break;
9562
9563 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
9564 salt_type = SALT_TYPE_EMBEDDED;
9565 attack_exec = ATTACK_EXEC_ON_CPU;
9566 opts_type = OPTS_TYPE_PT_GENERATE_LE
9567 | OPTS_TYPE_ST_BASE64
9568 | OPTS_TYPE_HASH_COPY;
9569 kern_type = KERN_TYPE_PBKDF2_SHA1;
9570 dgst_size = DGST_SIZE_4_32;
9571 parse_func = pbkdf2_sha1_parse_hash;
9572 sort_by_digest = sort_by_digest_4_32;
9573 opti_type = OPTI_TYPE_ZERO_BYTE;
9574 dgst_pos0 = 0;
9575 dgst_pos1 = 1;
9576 dgst_pos2 = 2;
9577 dgst_pos3 = 3;
9578 break;
9579
9580 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
9581 salt_type = SALT_TYPE_EMBEDDED;
9582 attack_exec = ATTACK_EXEC_ON_CPU;
9583 opts_type = OPTS_TYPE_PT_GENERATE_LE
9584 | OPTS_TYPE_ST_BASE64
9585 | OPTS_TYPE_HASH_COPY;
9586 kern_type = KERN_TYPE_PBKDF2_SHA512;
9587 dgst_size = DGST_SIZE_8_16;
9588 parse_func = pbkdf2_sha512_parse_hash;
9589 sort_by_digest = sort_by_digest_8_16;
9590 opti_type = OPTI_TYPE_ZERO_BYTE;
9591 dgst_pos0 = 0;
9592 dgst_pos1 = 1;
9593 dgst_pos2 = 2;
9594 dgst_pos3 = 3;
9595 break;
9596
9597 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
9598 salt_type = SALT_TYPE_EMBEDDED;
9599 attack_exec = ATTACK_EXEC_ON_CPU;
9600 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9601 kern_type = KERN_TYPE_ECRYPTFS;
9602 dgst_size = DGST_SIZE_8_8;
9603 parse_func = ecryptfs_parse_hash;
9604 sort_by_digest = sort_by_digest_8_8;
9605 opti_type = OPTI_TYPE_ZERO_BYTE;
9606 dgst_pos0 = 0;
9607 dgst_pos1 = 1;
9608 dgst_pos2 = 2;
9609 dgst_pos3 = 3;
9610 break;
9611
9612 case 12300: hash_type = HASH_TYPE_ORACLET;
9613 salt_type = SALT_TYPE_EMBEDDED;
9614 attack_exec = ATTACK_EXEC_ON_CPU;
9615 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9616 kern_type = KERN_TYPE_ORACLET;
9617 dgst_size = DGST_SIZE_8_16;
9618 parse_func = oraclet_parse_hash;
9619 sort_by_digest = sort_by_digest_8_16;
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 12400: hash_type = HASH_TYPE_BSDICRYPT;
9628 salt_type = SALT_TYPE_EMBEDDED;
9629 attack_exec = ATTACK_EXEC_ON_CPU;
9630 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9631 kern_type = KERN_TYPE_BSDICRYPT;
9632 dgst_size = DGST_SIZE_4_4;
9633 parse_func = bsdicrypt_parse_hash;
9634 sort_by_digest = sort_by_digest_4_4;
9635 opti_type = OPTI_TYPE_ZERO_BYTE
9636 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9637 dgst_pos0 = 0;
9638 dgst_pos1 = 1;
9639 dgst_pos2 = 2;
9640 dgst_pos3 = 3;
9641 break;
9642
9643 case 12500: hash_type = HASH_TYPE_RAR3HP;
9644 salt_type = SALT_TYPE_EMBEDDED;
9645 attack_exec = ATTACK_EXEC_ON_CPU;
9646 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9647 kern_type = KERN_TYPE_RAR3;
9648 dgst_size = DGST_SIZE_4_4;
9649 parse_func = rar3hp_parse_hash;
9650 sort_by_digest = sort_by_digest_4_4;
9651 opti_type = OPTI_TYPE_ZERO_BYTE;
9652 dgst_pos0 = 0;
9653 dgst_pos1 = 1;
9654 dgst_pos2 = 2;
9655 dgst_pos3 = 3;
9656 break;
9657
9658 case 12600: hash_type = HASH_TYPE_SHA256;
9659 salt_type = SALT_TYPE_INTERN;
9660 attack_exec = ATTACK_EXEC_ON_GPU;
9661 opts_type = OPTS_TYPE_PT_GENERATE_BE
9662 | OPTS_TYPE_PT_ADD80;
9663 kern_type = KERN_TYPE_CF10;
9664 dgst_size = DGST_SIZE_4_8;
9665 parse_func = cf10_parse_hash;
9666 sort_by_digest = sort_by_digest_4_8;
9667 opti_type = OPTI_TYPE_ZERO_BYTE
9668 | OPTI_TYPE_PRECOMPUTE_INIT
9669 | OPTI_TYPE_EARLY_SKIP
9670 | OPTI_TYPE_NOT_ITERATED;
9671 dgst_pos0 = 3;
9672 dgst_pos1 = 7;
9673 dgst_pos2 = 2;
9674 dgst_pos3 = 6;
9675 break;
9676
9677 case 12700: hash_type = HASH_TYPE_AES;
9678 salt_type = SALT_TYPE_EMBEDDED;
9679 attack_exec = ATTACK_EXEC_ON_CPU;
9680 opts_type = OPTS_TYPE_PT_GENERATE_LE
9681 | OPTS_TYPE_HASH_COPY;
9682 kern_type = KERN_TYPE_MYWALLET;
9683 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9684 parse_func = mywallet_parse_hash;
9685 sort_by_digest = sort_by_digest_4_5;
9686 opti_type = OPTI_TYPE_ZERO_BYTE;
9687 dgst_pos0 = 0;
9688 dgst_pos1 = 1;
9689 dgst_pos2 = 2;
9690 dgst_pos3 = 3;
9691 break;
9692
9693 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
9694 salt_type = SALT_TYPE_EMBEDDED;
9695 attack_exec = ATTACK_EXEC_ON_CPU;
9696 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9697 kern_type = KERN_TYPE_MS_DRSR;
9698 dgst_size = DGST_SIZE_4_8;
9699 parse_func = ms_drsr_parse_hash;
9700 sort_by_digest = sort_by_digest_4_8;
9701 opti_type = OPTI_TYPE_ZERO_BYTE;
9702 dgst_pos0 = 0;
9703 dgst_pos1 = 1;
9704 dgst_pos2 = 2;
9705 dgst_pos3 = 3;
9706 break;
9707
9708 default: usage_mini_print (PROGNAME); return (-1);
9709 }
9710
9711 /**
9712 * transpose
9713 */
9714
9715 data.parse_func = parse_func;
9716
9717 /**
9718 * misc stuff
9719 */
9720
9721 if (hex_salt)
9722 {
9723 if (salt_type == SALT_TYPE_INTERN)
9724 {
9725 opts_type |= OPTS_TYPE_ST_HEX;
9726 }
9727 else
9728 {
9729 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
9730
9731 return (-1);
9732 }
9733 }
9734
9735 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
9736 | (salt_type == SALT_TYPE_EXTERN)
9737 | (salt_type == SALT_TYPE_EMBEDDED)
9738 | (salt_type == SALT_TYPE_VIRTUAL));
9739
9740 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
9741
9742 data.hash_type = hash_type;
9743 data.attack_mode = attack_mode;
9744 data.attack_kern = attack_kern;
9745 data.attack_exec = attack_exec;
9746 data.kern_type = kern_type;
9747 data.opts_type = opts_type;
9748 data.dgst_size = dgst_size;
9749 data.salt_type = salt_type;
9750 data.isSalted = isSalted;
9751 data.sort_by_digest = sort_by_digest;
9752 data.dgst_pos0 = dgst_pos0;
9753 data.dgst_pos1 = dgst_pos1;
9754 data.dgst_pos2 = dgst_pos2;
9755 data.dgst_pos3 = dgst_pos3;
9756
9757 esalt_size = 0;
9758
9759 switch (hash_mode)
9760 {
9761 case 2500: esalt_size = sizeof (wpa_t); break;
9762 case 5300: esalt_size = sizeof (ikepsk_t); break;
9763 case 5400: esalt_size = sizeof (ikepsk_t); break;
9764 case 5500: esalt_size = sizeof (netntlm_t); break;
9765 case 5600: esalt_size = sizeof (netntlm_t); break;
9766 case 6211:
9767 case 6212:
9768 case 6213:
9769 case 6221:
9770 case 6222:
9771 case 6223:
9772 case 6231:
9773 case 6232:
9774 case 6233:
9775 case 6241:
9776 case 6242:
9777 case 6243: esalt_size = sizeof (tc_t); break;
9778 case 6600: esalt_size = sizeof (agilekey_t); break;
9779 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
9780 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
9781 case 7300: esalt_size = sizeof (rakp_t); break;
9782 case 7500: esalt_size = sizeof (krb5pa_t); break;
9783 case 8200: esalt_size = sizeof (cloudkey_t); break;
9784 case 8800: esalt_size = sizeof (androidfde_t); break;
9785 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
9786 case 9400: esalt_size = sizeof (office2007_t); break;
9787 case 9500: esalt_size = sizeof (office2010_t); break;
9788 case 9600: esalt_size = sizeof (office2013_t); break;
9789 case 9700: esalt_size = sizeof (oldoffice01_t); break;
9790 case 9710: esalt_size = sizeof (oldoffice01_t); break;
9791 case 9720: esalt_size = sizeof (oldoffice01_t); break;
9792 case 9800: esalt_size = sizeof (oldoffice34_t); break;
9793 case 9810: esalt_size = sizeof (oldoffice34_t); break;
9794 case 9820: esalt_size = sizeof (oldoffice34_t); break;
9795 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
9796 case 10200: esalt_size = sizeof (cram_md5_t); break;
9797 case 10400: esalt_size = sizeof (pdf_t); break;
9798 case 10410: esalt_size = sizeof (pdf_t); break;
9799 case 10420: esalt_size = sizeof (pdf_t); break;
9800 case 10500: esalt_size = sizeof (pdf_t); break;
9801 case 10600: esalt_size = sizeof (pdf_t); break;
9802 case 10700: esalt_size = sizeof (pdf_t); break;
9803 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
9804 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
9805 case 11400: esalt_size = sizeof (sip_t); break;
9806 case 11600: esalt_size = sizeof (seven_zip_t); break;
9807 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
9808 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
9809 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
9810 }
9811
9812 data.esalt_size = esalt_size;
9813
9814 /**
9815 * choose dictionary parser
9816 */
9817
9818 if (hash_type == HASH_TYPE_LM)
9819 {
9820 get_next_word_func = get_next_word_lm;
9821 }
9822 else if (opts_type & OPTS_TYPE_PT_UPPER)
9823 {
9824 get_next_word_func = get_next_word_uc;
9825 }
9826 else
9827 {
9828 get_next_word_func = get_next_word_std;
9829 }
9830
9831 /**
9832 * dictstat
9833 */
9834
9835 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
9836
9837 #ifdef _POSIX
9838 size_t dictstat_nmemb = 0;
9839 #endif
9840
9841 #ifdef _WIN
9842 uint dictstat_nmemb = 0;
9843 #endif
9844
9845 char dictstat[256];
9846
9847 FILE *dictstat_fp = NULL;
9848
9849 if (keyspace == 0)
9850 {
9851 memset (dictstat, 0, sizeof (dictstat));
9852
9853 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s.dictstat", install_dir, PROGNAME);
9854
9855 dictstat_fp = fopen (dictstat, "rb");
9856
9857 if (dictstat_fp)
9858 {
9859 #ifdef _POSIX
9860 struct stat tmpstat;
9861
9862 fstat (fileno (dictstat_fp), &tmpstat);
9863 #endif
9864
9865 #ifdef _WIN
9866 struct stat64 tmpstat;
9867
9868 _fstat64 (fileno (dictstat_fp), &tmpstat);
9869 #endif
9870
9871 if (tmpstat.st_mtime < COMPTIME)
9872 {
9873 /* with v0.15 the format changed so we have to ensure user is using a good version
9874 since there is no version-header in the dictstat file */
9875
9876 fclose (dictstat_fp);
9877
9878 unlink (dictstat);
9879 }
9880 else
9881 {
9882 while (!feof (dictstat_fp))
9883 {
9884 dictstat_t d;
9885
9886 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
9887
9888 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
9889
9890 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
9891 {
9892 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
9893
9894 return -1;
9895 }
9896 }
9897
9898 fclose (dictstat_fp);
9899 }
9900 }
9901 }
9902
9903 /**
9904 * potfile
9905 */
9906
9907 char potfile[256];
9908
9909 memset (potfile, 0, sizeof (potfile));
9910
9911 snprintf (potfile, sizeof (potfile) - 1, "%s.pot", session);
9912
9913 data.pot_fp = NULL;
9914
9915 FILE *out_fp = NULL;
9916 FILE *pot_fp = NULL;
9917
9918 if (show == 1 || left == 1)
9919 {
9920 pot_fp = fopen (potfile, "rb");
9921
9922 if (pot_fp == NULL)
9923 {
9924 log_error ("ERROR: %s: %s", potfile, strerror (errno));
9925
9926 return (-1);
9927 }
9928
9929 if (outfile != NULL)
9930 {
9931 if ((out_fp = fopen (outfile, "ab")) == NULL)
9932 {
9933 log_error ("ERROR: %s: %s", outfile, strerror (errno));
9934
9935 fclose (pot_fp);
9936
9937 return (-1);
9938 }
9939 }
9940 else
9941 {
9942 out_fp = stdout;
9943 }
9944 }
9945 else
9946 {
9947 if (potfile_disable == 0)
9948 {
9949 pot_fp = fopen (potfile, "ab");
9950
9951 if (pot_fp == NULL)
9952 {
9953 log_error ("ERROR: %s: %s", potfile, strerror (errno));
9954
9955 return (-1);
9956 }
9957
9958 data.pot_fp = pot_fp;
9959 }
9960 }
9961
9962 pot_t *pot = NULL;
9963
9964 uint pot_cnt = 0;
9965 uint pot_avail = 0;
9966
9967 if (show == 1 || left == 1)
9968 {
9969 SUPPRESS_OUTPUT = 1;
9970
9971 pot_avail = count_lines (pot_fp);
9972
9973 rewind (pot_fp);
9974
9975 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
9976
9977 uint pot_hashes_avail = 0;
9978
9979 uint line_num = 0;
9980
9981 while (!feof (pot_fp))
9982 {
9983 line_num++;
9984
9985 char line_buf[BUFSIZ];
9986
9987 int line_len = fgetl (pot_fp, line_buf);
9988
9989 if (line_len == 0) continue;
9990
9991 char *plain_buf = line_buf + line_len;
9992
9993 pot_t *pot_ptr = &pot[pot_cnt];
9994
9995 hash_t *hashes_buf = &pot_ptr->hash;
9996
9997 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
9998 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
9999
10000 if (pot_cnt == pot_hashes_avail)
10001 {
10002 uint pos = 0;
10003
10004 for (pos = 0; pos < INCR_POT; pos++)
10005 {
10006 if ((pot_cnt + pos) >= pot_avail) break;
10007
10008 pot_t *tmp_pot = &pot[pot_cnt + pos];
10009
10010 hash_t *tmp_hash = &tmp_pot->hash;
10011
10012 tmp_hash->digest = mymalloc (dgst_size);
10013
10014 if (isSalted)
10015 {
10016 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10017 }
10018
10019 if (esalt_size)
10020 {
10021 tmp_hash->esalt = mymalloc (esalt_size);
10022 }
10023
10024 pot_hashes_avail++;
10025 }
10026 }
10027
10028 int plain_len = 0;
10029
10030 int parser_status;
10031
10032 int iter = MAX_CUT_TRIES;
10033
10034 do
10035 {
10036 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10037 {
10038 if (line_buf[i] == ':')
10039 {
10040 line_len--;
10041
10042 break;
10043 }
10044 }
10045
10046 if (data.hash_mode != 2500)
10047 {
10048 parser_status = parse_func (line_buf, line_len, hashes_buf);
10049 }
10050 else
10051 {
10052 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10053
10054 if (line_len > max_salt_size)
10055 {
10056 parser_status = PARSER_GLOBAL_LENGTH;
10057 }
10058 else
10059 {
10060 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10061
10062 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10063
10064 hashes_buf->salt->salt_len = line_len;
10065
10066 parser_status = PARSER_OK;
10067 }
10068 }
10069
10070 // if NOT parsed without error, we add the ":" to the plain
10071
10072 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10073 {
10074 plain_len++;
10075 plain_buf--;
10076 }
10077
10078 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10079
10080 if (parser_status < PARSER_GLOBAL_ZERO)
10081 {
10082 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10083
10084 continue;
10085 }
10086
10087 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10088
10089 pot_ptr->plain_len = plain_len;
10090
10091 pot_cnt++;
10092 }
10093
10094 fclose (pot_fp);
10095
10096 SUPPRESS_OUTPUT = 0;
10097
10098 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10099 }
10100
10101 /**
10102 * gpu accel and loops auto adjustment
10103 */
10104
10105 if (gpu_accel_chgd == 0) gpu_accel = set_gpu_accel (hash_mode);
10106 if (gpu_loops_chgd == 0) gpu_loops = set_gpu_loops (hash_mode);
10107
10108 if (workload_profile == 1)
10109 {
10110 gpu_loops /= 8;
10111 gpu_accel /= 4;
10112
10113 if (gpu_loops == 0) gpu_loops = 8;
10114 if (gpu_accel == 0) gpu_accel = 2;
10115 }
10116 else if (workload_profile == 3)
10117 {
10118 gpu_loops *= 8;
10119 gpu_accel *= 4;
10120
10121 if (gpu_loops > 1024) gpu_loops = 1024;
10122 if (gpu_accel > 256) gpu_accel = 256; // causes memory problems otherwise
10123 }
10124
10125 // those hashes *must* run at a specific gpu_loops count because of some optimization inside the kernel
10126
10127 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
10128 {
10129 gpu_loops = 1024;
10130 }
10131
10132 if (hash_mode == 12500)
10133 {
10134 gpu_loops = ROUNDS_RAR3 / 16;
10135 }
10136
10137 data.gpu_accel = gpu_accel;
10138 data.gpu_loops = gpu_loops;
10139
10140 /**
10141 * word len
10142 */
10143
10144 uint pw_min = PW_MIN;
10145 uint pw_max = PW_MAX;
10146
10147 switch (hash_mode)
10148 {
10149 case 400: if (pw_max > 40) pw_max = 40;
10150 break;
10151 case 500: if (pw_max > 16) pw_max = 16;
10152 break;
10153 case 1500: if (pw_max > 8) pw_max = 8;
10154 break;
10155 case 1600: if (pw_max > 16) pw_max = 16;
10156 break;
10157 case 1800: if (pw_max > 16) pw_max = 16;
10158 break;
10159 case 2100: if (pw_max > 16) pw_max = 16;
10160 break;
10161 case 2500: if (pw_min < 8) pw_min = 8;
10162 break;
10163 case 3000: if (pw_max > 7) pw_max = 7;
10164 break;
10165 case 5200: if (pw_max > 24) pw_max = 24;
10166 break;
10167 case 5800: if (pw_max > 16) pw_max = 16;
10168 break;
10169 case 6300: if (pw_max > 16) pw_max = 16;
10170 break;
10171 case 7400: if (pw_max > 16) pw_max = 16;
10172 break;
10173 case 7900: if (pw_max > 48) pw_max = 48;
10174 break;
10175 case 8500: if (pw_max > 8) pw_max = 8;
10176 break;
10177 case 8600: if (pw_max > 16) pw_max = 16;
10178 break;
10179 case 9710: pw_min = 5;
10180 pw_max = 5;
10181 break;
10182 case 9810: pw_min = 5;
10183 pw_max = 5;
10184 break;
10185 case 10410: pw_min = 5;
10186 pw_max = 5;
10187 break;
10188 case 10300: if (pw_max < 3) pw_min = 3;
10189 if (pw_max > 40) pw_max = 40;
10190 break;
10191 case 10500: if (pw_max < 3) pw_min = 3;
10192 if (pw_max > 40) pw_max = 40;
10193 break;
10194 case 10700: if (pw_max > 16) pw_max = 16;
10195 break;
10196 case 11300: if (pw_max > 40) pw_max = 40;
10197 break;
10198 case 12500: if (pw_max > 20) pw_max = 20;
10199 break;
10200 case 12800: if (pw_max > 24) pw_max = 24;
10201 break;
10202 }
10203
10204 if (attack_exec == ATTACK_EXEC_ON_GPU)
10205 {
10206 switch (attack_kern)
10207 {
10208 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10209 break;
10210 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10211 break;
10212 }
10213 }
10214
10215 /**
10216 * charsets : keep them together for more easy maintainnce
10217 */
10218
10219 cs_t mp_sys[6];
10220 cs_t mp_usr[4];
10221
10222 memset (mp_sys, 0, sizeof (mp_sys));
10223 memset (mp_usr, 0, sizeof (mp_usr));
10224
10225 mp_setup_sys (mp_sys);
10226
10227 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10228 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10229 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10230 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10231
10232 /**
10233 * load hashes, part I: find input mode, count hashes
10234 */
10235
10236 uint hashlist_mode = 0;
10237 uint hashlist_format = HLFMT_HASHCAT;
10238
10239 uint hashes_avail = 0;
10240
10241 if (benchmark == 0)
10242 {
10243 struct stat f;
10244
10245 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10246
10247 if ((hash_mode == 2500) ||
10248 (hash_mode == 5200) ||
10249 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10250 (hash_mode == 9000))
10251 {
10252 hashlist_mode = HL_MODE_ARG;
10253
10254 char *hashfile = myargv[optind];
10255
10256 data.hashfile = hashfile;
10257
10258 logfile_top_var_string ("target", hashfile);
10259 }
10260
10261 if (hashlist_mode == HL_MODE_ARG)
10262 {
10263 if (hash_mode == 2500)
10264 {
10265 struct stat st;
10266
10267 if (stat (data.hashfile, &st) == -1)
10268 {
10269 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10270
10271 return (-1);
10272 }
10273
10274 hashes_avail = st.st_size / sizeof (hccap_t);
10275 }
10276 else
10277 {
10278 hashes_avail = 1;
10279 }
10280 }
10281 else if (hashlist_mode == HL_MODE_FILE)
10282 {
10283 char *hashfile = myargv[optind];
10284
10285 data.hashfile = hashfile;
10286
10287 logfile_top_var_string ("target", hashfile);
10288
10289 FILE *fp = NULL;
10290
10291 if ((fp = fopen (hashfile, "rb")) == NULL)
10292 {
10293 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10294
10295 return (-1);
10296 }
10297
10298 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10299
10300 hashes_avail = count_lines (fp);
10301
10302 rewind (fp);
10303
10304 if (hashes_avail == 0)
10305 {
10306 log_error ("ERROR: hashfile is empty or corrupt");
10307
10308 fclose (fp);
10309
10310 return (-1);
10311 }
10312
10313 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10314
10315 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10316 {
10317 log_error ("ERROR: remove not supported in native hashfile-format mode");
10318
10319 fclose (fp);
10320
10321 return (-1);
10322 }
10323
10324 fclose (fp);
10325 }
10326 }
10327 else
10328 {
10329 hashlist_mode = HL_MODE_ARG;
10330
10331 hashes_avail = 1;
10332 }
10333
10334 if (hash_mode == 3000) hashes_avail *= 2;
10335
10336 data.hashlist_mode = hashlist_mode;
10337 data.hashlist_format = hashlist_format;
10338
10339 logfile_top_uint (hashlist_mode);
10340 logfile_top_uint (hashlist_format);
10341
10342 /**
10343 * load hashes, part II: allocate required memory, set pointers
10344 */
10345
10346 hash_t *hashes_buf = NULL;
10347 void *digests_buf = NULL;
10348 salt_t *salts_buf = NULL;
10349 void *esalts_buf = NULL;
10350
10351 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10352
10353 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10354
10355 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10356 {
10357 uint32_t hash_pos;
10358
10359 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10360 {
10361 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10362
10363 hashes_buf[hash_pos].hash_info = hash_info;
10364
10365 if (username && (remove || show || left))
10366 {
10367 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10368 }
10369
10370 if (benchmark)
10371 {
10372 hash_info->orighash = (char *) mymalloc (256);
10373 }
10374 }
10375 }
10376
10377 if (isSalted)
10378 {
10379 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10380
10381 if (esalt_size)
10382 {
10383 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10384 }
10385 }
10386 else
10387 {
10388 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10389 }
10390
10391 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10392 {
10393 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10394
10395 if (isSalted)
10396 {
10397 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10398
10399 if (esalt_size)
10400 {
10401 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10402 }
10403 }
10404 else
10405 {
10406 hashes_buf[hash_pos].salt = &salts_buf[0];
10407 }
10408 }
10409
10410 /**
10411 * load hashes, part III: parse hashes or generate them if benchmark
10412 */
10413
10414 uint hashes_cnt = 0;
10415
10416 if (benchmark == 0)
10417 {
10418 if (keyspace == 1)
10419 {
10420 // useless to read hash file for keyspace, cheat a little bit w/ optind
10421 }
10422 else if (hashes_avail == 0)
10423 {
10424 }
10425 else if (hashlist_mode == HL_MODE_ARG)
10426 {
10427 char *input_buf = myargv[optind];
10428
10429 uint input_len = strlen (input_buf);
10430
10431 logfile_top_var_string ("target", input_buf);
10432
10433 char *hash_buf = NULL;
10434 int hash_len = 0;
10435
10436 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10437
10438 if (hash_len)
10439 {
10440 if (opts_type & OPTS_TYPE_HASH_COPY)
10441 {
10442 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10443
10444 hash_info_tmp->orighash = mystrdup (hash_buf);
10445 }
10446
10447 if (isSalted)
10448 {
10449 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10450 }
10451
10452 int parser_status = PARSER_OK;
10453
10454 if (hash_mode == 2500)
10455 {
10456 if (hash_len == 0)
10457 {
10458 log_error ("ERROR: hccap file not specified");
10459
10460 return (-1);
10461 }
10462
10463 hashlist_mode = HL_MODE_FILE;
10464
10465 data.hashlist_mode = hashlist_mode;
10466
10467 FILE *fp = fopen (hash_buf, "rb");
10468
10469 if (fp == NULL)
10470 {
10471 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10472
10473 return (-1);
10474 }
10475
10476 if (hashes_avail < 1)
10477 {
10478 log_error ("ERROR: hccap file is empty or corrupt");
10479
10480 fclose (fp);
10481
10482 return (-1);
10483 }
10484
10485 uint hccap_size = sizeof (hccap_t);
10486
10487 char in[hccap_size];
10488
10489 while (!feof (fp))
10490 {
10491 int n = fread (&in, hccap_size, 1, fp);
10492
10493 if (n != 1)
10494 {
10495 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
10496
10497 break;
10498 }
10499
10500 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
10501
10502 if (parser_status != PARSER_OK)
10503 {
10504 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
10505
10506 continue;
10507 }
10508
10509 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
10510
10511 if ((show == 1) || (left == 1))
10512 {
10513 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
10514
10515 char *salt_ptr = (char *) tmp_salt->salt_buf;
10516
10517 int cur_pos = tmp_salt->salt_len;
10518 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10519
10520 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
10521
10522 unsigned char *pke_ptr = (unsigned char *) wpa->pke;
10523
10524 // do the appending task
10525
10526 snprintf (salt_ptr + cur_pos,
10527 rem_len,
10528 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
10529 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
10530 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
10531
10532
10533 // memset () the remaining part of the salt
10534
10535 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
10536 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10537
10538 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
10539
10540 tmp_salt->salt_len += 1 + 12 + 1 + 12;
10541 }
10542
10543 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);
10544 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);
10545
10546 hashes_cnt++;
10547 }
10548
10549 fclose (fp);
10550 }
10551 else if (hash_mode == 3000)
10552 {
10553 if (hash_len == 32)
10554 {
10555 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10556
10557 hash_t *lm_hash_left = NULL;
10558
10559 if (parser_status == PARSER_OK)
10560 {
10561 lm_hash_left = &hashes_buf[hashes_cnt];
10562
10563 hashes_cnt++;
10564 }
10565 else
10566 {
10567 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10568 }
10569
10570
10571 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10572
10573 hash_t *lm_hash_right = NULL;
10574
10575 if (parser_status == PARSER_OK)
10576 {
10577 lm_hash_right = &hashes_buf[hashes_cnt];
10578
10579 hashes_cnt++;
10580 }
10581 else
10582 {
10583 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10584 }
10585
10586 // show / left
10587
10588 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
10589 {
10590 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);
10591 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);
10592 }
10593 }
10594 else
10595 {
10596 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10597
10598 if (parser_status == PARSER_OK)
10599 {
10600 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10601 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10602 }
10603
10604 if (parser_status == PARSER_OK)
10605 {
10606 hashes_cnt++;
10607 }
10608 else
10609 {
10610 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10611 }
10612 }
10613 }
10614 else
10615 {
10616 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10617
10618 if (parser_status == PARSER_OK)
10619 {
10620 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10621 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10622 }
10623
10624 if (parser_status == PARSER_OK)
10625 {
10626 hashes_cnt++;
10627 }
10628 else
10629 {
10630 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10631 }
10632 }
10633 }
10634 }
10635 else if (hashlist_mode == HL_MODE_FILE)
10636 {
10637 char *hashfile = data.hashfile;
10638
10639 FILE *fp;
10640
10641 if ((fp = fopen (hashfile, "rb")) == NULL)
10642 {
10643 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10644
10645 return (-1);
10646 }
10647
10648 uint line_num = 0;
10649
10650 while (!feof (fp))
10651 {
10652 line_num++;
10653
10654 char line_buf[BUFSIZ];
10655
10656 int line_len = fgetl (fp, line_buf);
10657
10658 if (line_len == 0) continue;
10659
10660 char *hash_buf = NULL;
10661 int hash_len = 0;
10662
10663 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
10664
10665 if (username)
10666 {
10667 char *user_buf = NULL;
10668 int user_len = 0;
10669
10670 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
10671
10672 if (remove || show)
10673 {
10674 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
10675
10676 *user = (user_t *) malloc (sizeof (user_t));
10677
10678 user_t *user_ptr = *user;
10679
10680 if (user_buf != NULL)
10681 {
10682 user_ptr->user_name = mystrdup (user_buf);
10683 }
10684 else
10685 {
10686 user_ptr->user_name = mystrdup ("");
10687 }
10688
10689 user_ptr->user_len = user_len;
10690 }
10691 }
10692
10693 if (opts_type & OPTS_TYPE_HASH_COPY)
10694 {
10695 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10696
10697 hash_info_tmp->orighash = mystrdup (hash_buf);
10698 }
10699
10700 if (isSalted)
10701 {
10702 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
10703 }
10704
10705 if (hash_mode == 3000)
10706 {
10707 if (hash_len == 32)
10708 {
10709 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10710
10711 if (parser_status < PARSER_GLOBAL_ZERO)
10712 {
10713 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10714
10715 continue;
10716 }
10717
10718 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
10719
10720 hashes_cnt++;
10721
10722 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10723
10724 if (parser_status < PARSER_GLOBAL_ZERO)
10725 {
10726 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10727
10728 continue;
10729 }
10730
10731 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
10732
10733 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);
10734
10735 hashes_cnt++;
10736
10737 // show / left
10738
10739 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);
10740 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);
10741 }
10742 else
10743 {
10744 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10745
10746 if (parser_status < PARSER_GLOBAL_ZERO)
10747 {
10748 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10749
10750 continue;
10751 }
10752
10753 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);
10754
10755 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10756 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10757
10758 hashes_cnt++;
10759 }
10760 }
10761 else
10762 {
10763 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10764
10765 if (parser_status < PARSER_GLOBAL_ZERO)
10766 {
10767 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10768
10769 continue;
10770 }
10771
10772 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);
10773
10774 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10775 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10776
10777 hashes_cnt++;
10778 }
10779 }
10780
10781 fclose (fp);
10782
10783 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
10784
10785 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
10786 }
10787 }
10788 else
10789 {
10790 if (isSalted)
10791 {
10792 hashes_buf[0].salt->salt_len = 8;
10793
10794 // special salt handling
10795
10796 switch (hash_mode)
10797 {
10798 case 1500: hashes_buf[0].salt->salt_len = 2;
10799 break;
10800 case 1731: hashes_buf[0].salt->salt_len = 4;
10801 break;
10802 case 2410: hashes_buf[0].salt->salt_len = 4;
10803 break;
10804 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
10805 break;
10806 case 3100: hashes_buf[0].salt->salt_len = 1;
10807 break;
10808 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
10809 break;
10810 case 5800: hashes_buf[0].salt->salt_len = 16;
10811 break;
10812 case 6800: hashes_buf[0].salt->salt_len = 32;
10813 break;
10814 case 8400: hashes_buf[0].salt->salt_len = 40;
10815 break;
10816 case 8800: hashes_buf[0].salt->salt_len = 16;
10817 break;
10818 case 8900: hashes_buf[0].salt->salt_len = 16;
10819 hashes_buf[0].salt->scrypt_N = 1024;
10820 hashes_buf[0].salt->scrypt_r = 1;
10821 hashes_buf[0].salt->scrypt_p = 1;
10822 break;
10823 case 9100: hashes_buf[0].salt->salt_len = 16;
10824 break;
10825 case 9300: hashes_buf[0].salt->salt_len = 14;
10826 hashes_buf[0].salt->scrypt_N = 16384;
10827 hashes_buf[0].salt->scrypt_r = 1;
10828 hashes_buf[0].salt->scrypt_p = 1;
10829 break;
10830 case 9400: hashes_buf[0].salt->salt_len = 16;
10831 break;
10832 case 9500: hashes_buf[0].salt->salt_len = 16;
10833 break;
10834 case 9600: hashes_buf[0].salt->salt_len = 16;
10835 break;
10836 case 9700: hashes_buf[0].salt->salt_len = 16;
10837 break;
10838 case 9710: hashes_buf[0].salt->salt_len = 16;
10839 break;
10840 case 9720: hashes_buf[0].salt->salt_len = 16;
10841 break;
10842 case 9800: hashes_buf[0].salt->salt_len = 16;
10843 break;
10844 case 9810: hashes_buf[0].salt->salt_len = 16;
10845 break;
10846 case 9820: hashes_buf[0].salt->salt_len = 16;
10847 break;
10848 case 10300: hashes_buf[0].salt->salt_len = 12;
10849 break;
10850 case 11500: hashes_buf[0].salt->salt_len = 4;
10851 break;
10852 case 11600: hashes_buf[0].salt->salt_len = 4;
10853 break;
10854 case 12400: hashes_buf[0].salt->salt_len = 4;
10855 break;
10856 case 12500: hashes_buf[0].salt->salt_len = 8;
10857 break;
10858 case 12600: hashes_buf[0].salt->salt_len = 64;
10859 break;
10860 }
10861
10862 // special esalt handling
10863
10864 switch (hash_mode)
10865 {
10866 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
10867 break;
10868 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
10869 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
10870 break;
10871 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
10872 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
10873 break;
10874 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
10875 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
10876 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
10877 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
10878 break;
10879 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
10880 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
10881 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
10882 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
10883 break;
10884 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
10885 break;
10886 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10887 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
10888 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
10889 break;
10890 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10891 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
10892 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
10893 break;
10894 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10895 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
10896 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
10897 break;
10898 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10899 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
10900 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
10901 break;
10902 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10903 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
10904 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
10905 break;
10906 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10907 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
10908 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
10909 break;
10910 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
10911 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
10912 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
10913 break;
10914 }
10915 }
10916
10917 // set hashfile
10918
10919 switch (hash_mode)
10920 {
10921 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
10922 break;
10923 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
10924 break;
10925 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
10926 break;
10927 case 6211:
10928 case 6212:
10929 case 6213:
10930 case 6221:
10931 case 6222:
10932 case 6223:
10933 case 6231:
10934 case 6232:
10935 case 6233:
10936 case 6241:
10937 case 6242:
10938 case 6243: data.hashfile = mystrdup ("hashcat.tc");
10939 break;
10940 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
10941 break;
10942 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
10943 break;
10944 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
10945 break;
10946 }
10947
10948 // set default iterations
10949
10950 switch (hash_mode)
10951 {
10952 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
10953 break;
10954 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
10955 break;
10956 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
10957 break;
10958 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
10959 break;
10960 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
10961 break;
10962 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
10963 break;
10964 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
10965 break;
10966 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
10967 break;
10968 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
10969 break;
10970 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
10971 break;
10972 case 6211:
10973 case 6212:
10974 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
10975 break;
10976 case 6221:
10977 case 6222:
10978 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
10979 break;
10980 case 6231:
10981 case 6232:
10982 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
10983 break;
10984 case 6241:
10985 case 6242:
10986 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
10987 break;
10988 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
10989 break;
10990 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
10991 break;
10992 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
10993 break;
10994 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
10995 break;
10996 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
10997 break;
10998 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
10999 break;
11000 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11001 break;
11002 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11003 break;
11004 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11005 break;
11006 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11007 break;
11008 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11009 break;
11010 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11011 break;
11012 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11013 break;
11014 case 8900: hashes_buf[0].salt->salt_iter = 1;
11015 break;
11016 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11017 break;
11018 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11019 break;
11020 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11021 break;
11022 case 9300: hashes_buf[0].salt->salt_iter = 1;
11023 break;
11024 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11025 break;
11026 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11027 break;
11028 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11029 break;
11030 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11031 break;
11032 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11033 break;
11034 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11035 break;
11036 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11037 break;
11038 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11039 break;
11040 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11041 break;
11042 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11043 break;
11044 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11045 break;
11046 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11047 break;
11048 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11049 break;
11050 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11051 break;
11052 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11053 break;
11054 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11055 break;
11056 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11057 break;
11058 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11059 break;
11060 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11061 break;
11062 }
11063
11064 // set special tuning for benchmark-mode 1
11065
11066 if (benchmark_mode == 1)
11067 {
11068 gpu_loops *= 8;
11069 gpu_accel *= 4;
11070
11071 switch (hash_mode)
11072 {
11073 case 400: gpu_loops = ROUNDS_PHPASS;
11074 gpu_accel = 32;
11075 break;
11076 case 500: gpu_loops = ROUNDS_MD5CRYPT;
11077 gpu_accel = 32;
11078 break;
11079 case 501: gpu_loops = ROUNDS_MD5CRYPT;
11080 gpu_accel = 32;
11081 break;
11082 case 1600: gpu_loops = ROUNDS_MD5CRYPT;
11083 gpu_accel = 32;
11084 break;
11085 case 1800: gpu_loops = ROUNDS_SHA512CRYPT;
11086 gpu_accel = 8;
11087 break;
11088 case 2100: gpu_loops = ROUNDS_DCC2;
11089 gpu_accel = 16;
11090 break;
11091 case 2500: gpu_loops = ROUNDS_WPA2;
11092 gpu_accel = 32;
11093 break;
11094 case 3200: gpu_loops = ROUNDS_BCRYPT;
11095 gpu_accel = 2;
11096 break;
11097 case 5200: gpu_loops = ROUNDS_PSAFE3;
11098 gpu_accel = 16;
11099 break;
11100 case 5800: gpu_loops = ROUNDS_ANDROIDPIN;
11101 gpu_accel = 16;
11102 break;
11103 case 6211: gpu_loops = ROUNDS_TRUECRYPT_2K;
11104 gpu_accel = 64;
11105 break;
11106 case 6212: gpu_loops = ROUNDS_TRUECRYPT_2K;
11107 gpu_accel = 32;
11108 break;
11109 case 6213: gpu_loops = ROUNDS_TRUECRYPT_2K;
11110 gpu_accel = 32;
11111 break;
11112 case 6221: gpu_loops = ROUNDS_TRUECRYPT_1K;
11113 gpu_accel = 8;
11114 break;
11115 case 6222: gpu_loops = ROUNDS_TRUECRYPT_1K;
11116 gpu_accel = 8;
11117 break;
11118 case 6223: gpu_loops = ROUNDS_TRUECRYPT_1K;
11119 gpu_accel = 8;
11120 break;
11121 case 6231: gpu_loops = ROUNDS_TRUECRYPT_1K;
11122 gpu_accel = 8;
11123 break;
11124 case 6232: gpu_loops = ROUNDS_TRUECRYPT_1K;
11125 gpu_accel = 8;
11126 break;
11127 case 6233: gpu_loops = ROUNDS_TRUECRYPT_1K;
11128 gpu_accel = 8;
11129 break;
11130 case 6241: gpu_loops = ROUNDS_TRUECRYPT_1K;
11131 gpu_accel = 128;
11132 break;
11133 case 6242: gpu_loops = ROUNDS_TRUECRYPT_1K;
11134 gpu_accel = 64;
11135 break;
11136 case 6243: gpu_loops = ROUNDS_TRUECRYPT_1K;
11137 gpu_accel = 64;
11138 break;
11139 case 6300: gpu_loops = ROUNDS_MD5CRYPT;
11140 gpu_accel = 32;
11141 break;
11142 case 6700: gpu_loops = ROUNDS_SHA1AIX;
11143 gpu_accel = 128;
11144 break;
11145 case 6400: gpu_loops = ROUNDS_SHA256AIX;
11146 gpu_accel = 128;
11147 break;
11148 case 6500: gpu_loops = ROUNDS_SHA512AIX;
11149 gpu_accel = 32;
11150 break;
11151 case 6600: gpu_loops = ROUNDS_AGILEKEY;
11152 gpu_accel = 64;
11153 break;
11154 case 6800: gpu_loops = ROUNDS_LASTPASS;
11155 gpu_accel = 64;
11156 break;
11157 case 7100: gpu_loops = ROUNDS_SHA512OSX;
11158 gpu_accel = 2;
11159 break;
11160 case 7200: gpu_loops = ROUNDS_GRUB;
11161 gpu_accel = 2;
11162 break;
11163 case 7400: gpu_loops = ROUNDS_SHA256CRYPT;
11164 gpu_accel = 4;
11165 break;
11166 case 7900: gpu_loops = ROUNDS_DRUPAL7;
11167 gpu_accel = 8;
11168 break;
11169 case 8200: gpu_loops = ROUNDS_CLOUDKEY;
11170 gpu_accel = 2;
11171 break;
11172 case 8800: gpu_loops = ROUNDS_ANDROIDFDE;
11173 gpu_accel = 32;
11174 break;
11175 case 8900: gpu_loops = 1;
11176 gpu_accel = 64;
11177 break;
11178 case 9000: gpu_loops = ROUNDS_PSAFE2;
11179 gpu_accel = 16;
11180 break;
11181 case 9100: gpu_loops = ROUNDS_LOTUS8;
11182 gpu_accel = 64;
11183 break;
11184 case 9200: gpu_loops = ROUNDS_CISCO8;
11185 gpu_accel = 8;
11186 break;
11187 case 9300: gpu_loops = 1;
11188 gpu_accel = 4;
11189 break;
11190 case 9400: gpu_loops = ROUNDS_OFFICE2007;
11191 gpu_accel = 32;
11192 break;
11193 case 9500: gpu_loops = ROUNDS_OFFICE2010;
11194 gpu_accel = 32;
11195 break;
11196 case 9600: gpu_loops = ROUNDS_OFFICE2013;
11197 gpu_accel = 4;
11198 break;
11199 case 10000: gpu_loops = ROUNDS_DJANGOPBKDF2;
11200 gpu_accel = 8;
11201 break;
11202 case 10300: gpu_loops = ROUNDS_SAPH_SHA1;
11203 gpu_accel = 16;
11204 break;
11205 case 10500: gpu_loops = ROUNDS_PDF14;
11206 gpu_accel = 256;
11207 break;
11208 case 10700: gpu_loops = ROUNDS_PDF17L8;
11209 gpu_accel = 8;
11210 break;
11211 case 10900: gpu_loops = ROUNDS_PBKDF2_SHA256;
11212 gpu_accel = 8;
11213 break;
11214 case 11300: gpu_loops = ROUNDS_BITCOIN_WALLET;
11215 gpu_accel = 2;
11216 break;
11217 case 11600: gpu_loops = ROUNDS_SEVEN_ZIP;
11218 gpu_accel = 4;
11219 break;
11220 case 11900: gpu_loops = ROUNDS_PBKDF2_MD5;
11221 gpu_accel = 8;
11222 break;
11223 case 12000: gpu_loops = ROUNDS_PBKDF2_SHA1;
11224 gpu_accel = 8;
11225 break;
11226 case 12100: gpu_loops = ROUNDS_PBKDF2_SHA512;
11227 gpu_accel = 8;
11228 break;
11229 case 12200: gpu_loops = ROUNDS_ECRYPTFS;
11230 gpu_accel = 8;
11231 break;
11232 case 12300: gpu_loops = ROUNDS_ORACLET;
11233 gpu_accel = 8;
11234 break;
11235 case 12500: gpu_loops = ROUNDS_RAR3;
11236 gpu_accel = 32;
11237 break;
11238 case 12700: gpu_loops = ROUNDS_MYWALLET;
11239 gpu_accel = 512;
11240 break;
11241 case 12800: gpu_loops = ROUNDS_MS_DRSR;
11242 gpu_accel = 512;
11243 break;
11244 }
11245
11246 // some algorithm collide too fast, make that impossible
11247
11248 switch (hash_mode)
11249 {
11250 case 11500: ((uint *) digests_buf)[1] = 1;
11251 break;
11252 }
11253
11254 if (gpu_loops > 1024) gpu_loops = 1024;
11255 if (gpu_accel > 256) gpu_accel = 256; // causes memory problems otherwise
11256 }
11257
11258 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
11259 {
11260 gpu_loops = 1024;
11261 }
11262
11263 if (hash_mode == 12500)
11264 {
11265 gpu_loops = ROUNDS_RAR3 / 16;
11266 }
11267
11268 data.gpu_accel = gpu_accel;
11269 data.gpu_loops = gpu_loops;
11270
11271 hashes_cnt = 1;
11272 }
11273
11274 if (show == 1 || left == 1)
11275 {
11276 for (uint i = 0; i < pot_cnt; i++)
11277 {
11278 pot_t *pot_ptr = &pot[i];
11279
11280 hash_t *hashes_buf = &pot_ptr->hash;
11281
11282 local_free (hashes_buf->digest);
11283
11284 if (isSalted)
11285 {
11286 local_free (hashes_buf->salt);
11287 }
11288 }
11289
11290 local_free (pot);
11291
11292 if (data.quiet == 0) log_info_nn ("");
11293
11294 return (0);
11295 }
11296
11297 if (keyspace == 0)
11298 {
11299 if (hashes_cnt == 0)
11300 {
11301 log_error ("ERROR: No hashes loaded");
11302
11303 return (-1);
11304 }
11305 }
11306
11307 /**
11308 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11309 */
11310
11311 if (data.outfile != NULL)
11312 {
11313 if (data.hashfile != NULL)
11314 {
11315 #ifdef _POSIX
11316 struct stat tmpstat_outfile;
11317 struct stat tmpstat_hashfile;
11318 #endif
11319
11320 #ifdef _WIN
11321 struct stat64 tmpstat_outfile;
11322 struct stat64 tmpstat_hashfile;
11323 #endif
11324
11325 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11326
11327 if (tmp_outfile_fp)
11328 {
11329 #ifdef _POSIX
11330 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11331 #endif
11332
11333 #ifdef _WIN
11334 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11335 #endif
11336
11337 fclose (tmp_outfile_fp);
11338 }
11339
11340 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11341
11342 if (tmp_hashfile_fp)
11343 {
11344 #ifdef _POSIX
11345 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11346 #endif
11347
11348 #ifdef _WIN
11349 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11350 #endif
11351
11352 fclose (tmp_hashfile_fp);
11353 }
11354
11355 if (tmp_outfile_fp && tmp_outfile_fp)
11356 {
11357 tmpstat_outfile.st_mode = 0;
11358 tmpstat_outfile.st_nlink = 0;
11359 tmpstat_outfile.st_uid = 0;
11360 tmpstat_outfile.st_gid = 0;
11361 tmpstat_outfile.st_rdev = 0;
11362 tmpstat_outfile.st_atime = 0;
11363
11364 tmpstat_hashfile.st_mode = 0;
11365 tmpstat_hashfile.st_nlink = 0;
11366 tmpstat_hashfile.st_uid = 0;
11367 tmpstat_hashfile.st_gid = 0;
11368 tmpstat_hashfile.st_rdev = 0;
11369 tmpstat_hashfile.st_atime = 0;
11370
11371 #ifdef _POSIX
11372 tmpstat_outfile.st_blksize = 0;
11373 tmpstat_outfile.st_blocks = 0;
11374
11375 tmpstat_hashfile.st_blksize = 0;
11376 tmpstat_hashfile.st_blocks = 0;
11377 #endif
11378
11379 #ifdef _POSIX
11380 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11381 {
11382 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11383
11384 return (-1);
11385 }
11386 #endif
11387
11388 #ifdef _WIN
11389 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11390 {
11391 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11392
11393 return (-1);
11394 }
11395 #endif
11396 }
11397 }
11398 }
11399
11400 /**
11401 * Remove duplicates
11402 */
11403
11404 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11405
11406 if (isSalted)
11407 {
11408 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11409 }
11410 else
11411 {
11412 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11413 }
11414
11415 uint hashes_cnt_orig = hashes_cnt;
11416
11417 hashes_cnt = 1;
11418
11419 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11420 {
11421 if (isSalted)
11422 {
11423 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11424 {
11425 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11426 }
11427 }
11428 else
11429 {
11430 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11431 }
11432
11433 if (hashes_pos > hashes_cnt)
11434 {
11435 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11436 }
11437
11438 hashes_cnt++;
11439 }
11440
11441 /**
11442 * Potfile removes
11443 */
11444
11445 uint potfile_remove_cracks = 0;
11446
11447 if (potfile_disable == 0)
11448 {
11449 hash_t hash_buf;
11450
11451 hash_buf.digest = mymalloc (dgst_size);
11452 hash_buf.salt = NULL;
11453 hash_buf.esalt = NULL;
11454 hash_buf.hash_info = NULL;
11455 hash_buf.cracked = 0;
11456
11457 if (isSalted)
11458 {
11459 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11460 }
11461
11462 if (esalt_size)
11463 {
11464 hash_buf.esalt = mymalloc (esalt_size);
11465 }
11466
11467 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11468
11469 // no solution for these special hash types (for instane because they use hashfile in output etc)
11470 if ((hash_mode != 5200) &&
11471 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11472 (hash_mode != 9000))
11473 {
11474 FILE *fp = fopen (potfile, "rb");
11475
11476 if (fp != NULL)
11477 {
11478 while (!feof (fp))
11479 {
11480 char line_buf[BUFSIZ];
11481
11482 memset (line_buf, 0, BUFSIZ);
11483
11484 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11485
11486 if (ptr == NULL) break;
11487
11488 int line_len = strlen (line_buf);
11489
11490 if (line_len == 0) continue;
11491
11492 int iter = MAX_CUT_TRIES;
11493
11494 for (int i = line_len - 1; i && iter; i--, line_len--)
11495 {
11496 if (line_buf[i] != ':') continue;
11497
11498 if (isSalted)
11499 {
11500 memset (hash_buf.salt, 0, sizeof (salt_t));
11501 }
11502
11503 hash_t *found = NULL;
11504
11505 if (hash_mode == 6800)
11506 {
11507 if (i < 48) // 48 = 12 * uint in salt_buf[]
11508 {
11509 // manipulate salt_buf
11510 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11511
11512 hash_buf.salt->salt_len = i;
11513
11514 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11515 }
11516 }
11517 else if (hash_mode == 2500)
11518 {
11519 if (i < 48) // 48 = 12 * uint in salt_buf[]
11520 {
11521 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11522 // manipulate salt_buf
11523
11524 // to be safe work with a copy (because of line_len loop, i etc)
11525
11526 char line_buf_cpy[BUFSIZ];
11527 memset (line_buf_cpy, 0, BUFSIZ);
11528
11529 memset (line_buf_cpy, 0, sizeof (line_buf_cpy));
11530
11531 memcpy (line_buf_cpy, line_buf, i);
11532
11533 char *mac2_pos = strrchr (line_buf_cpy, ':');
11534
11535 if (mac2_pos == NULL) continue;
11536
11537 mac2_pos[0] = 0;
11538 mac2_pos++;
11539
11540 if (strlen (mac2_pos) != 12) continue;
11541
11542 char *mac1_pos = strrchr (line_buf_cpy, ':');
11543
11544 if (mac1_pos == NULL) continue;
11545
11546 mac1_pos[0] = 0;
11547 mac1_pos++;
11548
11549 if (strlen (mac1_pos) != 12) continue;
11550
11551 uint essid_length = mac1_pos - line_buf_cpy - 1;
11552
11553 // here we need the ESSID
11554 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11555
11556 hash_buf.salt->salt_len = essid_length;
11557
11558 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11559
11560 if (found)
11561 {
11562 wpa_t *wpa = (wpa_t *) found->esalt;
11563
11564 uint pke[25];
11565
11566 char *pke_ptr = (char *) pke;
11567
11568 for (uint i = 0; i < 25; i++)
11569 {
11570 pke[i] = byte_swap_32 (wpa->pke[i]);
11571 }
11572
11573 unsigned char mac1[6];
11574 unsigned char mac2[6];
11575
11576 memcpy (mac1, pke_ptr + 23, 6);
11577 memcpy (mac2, pke_ptr + 29, 6);
11578
11579 // compare hex string(s) vs binary MAC address(es)
11580
11581 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11582 {
11583 if (mac1[i] != (unsigned char) hex_to_char (&mac1_pos[j]))
11584 {
11585 found = NULL;
11586 break;
11587 }
11588 }
11589
11590 // early skip ;)
11591 if (!found) continue;
11592
11593 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11594 {
11595 if (mac2[i] != (unsigned char) hex_to_char (&mac2_pos[j]))
11596 {
11597 found = NULL;
11598 break;
11599 }
11600 }
11601 }
11602 }
11603 }
11604 else
11605 {
11606 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11607
11608 if (parser_status == PARSER_OK)
11609 {
11610 if (isSalted)
11611 {
11612 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11613 }
11614 else
11615 {
11616 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11617 }
11618 }
11619 }
11620
11621 if (found == NULL) continue;
11622
11623 if (!found->cracked) potfile_remove_cracks++;
11624
11625 found->cracked = 1;
11626
11627 if (found) break;
11628
11629 iter--;
11630 }
11631 }
11632
11633 fclose (fp);
11634 }
11635 }
11636
11637 if (esalt_size)
11638 {
11639 local_free (hash_buf.esalt);
11640 }
11641
11642 if (isSalted)
11643 {
11644 local_free (hash_buf.salt);
11645 }
11646
11647 local_free (hash_buf.digest);
11648 }
11649
11650 /**
11651 * Now generate all the buffers required for later
11652 */
11653
11654 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11655
11656 salt_t *salts_buf_new = NULL;
11657 void *esalts_buf_new = NULL;
11658
11659 if (isSalted)
11660 {
11661 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11662
11663 if (esalt_size)
11664 {
11665 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
11666 }
11667 }
11668 else
11669 {
11670 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
11671 }
11672
11673 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
11674
11675 uint digests_cnt = hashes_cnt;
11676 uint digests_done = 0;
11677
11678 uint size_digests = digests_cnt * dgst_size;
11679 uint size_shown = digests_cnt * sizeof (uint);
11680
11681 uint *digests_shown = (uint *) mymalloc (size_shown);
11682 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
11683
11684 uint salts_cnt = 0;
11685 uint salts_done = 0;
11686
11687 hashinfo_t **hash_info = NULL;
11688
11689 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11690 {
11691 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
11692
11693 if (username && (remove || show))
11694 {
11695 uint user_pos;
11696
11697 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
11698 {
11699 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
11700
11701 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
11702 }
11703 }
11704 }
11705
11706 uint *salts_shown = (uint *) mymalloc (size_shown);
11707
11708 salt_t *salt_buf;
11709
11710 {
11711 // copied from inner loop
11712
11713 salt_buf = &salts_buf_new[salts_cnt];
11714
11715 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
11716
11717 if (esalt_size)
11718 {
11719 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
11720 }
11721
11722 salt_buf->digests_cnt = 0;
11723 salt_buf->digests_done = 0;
11724 salt_buf->digests_offset = 0;
11725
11726 salts_cnt++;
11727 }
11728
11729 if (hashes_buf[0].cracked == 1)
11730 {
11731 digests_shown[0] = 1;
11732
11733 digests_done++;
11734
11735 salt_buf->digests_done++;
11736 }
11737
11738 salt_buf->digests_cnt++;
11739
11740 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
11741
11742 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11743 {
11744 hash_info[0] = hashes_buf[0].hash_info;
11745 }
11746
11747 // copy from inner loop
11748
11749 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
11750 {
11751 if (isSalted)
11752 {
11753 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
11754 {
11755 salt_buf = &salts_buf_new[salts_cnt];
11756
11757 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
11758
11759 if (esalt_size)
11760 {
11761 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
11762 }
11763
11764 salt_buf->digests_cnt = 0;
11765 salt_buf->digests_done = 0;
11766 salt_buf->digests_offset = hashes_pos;
11767
11768 salts_cnt++;
11769 }
11770 }
11771
11772 if (hashes_buf[hashes_pos].cracked == 1)
11773 {
11774 digests_shown[hashes_pos] = 1;
11775
11776 digests_done++;
11777
11778 salt_buf->digests_done++;
11779 }
11780
11781 salt_buf->digests_cnt++;
11782
11783 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
11784
11785 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11786 {
11787 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
11788 }
11789 }
11790
11791 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
11792 {
11793 salt_t *salt_buf = &salts_buf_new[salt_pos];
11794
11795 if (salt_buf->digests_done == salt_buf->digests_cnt)
11796 {
11797 salts_shown[salt_pos] = 1;
11798
11799 salts_done++;
11800 }
11801
11802 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
11803 }
11804
11805 local_free (digests_buf);
11806 local_free (salts_buf);
11807 local_free (esalts_buf);
11808
11809 digests_buf = digests_buf_new;
11810 salts_buf = salts_buf_new;
11811 esalts_buf = esalts_buf_new;
11812
11813 local_free (hashes_buf);
11814
11815 /**
11816 * special modification not set from parser
11817 */
11818
11819 switch (hash_mode)
11820 {
11821 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
11822 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
11823 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
11824 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
11825 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
11826 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
11827 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
11828 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
11829 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
11830 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
11831 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
11832 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
11833 }
11834
11835 if (truecrypt_keyfiles)
11836 {
11837 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
11838
11839 char *keyfiles = strdup (truecrypt_keyfiles);
11840
11841 char *keyfile = strtok (keyfiles, ",");
11842
11843 do
11844 {
11845 truecrypt_crc32 (keyfile, (unsigned char *) keyfile_buf);
11846
11847 } while ((keyfile = strtok (NULL, ",")) != NULL);
11848
11849 free (keyfiles);
11850 }
11851
11852 data.digests_cnt = digests_cnt;
11853 data.digests_done = digests_done;
11854 data.digests_buf = digests_buf;
11855 data.digests_shown = digests_shown;
11856 data.digests_shown_tmp = digests_shown_tmp;
11857
11858 data.salts_cnt = salts_cnt;
11859 data.salts_done = salts_done;
11860 data.salts_buf = salts_buf;
11861 data.salts_shown = salts_shown;
11862
11863 data.esalts_buf = esalts_buf;
11864 data.hash_info = hash_info;
11865
11866 /**
11867 * Automatic Optimizers
11868 */
11869
11870 if (salts_cnt == 1)
11871 opti_type |= OPTI_TYPE_SINGLE_SALT;
11872
11873 if (digests_cnt == 1)
11874 opti_type |= OPTI_TYPE_SINGLE_HASH;
11875
11876 if (attack_exec == ATTACK_EXEC_ON_GPU)
11877 opti_type |= OPTI_TYPE_NOT_ITERATED;
11878
11879 if (attack_mode == ATTACK_MODE_BF)
11880 opti_type |= OPTI_TYPE_BRUTE_FORCE;
11881
11882 data.opti_type = opti_type;
11883
11884 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
11885 {
11886 if (opti_type & OPTI_TYPE_SINGLE_HASH)
11887 {
11888 if (opti_type & OPTI_TYPE_APPENDED_SALT)
11889 {
11890 if (opts_type & OPTS_TYPE_ST_ADD80)
11891 {
11892 opts_type &= ~OPTS_TYPE_ST_ADD80;
11893 opts_type |= OPTS_TYPE_PT_ADD80;
11894 }
11895
11896 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
11897 {
11898 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
11899 opts_type |= OPTS_TYPE_PT_ADDBITS14;
11900 }
11901
11902 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
11903 {
11904 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
11905 opts_type |= OPTS_TYPE_PT_ADDBITS15;
11906 }
11907 }
11908 }
11909 }
11910
11911 /**
11912 * Some algorithm, like descrypt, can benefit from JIT compilation
11913 */
11914
11915 uint force_jit_compilation = 0;
11916
11917 if (hash_mode == 8900)
11918 {
11919 force_jit_compilation = 8900;
11920 }
11921 else if (hash_mode == 9300)
11922 {
11923 force_jit_compilation = 8900;
11924 }
11925 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
11926 {
11927 force_jit_compilation = 1500;
11928 }
11929
11930 /**
11931 * generate bitmap tables
11932 */
11933
11934 const uint bitmap_shift1 = 5;
11935 const uint bitmap_shift2 = 13;
11936
11937 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
11938
11939 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
11940 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
11941 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
11942 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
11943 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
11944 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
11945 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
11946 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
11947
11948 uint bitmap_bits;
11949 uint bitmap_nums;
11950 uint bitmap_mask;
11951 uint bitmap_size;
11952
11953 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
11954 {
11955 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
11956
11957 bitmap_nums = 1 << bitmap_bits;
11958
11959 bitmap_mask = bitmap_nums - 1;
11960
11961 bitmap_size = bitmap_nums * sizeof (uint);
11962
11963 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
11964
11965 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;
11966 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;
11967
11968 break;
11969 }
11970
11971 bitmap_nums = 1 << bitmap_bits;
11972
11973 bitmap_mask = bitmap_nums - 1;
11974
11975 bitmap_size = bitmap_nums * sizeof (uint);
11976
11977 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);
11978 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);
11979
11980 /**
11981 * prepare quick rule
11982 */
11983
11984 data.rule_buf_l = rule_buf_l;
11985 data.rule_buf_r = rule_buf_r;
11986
11987 int rule_len_l = (int) strlen (rule_buf_l);
11988 int rule_len_r = (int) strlen (rule_buf_r);
11989
11990 data.rule_len_l = rule_len_l;
11991 data.rule_len_r = rule_len_r;
11992
11993 /**
11994 * load rules
11995 */
11996
11997 uint *all_gpu_rules_cnt = NULL;
11998
11999 gpu_rule_t **all_gpu_rules_buf = NULL;
12000
12001 if (rp_files_cnt)
12002 {
12003 all_gpu_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12004
12005 all_gpu_rules_buf = (gpu_rule_t **) mycalloc (rp_files_cnt, sizeof (gpu_rule_t *));
12006 }
12007
12008 char rule_buf[BUFSIZ];
12009
12010 int rule_len = 0;
12011
12012 for (uint i = 0; i < rp_files_cnt; i++)
12013 {
12014 uint gpu_rules_avail = 0;
12015
12016 uint gpu_rules_cnt = 0;
12017
12018 gpu_rule_t *gpu_rules_buf = NULL;
12019
12020 char *rp_file = rp_files[i];
12021
12022 char in[BLOCK_SIZE];
12023 char out[BLOCK_SIZE];
12024
12025 FILE *fp = NULL;
12026
12027 uint rule_line = 0;
12028
12029 if ((fp = fopen (rp_file, "rb")) == NULL)
12030 {
12031 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12032
12033 return (-1);
12034 }
12035
12036 while (!feof (fp))
12037 {
12038 memset (rule_buf, 0, BUFSIZ);
12039
12040 rule_len = fgetl (fp, rule_buf);
12041
12042 rule_line++;
12043
12044 if (rule_len == 0) continue;
12045
12046 if (rule_buf[0] == '#') continue;
12047
12048 if (gpu_rules_avail == gpu_rules_cnt)
12049 {
12050 gpu_rules_buf = (gpu_rule_t *) myrealloc (gpu_rules_buf, gpu_rules_avail * sizeof (gpu_rule_t), INCR_RULES * sizeof (gpu_rule_t));
12051
12052 gpu_rules_avail += INCR_RULES;
12053 }
12054
12055 memset (in, 0, BLOCK_SIZE);
12056 memset (out, 0, BLOCK_SIZE);
12057
12058 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12059
12060 if (result == -1)
12061 {
12062 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12063
12064 continue;
12065 }
12066
12067 if (cpu_rule_to_gpu_rule (rule_buf, rule_len, &gpu_rules_buf[gpu_rules_cnt]) == -1)
12068 {
12069 log_info ("WARNING: Cannot convert rule for use on GPU in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12070
12071 memset (&gpu_rules_buf[gpu_rules_cnt], 0, sizeof (gpu_rule_t)); // needs to be cleared otherwise we could have some remaining data
12072
12073 continue;
12074 }
12075
12076 /* its so slow
12077 if (rulefind (&gpu_rules_buf[gpu_rules_cnt], gpu_rules_buf, gpu_rules_cnt, sizeof (gpu_rule_t), sort_by_gpu_rule))
12078 {
12079 log_info ("Duplicate rule for use on GPU in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12080
12081 continue;
12082 }
12083 */
12084
12085 gpu_rules_cnt++;
12086 }
12087
12088 fclose (fp);
12089
12090 all_gpu_rules_cnt[i] = gpu_rules_cnt;
12091
12092 all_gpu_rules_buf[i] = gpu_rules_buf;
12093 }
12094
12095 /**
12096 * merge rules or automatic rule generator
12097 */
12098
12099 uint gpu_rules_cnt = 0;
12100
12101 gpu_rule_t *gpu_rules_buf = NULL;
12102
12103 if (attack_mode == ATTACK_MODE_STRAIGHT)
12104 {
12105 if (rp_files_cnt)
12106 {
12107 gpu_rules_cnt = 1;
12108
12109 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12110
12111 repeats[0] = gpu_rules_cnt;
12112
12113 for (uint i = 0; i < rp_files_cnt; i++)
12114 {
12115 gpu_rules_cnt *= all_gpu_rules_cnt[i];
12116
12117 repeats[i + 1] = gpu_rules_cnt;
12118 }
12119
12120 gpu_rules_buf = (gpu_rule_t *) mycalloc (gpu_rules_cnt, sizeof (gpu_rule_t));
12121
12122 memset (gpu_rules_buf, 0, gpu_rules_cnt * sizeof (gpu_rule_t));
12123
12124 for (uint i = 0; i < gpu_rules_cnt; i++)
12125 {
12126 uint out_pos = 0;
12127
12128 gpu_rule_t *out = &gpu_rules_buf[i];
12129
12130 for (uint j = 0; j < rp_files_cnt; j++)
12131 {
12132 uint in_off = (i / repeats[j]) % all_gpu_rules_cnt[j];
12133 uint in_pos;
12134
12135 gpu_rule_t *in = &all_gpu_rules_buf[j][in_off];
12136
12137 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12138 {
12139 if (out_pos == RULES_MAX - 1)
12140 {
12141 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12142
12143 break;
12144 }
12145
12146 out->cmds[out_pos] = in->cmds[in_pos];
12147 }
12148 }
12149 }
12150
12151 local_free (repeats);
12152 }
12153 else if (rp_gen)
12154 {
12155 uint gpu_rules_avail = 0;
12156
12157 while (gpu_rules_cnt < rp_gen)
12158 {
12159 if (gpu_rules_avail == gpu_rules_cnt)
12160 {
12161 gpu_rules_buf = (gpu_rule_t *) myrealloc (gpu_rules_buf, gpu_rules_avail * sizeof (gpu_rule_t), INCR_RULES * sizeof (gpu_rule_t));
12162
12163 gpu_rules_avail += INCR_RULES;
12164 }
12165
12166 memset (rule_buf, 0, BLOCK_SIZE);
12167
12168 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12169
12170 if (cpu_rule_to_gpu_rule (rule_buf, rule_len, &gpu_rules_buf[gpu_rules_cnt]) == -1) continue;
12171
12172 gpu_rules_cnt++;
12173 }
12174 }
12175 }
12176
12177 /**
12178 * generate NOP rules
12179 */
12180
12181 if (gpu_rules_cnt == 0)
12182 {
12183 gpu_rules_buf = (gpu_rule_t *) mymalloc (sizeof (gpu_rule_t));
12184
12185 gpu_rules_buf[gpu_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12186
12187 gpu_rules_cnt++;
12188 }
12189
12190 data.gpu_rules_cnt = gpu_rules_cnt;
12191 data.gpu_rules_buf = gpu_rules_buf;
12192
12193 /**
12194 * platform
12195 */
12196
12197 cl_platform_id CL_platforms[CL_PLATFORMS_MAX];
12198
12199 uint CL_platforms_cnt = 0;
12200
12201 hc_clGetPlatformIDs (CL_PLATFORMS_MAX, CL_platforms, &CL_platforms_cnt);
12202
12203 if (CL_platforms_cnt == 0)
12204 {
12205 log_error ("ERROR: No OpenCL compatible platform found");
12206
12207 return (-1);
12208 }
12209
12210 if (CL_platforms_cnt > 1)
12211 {
12212 log_error ("ERROR: Too many OpenCL compatible platforms found");
12213
12214 return (-1);
12215 }
12216
12217 cl_platform_id CL_platform = CL_platforms[0];
12218
12219 char CL_platform_vendor[INFOSZ];
12220
12221 memset (CL_platform_vendor, 0, sizeof (CL_platform_vendor));
12222
12223 hc_clGetPlatformInfo (CL_platform, CL_PLATFORM_VENDOR, sizeof (CL_platform_vendor), CL_platform_vendor, NULL);
12224
12225 uint vendor_id;
12226
12227 if (strcmp (CL_platform_vendor, CL_VENDOR_AMD) == 0)
12228 {
12229 vendor_id = VENDOR_ID_AMD;
12230 }
12231 else if (strcmp (CL_platform_vendor, CL_VENDOR_NV) == 0)
12232 {
12233 vendor_id = VENDOR_ID_NV;
12234
12235 // make sure that we do not directly control the fan for NVidia
12236
12237 gpu_temp_retain = 0;
12238 data.gpu_temp_retain = gpu_temp_retain;
12239 }
12240 else
12241 {
12242 vendor_id = VENDOR_ID_UNKNOWN;
12243 }
12244
12245 if (vendor_id == VENDOR_ID_UNKNOWN)
12246 {
12247 log_error ("Warning: unknown OpenCL vendor '%s' detected", CL_platform_vendor);
12248
12249 gpu_temp_disable = 1;
12250 }
12251
12252 data.vendor_id = vendor_id;
12253
12254 /**
12255 * devices
12256 */
12257
12258 cl_device_id devices_all[DEVICES_MAX];
12259 cl_device_id devices[DEVICES_MAX];
12260
12261 uint devices_all_cnt = 0;
12262
12263 hc_clGetDeviceIDs (CL_platform, CL_DEVICE_TYPE_GPU, DEVICES_MAX, devices_all, (uint *) &devices_all_cnt);
12264
12265 int hm_adapters_all = devices_all_cnt;
12266
12267 hm_attrs_t hm_adapter_all[DEVICES_MAX];
12268
12269 memset (hm_adapter_all, 0, sizeof (hm_adapter_all));
12270
12271 if (gpu_temp_disable == 0)
12272 {
12273 if (vendor_id == VENDOR_ID_NV)
12274 {
12275 #ifdef LINUX
12276 HM_LIB hm_dll = hm_init ();
12277
12278 data.hm_dll = hm_dll;
12279
12280 if (hc_NVML_nvmlInit (hm_dll) == NVML_SUCCESS)
12281 {
12282 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX];
12283
12284 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12285
12286 int tmp_out = 0;
12287
12288 for (int i = 0; i < tmp_in; i++)
12289 {
12290 hm_adapter_all[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12291 }
12292
12293 hm_adapters_all = tmp_out;
12294
12295 for (int i = 0; i < tmp_out; i++)
12296 {
12297 unsigned int speed;
12298
12299 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;
12300 }
12301 }
12302 #endif
12303
12304 #ifdef WIN
12305 if (NvAPI_Initialize () == NVAPI_OK)
12306 {
12307 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX];
12308
12309 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12310
12311 int tmp_out = 0;
12312
12313 for (int i = 0; i < tmp_in; i++)
12314 {
12315 hm_adapter_all[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12316 }
12317
12318 hm_adapters_all = tmp_out;
12319
12320 for (int i = 0; i < tmp_out; i++)
12321 {
12322 NvU32 speed;
12323
12324 if (NvAPI_GPU_GetTachReading (hm_adapter_all[i].adapter_index.nv, &speed) != NVAPI_NOT_SUPPORTED) hm_adapter_all[i].fan_supported = 1;
12325 }
12326 }
12327 #endif
12328 }
12329
12330 if (vendor_id == VENDOR_ID_AMD)
12331 {
12332 HM_LIB hm_dll = hm_init ();
12333
12334 data.hm_dll = hm_dll;
12335
12336 if (hc_ADL_Main_Control_Create (hm_dll, ADL_Main_Memory_Alloc, 0) == ADL_OK)
12337 {
12338 // total number of adapters
12339
12340 int hm_adapters_num;
12341
12342 if (get_adapters_num_amd (hm_dll, &hm_adapters_num) != 0) return (-1);
12343
12344 // adapter info
12345
12346 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (hm_dll, hm_adapters_num);
12347
12348 if (lpAdapterInfo == NULL) return (-1);
12349
12350 // get a list (of ids of) valid/usable adapters
12351
12352 int num_adl_adapters = 0;
12353
12354 uint32_t *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
12355
12356 if (num_adl_adapters > 0)
12357 {
12358 hc_thread_mutex_lock (mux_adl);
12359
12360 // hm_get_opencl_busid_devid (hm_adapter_all, devices_all_cnt, devices_all);
12361
12362 hm_get_adapter_index_amd (hm_adapter_all, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12363
12364 hm_get_overdrive_version (hm_dll, hm_adapter_all, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12365 hm_check_fanspeed_control (hm_dll, hm_adapter_all, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12366
12367 hc_thread_mutex_unlock (mux_adl);
12368 }
12369
12370 hm_adapters_all = num_adl_adapters;
12371
12372 myfree (valid_adl_device_list);
12373 myfree (lpAdapterInfo);
12374 }
12375 }
12376 }
12377
12378 if (hm_adapters_all == 0)
12379 {
12380 gpu_temp_disable = 1;
12381 }
12382
12383 if (gpu_temp_disable == 1)
12384 {
12385 gpu_temp_abort = 0;
12386 gpu_temp_retain = 0;
12387 }
12388
12389 /**
12390 * enable custom signal handler(s)
12391 */
12392
12393 if (benchmark == 0)
12394 {
12395 hc_signal (sigHandler_default);
12396 }
12397 else
12398 {
12399 hc_signal (sigHandler_benchmark);
12400 }
12401
12402 /**
12403 * devices mask and properties
12404 */
12405
12406 uint devices_cnt = 0;
12407
12408 for (uint device_all_id = 0; device_all_id < devices_all_cnt; device_all_id++)
12409 {
12410 if (gpu_devicemask)
12411 {
12412 uint device_all_id_mask = 1 << device_all_id;
12413
12414 if ((device_all_id_mask & gpu_devicemask) != device_all_id_mask)
12415 {
12416 if (quiet == 0 && algorithm_pos == 0) log_info ("Device #%d: skipped by user", device_all_id_mask + 1);
12417
12418 continue;
12419 }
12420 }
12421
12422 const uint device_id = devices_cnt;
12423
12424 devices[device_id] = devices_all[device_all_id];
12425
12426 memcpy (&data.hm_device[device_id], &hm_adapter_all[device_all_id], sizeof (hm_attrs_t));
12427
12428 char device_name[INFOSZ];
12429
12430 memset (device_name, 0, sizeof (device_name));
12431
12432 cl_ulong global_mem_size;
12433 cl_uint max_clock_frequency;
12434 cl_uint max_compute_units;
12435
12436 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_NAME, sizeof (device_name), &device_name, NULL);
12437 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (global_mem_size), &global_mem_size, NULL);
12438 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (max_clock_frequency), &max_clock_frequency, NULL);
12439 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (max_compute_units), &max_compute_units, NULL);
12440
12441 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12442 {
12443 log_info ("Device #%u: %s, %luMB, %dMhz, %uMCU",
12444 device_all_id + 1,
12445 device_name,
12446 (unsigned int) (global_mem_size / 1024 / 1024),
12447 (unsigned int) (max_clock_frequency),
12448 (unsigned int) max_compute_units);
12449 }
12450
12451 devices_cnt++;
12452 }
12453
12454 if (devices_cnt == 0)
12455 {
12456 log_error ("ERROR: No devices left that matches your specification.");
12457
12458 return (-1);
12459 }
12460
12461 data.devices_cnt = devices_cnt;
12462
12463 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12464 {
12465 log_info ("");
12466 }
12467
12468 /**
12469 * inform the user
12470 */
12471
12472 // gpu temp sanity check
12473
12474 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
12475 {
12476 if (gpu_temp_abort < gpu_temp_retain)
12477 {
12478 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
12479
12480 return (-1);
12481 }
12482 }
12483
12484 data.gpu_temp_disable = gpu_temp_disable;
12485 data.gpu_temp_abort = gpu_temp_abort;
12486 data.gpu_temp_retain = gpu_temp_retain;
12487
12488 if (data.quiet == 0)
12489 {
12490 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
12491
12492 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);
12493
12494 if (attack_mode == ATTACK_MODE_STRAIGHT)
12495 {
12496 log_info ("Rules: %u", gpu_rules_cnt);
12497 }
12498
12499 if (opti_type)
12500 {
12501 log_info ("Applicable Optimizers:");
12502
12503 for (uint i = 0; i < 32; i++)
12504 {
12505 const uint opti_bit = 1 << i;
12506
12507 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
12508 }
12509 }
12510
12511 /**
12512 * Watchdog and Temperature balance
12513 */
12514
12515 if (gpu_temp_abort == 0)
12516 {
12517 log_info ("Watchdog: Temperature abort trigger disabled");
12518 }
12519 else
12520 {
12521 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
12522 }
12523
12524 if (gpu_temp_retain == 0)
12525 {
12526 log_info ("Watchdog: Temperature retain trigger disabled");
12527 }
12528 else
12529 {
12530 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
12531 }
12532 }
12533
12534 /**
12535 * devices init
12536 */
12537
12538 int *temp_retain_fanspeed_value = (int *) mycalloc (devices_cnt, sizeof (int));
12539
12540 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (devices_cnt, sizeof (ADLOD6MemClockState));
12541
12542 int *od_power_control_status = (int *) mycalloc (devices_cnt, sizeof (int));
12543
12544 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (devices_cnt, sizeof (hc_device_param_t));
12545
12546 data.devices_param = devices_param;
12547
12548 for (uint device_id = 0; device_id < devices_cnt; device_id++)
12549 {
12550 hc_device_param_t *device_param = &data.devices_param[device_id];
12551
12552 cl_device_id device = devices[device_id];
12553
12554 device_param->device = device;
12555
12556 cl_uint max_compute_units = 0;
12557
12558 hc_clGetDeviceInfo (device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (max_compute_units), &max_compute_units, NULL);
12559
12560 device_param->gpu_processors = max_compute_units;
12561
12562 cl_ulong max_mem_alloc_size = 0;
12563
12564 hc_clGetDeviceInfo (device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (max_mem_alloc_size), &max_mem_alloc_size, NULL);
12565
12566 device_param->gpu_maxmem_alloc = max_mem_alloc_size;
12567
12568 char tmp[INFOSZ], t1[64];
12569
12570 memset (tmp, 0, sizeof (tmp));
12571
12572 hc_clGetDeviceInfo (device, CL_DEVICE_NAME, sizeof (tmp), &tmp, NULL);
12573
12574 device_param->device_name = mystrdup (tmp);
12575
12576 memset (tmp, 0, sizeof (tmp));
12577
12578 hc_clGetDeviceInfo (device, CL_DEVICE_VERSION, sizeof (tmp), &tmp, NULL);
12579
12580 memset (t1, 0, sizeof (t1));
12581
12582 sscanf (tmp, "%*16s %*16s %*16s (%[^)]16s)", t1);
12583
12584 device_param->device_version = mystrdup (t1);
12585
12586 memset (tmp, 0, sizeof (tmp));
12587
12588 hc_clGetDeviceInfo (device, CL_DRIVER_VERSION, sizeof (tmp), &tmp, NULL);
12589
12590 device_param->driver_version = mystrdup (tmp);
12591
12592 if (vendor_id == VENDOR_ID_NV)
12593 {
12594 cl_uint sm_minor = 0;
12595 cl_uint sm_major = 0;
12596
12597 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12598 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12599
12600 hc_clGetDeviceInfo (device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12601 hc_clGetDeviceInfo (device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12602
12603 device_param->sm_minor = sm_minor;
12604 device_param->sm_major = sm_major;
12605 }
12606
12607 /**
12608 * catalyst driver check
12609 */
12610
12611 if (vendor_id == VENDOR_ID_AMD)
12612 {
12613 int catalyst_check = (force == 1) ? 0 : 1;
12614
12615 int catalyst_warn = 0;
12616
12617 int catalyst_broken = 0;
12618
12619 if (catalyst_check == 1)
12620 {
12621 catalyst_warn = 1;
12622
12623 // v14.9 and higher
12624 if ((atoi (device_param->device_version) >= 1573)
12625 && (atoi (device_param->driver_version) >= 1573))
12626 {
12627 catalyst_warn = 0;
12628 }
12629
12630 /*
12631 // v14.9
12632 if ((strstr (device_param->device_version, "1573.") != NULL)
12633 && (strstr (device_param->driver_version, "1573.") != NULL))
12634 {
12635 catalyst_warn = 0;
12636 }
12637
12638 // v14.12 -- version overlaps with v15.4 beta
12639 if ((strstr (device_param->device_version, "1642.") != NULL)
12640 && (strstr (device_param->driver_version, "1642.") != NULL))
12641 {
12642 catalyst_broken = 1;
12643 }
12644
12645 // v15.4 (Beta, Windows only release)
12646 if ((strstr (device_param->device_version, "1642.") != NULL)
12647 && (strstr (device_param->driver_version, "1642.") != NULL))
12648 {
12649 catalyst_warn = 0;
12650 }
12651
12652 // v15.5 (Release, Linux)
12653 if ((strstr (device_param->device_version, "1702.") != NULL)
12654 && (strstr (device_param->driver_version, "1702.") != NULL))
12655 {
12656 catalyst_warn = 0;
12657 }
12658
12659 // v15.3 (Beta, Ubuntu repository release)
12660 if ((strstr (device_param->device_version, "1729.") != NULL)
12661 && (strstr (device_param->driver_version, "1729.") != NULL))
12662 {
12663 catalyst_warn = 0;
12664 }
12665 */
12666
12667 catalyst_check = 0;
12668 }
12669
12670 if (catalyst_broken == 1)
12671 {
12672 log_error ("");
12673 log_error ("ATTENTION! The installed GPU driver in your system is known to be broken!");
12674 log_error ("It will pass over cracked hashes and does not report them as cracked");
12675 log_error ("You are STRONGLY encouraged not to use it");
12676 log_error ("You can use --force to override this but do not post error reports if you do so");
12677
12678 return (-1);
12679 }
12680
12681 if (catalyst_warn == 1)
12682 {
12683 log_error ("");
12684 log_error ("ATTENTION! Unsupported or incorrect installed GPU driver detected!");
12685 log_error ("You are STRONGLY encouraged to use the official supported GPU driver for good reasons");
12686 log_error ("See oclHashcat's homepage for official supported GPU drivers");
12687 #ifdef _WIN
12688 log_error ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12689 #endif
12690 log_error ("You can use --force to override this but do not post error reports if you do so");
12691
12692 return (-1);
12693 }
12694 }
12695 }
12696
12697 /*
12698 * Temporary fix:
12699 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
12700 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
12701 * were not working @ full speed (setting hc_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
12702 * Driver / ADL bug?
12703 */
12704
12705 if (vendor_id == VENDOR_ID_AMD)
12706 {
12707 if (powertune_enable == 1)
12708 {
12709 hc_thread_mutex_lock (mux_adl);
12710
12711 for (uint i = 0; i < devices_cnt; i++)
12712 {
12713 if (data.hm_device[i].od_version == 6)
12714 {
12715 // set powertune value only
12716
12717 int powertune_supported = 0;
12718
12719 int ADL_rc = 0;
12720
12721 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll, data.hm_device[i].adapter_index.amd, &powertune_supported)) != ADL_OK)
12722 {
12723 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
12724
12725 return (-1);
12726 }
12727
12728 if (powertune_supported != 0)
12729 {
12730 // powertune set
12731 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
12732
12733 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll, data.hm_device[i].adapter_index.amd, &powertune)) != ADL_OK)
12734 {
12735 log_error ("ERROR: Failed to get current ADL PowerControl settings");
12736
12737 return (-1);
12738 }
12739
12740 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll, data.hm_device[i].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
12741 {
12742 log_error ("ERROR: Failed to set new ADL PowerControl values");
12743
12744 return (-1);
12745 }
12746 }
12747 }
12748 }
12749
12750 hc_thread_mutex_unlock (mux_adl);
12751 }
12752 }
12753
12754 uint gpu_blocks_all = 0;
12755
12756 for (uint device_id = 0; device_id < devices_cnt; device_id++)
12757 {
12758 /**
12759 * host buffer
12760 */
12761
12762 hc_device_param_t *device_param = &data.devices_param[device_id];
12763
12764 /**
12765 * device properties
12766 */
12767
12768 char *device_name = device_param->device_name;
12769 char *device_version = device_param->device_version;
12770 char *driver_version = device_param->driver_version;
12771
12772 uint gpu_processors = device_param->gpu_processors;
12773
12774 /**
12775 * create context for each device
12776 */
12777
12778 device_param->context = hc_clCreateContext (NULL, 1, &device_param->device, NULL, NULL);
12779
12780 /**
12781 * create command-queue
12782 */
12783
12784 // not support with NV
12785 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
12786
12787 device_param->command_queue = hc_clCreateCommandQueue (device_param->context, device_param->device, 0);
12788
12789 /**
12790 * create input buffers on device
12791 */
12792
12793 uint gpu_threads = GPU_THREADS;
12794
12795 if (hash_mode == 3200) gpu_threads = 8;
12796 if (hash_mode == 9000) gpu_threads = 8;
12797
12798 uint gpu_power = gpu_processors * gpu_threads * gpu_accel;
12799 uint gpu_blocks = gpu_power;
12800
12801 device_param->gpu_threads = gpu_threads;
12802 device_param->gpu_power_user = gpu_power;
12803 device_param->gpu_blocks_user = gpu_blocks;
12804
12805 gpu_blocks_all += gpu_blocks;
12806
12807 uint size_pws = gpu_power * sizeof (pw_t);
12808
12809 uint size_tmps = 4;
12810
12811 switch (hash_mode)
12812 {
12813 case 400: size_tmps = gpu_blocks * sizeof (phpass_tmp_t); break;
12814 case 500: size_tmps = gpu_blocks * sizeof (md5crypt_tmp_t); break;
12815 case 501: size_tmps = gpu_blocks * sizeof (md5crypt_tmp_t); break;
12816 case 1600: size_tmps = gpu_blocks * sizeof (md5crypt_tmp_t); break;
12817 case 1800: size_tmps = gpu_blocks * sizeof (sha512crypt_tmp_t); break;
12818 case 2100: size_tmps = gpu_blocks * sizeof (dcc2_tmp_t); break;
12819 case 2500: size_tmps = gpu_blocks * sizeof (wpa_tmp_t); break;
12820 case 3200: size_tmps = gpu_blocks * sizeof (bcrypt_tmp_t); break;
12821 case 5200: size_tmps = gpu_blocks * sizeof (pwsafe3_tmp_t); break;
12822 case 5800: size_tmps = gpu_blocks * sizeof (androidpin_tmp_t); break;
12823 case 6211:
12824 case 6212:
12825 case 6213: size_tmps = gpu_blocks * sizeof (tc_tmp_t); break;
12826 case 6221:
12827 case 6222:
12828 case 6223: size_tmps = gpu_blocks * sizeof (tc64_tmp_t); break;
12829 case 6231:
12830 case 6232:
12831 case 6233: size_tmps = gpu_blocks * sizeof (tc_tmp_t); break;
12832 case 6241:
12833 case 6242:
12834 case 6243: size_tmps = gpu_blocks * sizeof (tc_tmp_t); break;
12835 case 6300: size_tmps = gpu_blocks * sizeof (md5crypt_tmp_t); break;
12836 case 6400: size_tmps = gpu_blocks * sizeof (sha256aix_tmp_t); break;
12837 case 6500: size_tmps = gpu_blocks * sizeof (sha512aix_tmp_t); break;
12838 case 6600: size_tmps = gpu_blocks * sizeof (agilekey_tmp_t); break;
12839 case 6700: size_tmps = gpu_blocks * sizeof (sha1aix_tmp_t); break;
12840 case 6800: size_tmps = gpu_blocks * sizeof (lastpass_tmp_t); break;
12841 case 7100: size_tmps = gpu_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
12842 case 7200: size_tmps = gpu_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
12843 case 7400: size_tmps = gpu_blocks * sizeof (sha256crypt_tmp_t); break;
12844 case 7900: size_tmps = gpu_blocks * sizeof (drupal7_tmp_t); break;
12845 case 8200: size_tmps = gpu_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
12846 case 8800: size_tmps = gpu_blocks * sizeof (androidfde_tmp_t); break;
12847 case 8900: size_tmps = gpu_blocks * sizeof (scrypt_tmp_t); break;
12848 case 9000: size_tmps = gpu_blocks * sizeof (pwsafe2_tmp_t); break;
12849 case 9100: size_tmps = gpu_blocks * sizeof (lotus8_tmp_t); break;
12850 case 9200: size_tmps = gpu_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
12851 case 9300: size_tmps = gpu_blocks * sizeof (scrypt_tmp_t); break;
12852 case 9400: size_tmps = gpu_blocks * sizeof (office2007_tmp_t); break;
12853 case 9500: size_tmps = gpu_blocks * sizeof (office2010_tmp_t); break;
12854 case 9600: size_tmps = gpu_blocks * sizeof (office2013_tmp_t); break;
12855 case 10000: size_tmps = gpu_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
12856 case 10200: size_tmps = gpu_blocks * sizeof (cram_md5_t); break;
12857 case 10300: size_tmps = gpu_blocks * sizeof (saph_sha1_tmp_t); break;
12858 case 10500: size_tmps = gpu_blocks * sizeof (pdf14_tmp_t); break;
12859 case 10700: size_tmps = gpu_blocks * sizeof (pdf17l8_tmp_t); break;
12860 case 10900: size_tmps = gpu_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
12861 case 11300: size_tmps = gpu_blocks * sizeof (bitcoin_wallet_tmp_t); break;
12862 case 11600: size_tmps = gpu_blocks * sizeof (seven_zip_tmp_t); break;
12863 case 11900: size_tmps = gpu_blocks * sizeof (pbkdf2_md5_tmp_t); break;
12864 case 12000: size_tmps = gpu_blocks * sizeof (pbkdf2_sha1_tmp_t); break;
12865 case 12100: size_tmps = gpu_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
12866 case 12200: size_tmps = gpu_blocks * sizeof (ecryptfs_tmp_t); break;
12867 case 12300: size_tmps = gpu_blocks * sizeof (oraclet_tmp_t); break;
12868 case 12400: size_tmps = gpu_blocks * sizeof (bsdicrypt_tmp_t); break;
12869 case 12500: size_tmps = gpu_blocks * sizeof (rar3_tmp_t); break;
12870 case 12700: size_tmps = gpu_blocks * sizeof (mywallet_tmp_t); break;
12871 case 12800: size_tmps = gpu_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
12872 };
12873
12874 uint size_hooks = 4;
12875
12876 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
12877 {
12878 // insert correct hook size
12879 }
12880
12881 // we can optimize some stuff here...
12882
12883 device_param->size_pws = size_pws;
12884 device_param->size_tmps = size_tmps;
12885 device_param->size_hooks = size_hooks;
12886
12887 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
12888 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
12889
12890 device_param->size_root_css = size_root_css;
12891 device_param->size_markov_css = size_markov_css;
12892
12893 uint size_results = GPU_THREADS * sizeof (uint);
12894
12895 device_param->size_results = size_results;
12896
12897 uint size_rules = gpu_rules_cnt * sizeof (gpu_rule_t);
12898 uint size_rules_c = GPU_RULES * sizeof (gpu_rule_t);
12899 uint size_plains = digests_cnt * sizeof (plain_t);
12900 uint size_salts = salts_cnt * sizeof (salt_t);
12901 uint size_esalts = salts_cnt * esalt_size;
12902
12903 device_param->size_plains = size_plains;
12904 device_param->size_digests = size_digests;
12905 device_param->size_shown = size_shown;
12906 device_param->size_salts = size_salts;
12907
12908 uint size_combs = GPU_COMBS * sizeof (comb_t);
12909 uint size_bfs = GPU_BFS * sizeof (bf_t);
12910 uint size_tm = 32 * sizeof (bs_word_t);
12911
12912 uint64_t size_scryptV = 1;
12913
12914 if ((hash_mode == 8900) || (hash_mode == 9300))
12915 {
12916 #define SHADER_PER_MP 8
12917 #define WAVEFRONTS 64
12918
12919 uint tmto_start = 2;
12920 uint tmto_stop = 1024;
12921
12922 if (scrypt_tmto)
12923 {
12924 tmto_start = 1 << scrypt_tmto;
12925 tmto_stop = tmto_start + 1;
12926 }
12927
12928 for (uint tmto = tmto_start; tmto < tmto_stop; tmto <<= 1)
12929 {
12930 // todo -- make sure all salts get the new tmto value
12931
12932 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
12933
12934 size_scryptV /= tmto;
12935
12936 size_scryptV *= gpu_processors * WAVEFRONTS * SHADER_PER_MP;
12937
12938 if (size_scryptV > (device_param->gpu_maxmem_alloc / 2)) continue;
12939
12940 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
12941 {
12942 data.salts_buf[salts_pos].scrypt_tmto = tmto;
12943 data.salts_buf[salts_pos].scrypt_phy = gpu_processors * WAVEFRONTS * SHADER_PER_MP;
12944 }
12945
12946 break;
12947 }
12948
12949 if (data.salts_buf[0].scrypt_tmto == 0)
12950 {
12951 log_error ("ERROR: can't allocate enough GPU memory");
12952
12953 return -1;
12954 }
12955
12956 if (quiet == 0) log_info ("");
12957 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u\n", data.salts_buf[0].scrypt_tmto);
12958 }
12959
12960 /**
12961 * kernel find
12962 */
12963
12964 char build_opts[1024];
12965
12966 // we don't have sm_* on AMD but it doesn't matter
12967
12968 sprintf (build_opts, "-I. -IOpenCL/ -DVENDOR_ID=%d -DCUDA_ARCH=%d", vendor_id, (device_param->sm_major * 100) + device_param->sm_minor);
12969
12970 struct stat st;
12971
12972 char kernel_file[256];
12973
12974 memset (kernel_file, 0, sizeof (kernel_file));
12975
12976 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
12977
12978 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
12979
12980 #ifdef BINARY_KERNEL
12981 if (force_jit_compilation == 0)
12982 {
12983 if (attack_exec == ATTACK_EXEC_ON_GPU)
12984 {
12985 if (attack_kern == ATTACK_KERN_STRAIGHT)
12986 snprintf (kernel_file, sizeof (kernel_file) - 1, "%s/kernels/4098/m%05d_a0.%s_%s_%s_%d.kernel", install_dir, (int) kern_type, device_name, device_version, driver_version, COMPTIME);
12987 else if (attack_kern == ATTACK_KERN_COMBI)
12988 snprintf (kernel_file, sizeof (kernel_file) - 1, "%s/kernels/4098/m%05d_a1.%s_%s_%s_%d.kernel", install_dir, (int) kern_type, device_name, device_version, driver_version, COMPTIME);
12989 else if (attack_kern == ATTACK_KERN_BF)
12990 snprintf (kernel_file, sizeof (kernel_file) - 1, "%s/kernels/4098/m%05d_a3.%s_%s_%s_%d.kernel", install_dir, (int) kern_type, device_name, device_version, driver_version, COMPTIME);
12991 }
12992 else
12993 {
12994 snprintf (kernel_file, sizeof (kernel_file) - 1, "%s/kernels/4098/m%05d.%s_%s_%s_%d.kernel", install_dir, (int) kern_type, device_name, device_version, driver_version, COMPTIME);
12995
12996 if ((hash_mode == 8900) || (hash_mode == 9300))
12997 {
12998 snprintf (kernel_file, sizeof (kernel_file) - 1, "%s/kernels/4098/m%05d_%d_%d_%d_%d.%s_%s_%s_%d.kernel", install_dir, (int) kern_type, data.salts_buf[0].scrypt_N, data.salts_buf[0].scrypt_r, data.salts_buf[0].scrypt_p, data.salts_buf[0].scrypt_tmto, device_name, device_version, driver_version, COMPTIME);
12999 }
13000 }
13001
13002 if (stat (kernel_file, &st) == -1)
13003 {
13004 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, kernel_file);
13005
13006 char module_file[256];
13007
13008 memset (module_file, 0, sizeof (module_file));
13009
13010 if (attack_exec == ATTACK_EXEC_ON_GPU)
13011 {
13012 if (attack_kern == ATTACK_KERN_STRAIGHT)
13013 snprintf (module_file, sizeof (module_file) - 1, "%s/kernels/4098/m%05d_a0.llvmir", install_dir, (int) kern_type);
13014 else if (attack_kern == ATTACK_KERN_COMBI)
13015 snprintf (module_file, sizeof (module_file) - 1, "%s/kernels/4098/m%05d_a1.llvmir", install_dir, (int) kern_type);
13016 else if (attack_kern == ATTACK_KERN_BF)
13017 snprintf (module_file, sizeof (module_file) - 1, "%s/kernels/4098/m%05d_a3.llvmir", install_dir, (int) kern_type);
13018 }
13019 else
13020 {
13021 snprintf (module_file, sizeof (module_file) - 1, "%s/kernels/4098/m%05d.llvmir", install_dir, (int) kern_type);
13022
13023 if ((hash_mode == 8900) || (hash_mode == 9300))
13024 {
13025 snprintf (module_file, sizeof (module_file) - 1, "%s/kernels/4098/m%05d_%d_%d_%d_%d.llvmir", install_dir, (int) kern_type, data.salts_buf[0].scrypt_N, data.salts_buf[0].scrypt_r, data.salts_buf[0].scrypt_p, data.salts_buf[0].scrypt_tmto);
13026 }
13027 }
13028
13029 load_kernel (module_file, 1, kernel_lengths, kernel_sources);
13030
13031 cl_program program = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13032
13033 local_free (kernel_sources[0]);
13034
13035 hc_clBuildProgram (program, 1, &device_param->device, build_opts, NULL, NULL);
13036
13037 size_t binary_size;
13038
13039 clGetProgramInfo (program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13040
13041 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13042
13043 clGetProgramInfo (program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13044
13045 writeProgramBin (kernel_file, binary, binary_size);
13046
13047 local_free (binary);
13048
13049 stat (kernel_file, &st); // to reload filesize
13050 }
13051 }
13052 else
13053 {
13054 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, install_dir, kernel_file);
13055
13056 if (stat (kernel_file, &st) == -1)
13057 {
13058 log_error ("ERROR: %s: %s", kernel_file, strerror (errno));
13059
13060 return -1;
13061 }
13062 }
13063
13064 #else
13065
13066 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, install_dir, kernel_file);
13067
13068 if (stat (kernel_file, &st) == -1)
13069 {
13070 log_error ("ERROR: %s: %s", kernel_file, strerror (errno));
13071
13072 return -1;
13073 }
13074
13075 #endif
13076
13077 load_kernel (kernel_file, 1, kernel_lengths, kernel_sources);
13078
13079 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, kernel_file, st.st_size);
13080
13081 #ifdef BINARY_KERNEL
13082 if (force_jit_compilation == 0)
13083 {
13084 device_param->program = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13085 }
13086 else
13087 {
13088 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13089 }
13090 #else
13091 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13092 #endif
13093
13094 local_free (kernel_lengths);
13095
13096 local_free (kernel_sources[0]);
13097
13098 local_free (kernel_sources)
13099
13100 /**
13101 * kernel mp find
13102 */
13103
13104 if (attack_mode != ATTACK_MODE_STRAIGHT)
13105 {
13106 char kernel_mp_file[256];
13107
13108 memset (kernel_mp_file, 0, sizeof (kernel_mp_file));
13109
13110 size_t *kernel_mp_lengths = (size_t *) mymalloc (sizeof (size_t));
13111
13112 const unsigned char **kernel_mp_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13113
13114 #ifdef BINARY_KERNEL
13115 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
13116 {
13117 snprintf (kernel_mp_file, sizeof (kernel_mp_file) - 1, "%s/kernels/4098/markov_be.%s_%s_%s_%d.kernel", install_dir, device_name, device_version, driver_version, COMPTIME);
13118 }
13119 else
13120 {
13121 snprintf (kernel_mp_file, sizeof (kernel_mp_file) - 1, "%s/kernels/4098/markov_le.%s_%s_%s_%d.kernel", install_dir, device_name, device_version, driver_version, COMPTIME);
13122 }
13123
13124 if (stat (kernel_mp_file, &st) == -1)
13125 {
13126 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, kernel_mp_file);
13127
13128 char module_mp_file[256];
13129
13130 memset (module_mp_file, 0, sizeof (module_mp_file));
13131
13132 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
13133 {
13134 snprintf (module_mp_file, sizeof (module_mp_file) - 1, "%s/kernels/4098/markov_be.llvmir", install_dir);
13135 }
13136 else
13137 {
13138 snprintf (module_mp_file, sizeof (module_mp_file) - 1, "%s/kernels/4098/markov_le.llvmir", install_dir);
13139 }
13140
13141 load_kernel (module_mp_file, 1, kernel_mp_lengths, kernel_mp_sources);
13142
13143 cl_program program_mp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_mp_lengths, (const unsigned char **) kernel_mp_sources, NULL);
13144
13145 local_free (kernel_mp_sources[0]);
13146
13147 hc_clBuildProgram (program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13148
13149 size_t binary_mp_size;
13150
13151 clGetProgramInfo (program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_mp_size, NULL);
13152
13153 unsigned char *binary_mp = (unsigned char *) mymalloc (binary_mp_size);
13154
13155 clGetProgramInfo (program_mp, CL_PROGRAM_BINARIES, sizeof (binary_mp), &binary_mp, NULL);
13156
13157 writeProgramBin (kernel_mp_file, binary_mp, binary_mp_size);
13158
13159 local_free (binary_mp);
13160
13161 stat (kernel_mp_file, &st); // to reload filesize
13162 }
13163
13164 #else
13165 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
13166 {
13167 snprintf (kernel_mp_file, sizeof (kernel_mp_file) - 1, "%s/OpenCL/markov_be.cl", install_dir);
13168 }
13169 else
13170 {
13171 snprintf (kernel_mp_file, sizeof (kernel_mp_file) - 1, "%s/OpenCL/markov_le.cl", install_dir);
13172 }
13173
13174 if (stat (kernel_mp_file, &st) == -1)
13175 {
13176 log_error ("ERROR: %s: %s", kernel_mp_file, strerror (errno));
13177
13178 return -1;
13179 }
13180
13181 #endif
13182
13183 load_kernel (kernel_mp_file, 1, kernel_mp_lengths, kernel_mp_sources);
13184
13185 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, kernel_mp_file, st.st_size);
13186
13187 #ifdef BINARY_KERNEL
13188 device_param->program_mp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_mp_lengths, (const unsigned char **) kernel_mp_sources, NULL);
13189 #else
13190 device_param->program_mp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_mp_sources, NULL);
13191 #endif
13192
13193 local_free (kernel_mp_lengths);
13194
13195 local_free (kernel_mp_sources[0]);
13196
13197 local_free (kernel_mp_sources);
13198 }
13199
13200 /**
13201 * kernel amp find
13202 */
13203
13204 if (attack_exec == ATTACK_EXEC_ON_GPU)
13205 {
13206 // nothing to do
13207 }
13208 else
13209 {
13210 char kernel_amp_file[256];
13211
13212 memset (kernel_amp_file, 0, sizeof (kernel_amp_file));
13213
13214 size_t *kernel_amp_lengths = (size_t *) mymalloc (sizeof (size_t));
13215
13216 const unsigned char **kernel_amp_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13217
13218 #ifdef BINARY_KERNEL
13219 snprintf (kernel_amp_file, sizeof (kernel_amp_file) - 1, "%s/kernels/4098/amp_a%d.%s_%s_%s_%d.kernel", install_dir, attack_kern, device_name, device_version, driver_version, COMPTIME);
13220
13221 if (stat (kernel_amp_file, &st) == -1)
13222 {
13223 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, kernel_amp_file);
13224
13225 char module_amp_file[256];
13226
13227 memset (module_amp_file, 0, sizeof (module_amp_file));
13228
13229 snprintf (module_amp_file, sizeof (module_amp_file) - 1, "%s/kernels/4098/amp_a%d.llvmir", install_dir, attack_kern);
13230
13231 load_kernel (module_amp_file, 1, kernel_amp_lengths, kernel_amp_sources);
13232
13233 cl_program program_amp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_amp_lengths, (const unsigned char **) kernel_amp_sources, NULL);
13234
13235 local_free (kernel_amp_sources[0]);
13236
13237 hc_clBuildProgram (program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13238
13239 size_t binary_amp_size;
13240
13241 clGetProgramInfo (program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_amp_size, NULL);
13242
13243 unsigned char *binary_amp = (unsigned char *) mymalloc (binary_amp_size);
13244
13245 clGetProgramInfo (program_amp, CL_PROGRAM_BINARIES, sizeof (binary_amp), &binary_amp, NULL);
13246
13247 writeProgramBin (kernel_amp_file, binary_amp, binary_amp_size);
13248
13249 local_free (binary_amp);
13250
13251 stat (kernel_amp_file, &st); // to reload filesize
13252 }
13253 #else
13254 snprintf (kernel_amp_file, sizeof (kernel_amp_file) - 1, "%s/OpenCL/amp_a%d.cl", install_dir, attack_kern);
13255
13256 if (stat (kernel_amp_file, &st) == -1)
13257 {
13258 log_error ("ERROR: %s: %s", kernel_amp_file, strerror (errno));
13259
13260 return -1;
13261 }
13262 #endif
13263
13264 load_kernel (kernel_amp_file, 1, kernel_amp_lengths, kernel_amp_sources);
13265
13266 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, kernel_amp_file, st.st_size);
13267
13268 #ifdef BINARY_KERNEL
13269 device_param->program_amp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_amp_lengths, (const unsigned char **) kernel_amp_sources, NULL);
13270 #else
13271 device_param->program_amp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_amp_sources, NULL);
13272 #endif
13273
13274 local_free (kernel_amp_lengths);
13275
13276 local_free (kernel_amp_sources[0]);
13277
13278 local_free (kernel_amp_sources);
13279 }
13280
13281 /**
13282 * kernel compile
13283 */
13284
13285 //#ifdef BINARY_KERNEL
13286
13287 if (force_jit_compilation == 0)
13288 {
13289 // nothing to do
13290 }
13291 else if (force_jit_compilation == 1500)
13292 {
13293 sprintf (build_opts, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13294 }
13295 else if (force_jit_compilation == 8900)
13296 {
13297 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);
13298 }
13299
13300 //#endif
13301
13302 clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13303
13304 size_t ret_val_size = 0;
13305
13306 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13307
13308 if (ret_val_size > 2)
13309 {
13310 char *build_log = (char *) malloc (ret_val_size + 1);
13311
13312 memset (build_log, 0, ret_val_size + 1);
13313
13314 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13315
13316 puts (build_log);
13317
13318 free (build_log);
13319 }
13320
13321 if (attack_mode != ATTACK_MODE_STRAIGHT)
13322 {
13323 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13324 }
13325
13326 if (attack_exec == ATTACK_EXEC_ON_GPU)
13327 {
13328 // nothing to do
13329 }
13330 else
13331 {
13332 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13333 }
13334
13335 /**
13336 * amp is not independent
13337 */
13338
13339 if (attack_exec == ATTACK_EXEC_ON_GPU)
13340 {
13341 // nothing to do
13342 }
13343 else
13344 {
13345 device_param->kernel_amp = hc_clCreateKernel (device_param->program_amp, "amp");
13346 }
13347
13348 /**
13349 * global buffers
13350 */
13351
13352 device_param->d_pws_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13353 device_param->d_pws_amp_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13354 device_param->d_tmps = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
13355 device_param->d_hooks = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
13356 device_param->d_bitmap_s1_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13357 device_param->d_bitmap_s1_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13358 device_param->d_bitmap_s1_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13359 device_param->d_bitmap_s1_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13360 device_param->d_bitmap_s2_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13361 device_param->d_bitmap_s2_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13362 device_param->d_bitmap_s2_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13363 device_param->d_bitmap_s2_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13364 device_param->d_plain_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
13365 device_param->d_digests_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
13366 device_param->d_digests_shown = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
13367 device_param->d_salt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
13368 device_param->d_result = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
13369 device_param->d_scryptV_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
13370
13371 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_a, CL_TRUE, 0, bitmap_size, bitmap_s1_a, 0, NULL, NULL);
13372 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_b, CL_TRUE, 0, bitmap_size, bitmap_s1_b, 0, NULL, NULL);
13373 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_c, CL_TRUE, 0, bitmap_size, bitmap_s1_c, 0, NULL, NULL);
13374 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_d, CL_TRUE, 0, bitmap_size, bitmap_s1_d, 0, NULL, NULL);
13375 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_a, CL_TRUE, 0, bitmap_size, bitmap_s2_a, 0, NULL, NULL);
13376 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_b, CL_TRUE, 0, bitmap_size, bitmap_s2_b, 0, NULL, NULL);
13377 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_c, CL_TRUE, 0, bitmap_size, bitmap_s2_c, 0, NULL, NULL);
13378 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_d, CL_TRUE, 0, bitmap_size, bitmap_s2_d, 0, NULL, NULL);
13379 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
13380 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
13381 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
13382
13383 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
13384 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
13385 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
13386 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
13387 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
13388 run_kernel_bzero (device_param, device_param->d_result, size_results);
13389
13390 /**
13391 * special buffers
13392 */
13393
13394 if (attack_kern == ATTACK_KERN_STRAIGHT)
13395 {
13396 device_param->d_rules = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
13397 device_param->d_rules_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
13398
13399 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, gpu_rules_buf, 0, NULL, NULL);
13400
13401 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
13402 }
13403 else if (attack_kern == ATTACK_KERN_COMBI)
13404 {
13405 device_param->d_combs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13406 device_param->d_combs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13407 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13408 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13409
13410 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
13411 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
13412 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13413 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13414 }
13415 else if (attack_kern == ATTACK_KERN_BF)
13416 {
13417 device_param->d_bfs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13418 device_param->d_bfs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13419 device_param->d_tm_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
13420 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13421 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13422
13423 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
13424 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
13425 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
13426 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13427 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13428 }
13429
13430 if (size_esalts)
13431 {
13432 device_param->d_esalt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
13433
13434 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
13435 }
13436
13437 /**
13438 * main host data
13439 */
13440
13441 uint *result = (uint *) mymalloc (size_results);
13442
13443 memset (result, 0, size_results);
13444
13445 device_param->result = result;
13446
13447 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
13448
13449 memset (pws_buf, 0, size_pws);
13450
13451 device_param->pws_buf = pws_buf;
13452
13453 pw_cache_t *pw_caches = (pw_cache_t *) mycalloc (64, sizeof (pw_cache_t));
13454
13455 for (int i = 0; i < 64; i++)
13456 {
13457 pw_caches[i].pw_buf.pw_len = i;
13458 pw_caches[i].cnt = 0;
13459 }
13460
13461 device_param->pw_caches = pw_caches;
13462
13463 comb_t *combs_buf = (comb_t *) mycalloc (GPU_COMBS, sizeof (comb_t));
13464
13465 device_param->combs_buf = combs_buf;
13466
13467 void *hooks_buf = mymalloc (size_hooks);
13468
13469 device_param->hooks_buf = hooks_buf;
13470
13471 device_param->pw_transpose = pw_transpose_to_hi1;
13472 device_param->pw_add = pw_add_to_hc1;
13473
13474 /**
13475 * kernel args
13476 */
13477
13478 device_param->kernel_params_buf32[21] = bitmap_mask;
13479 device_param->kernel_params_buf32[22] = bitmap_shift1;
13480 device_param->kernel_params_buf32[23] = bitmap_shift2;
13481 device_param->kernel_params_buf32[24] = 0; // salt_pos
13482 device_param->kernel_params_buf32[25] = 0; // loop_pos
13483 device_param->kernel_params_buf32[26] = 0; // loop_cnt
13484 device_param->kernel_params_buf32[27] = 0; // gpu_rules_cnt
13485 device_param->kernel_params_buf32[28] = 0; // digests_cnt
13486 device_param->kernel_params_buf32[29] = 0; // digests_offset
13487 device_param->kernel_params_buf32[30] = 0; // combs_mode
13488 device_param->kernel_params_buf32[31] = 0; // gid_max
13489
13490 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_ON_GPU)
13491 ? &device_param->d_pws_buf
13492 : &device_param->d_pws_amp_buf;
13493 device_param->kernel_params[ 1] = &device_param->d_rules_c;
13494 device_param->kernel_params[ 2] = &device_param->d_combs_c;
13495 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
13496 device_param->kernel_params[ 4] = &device_param->d_tmps;
13497 device_param->kernel_params[ 5] = &device_param->d_hooks;
13498 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
13499 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
13500 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
13501 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
13502 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
13503 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
13504 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
13505 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
13506 device_param->kernel_params[14] = &device_param->d_plain_bufs;
13507 device_param->kernel_params[15] = &device_param->d_digests_buf;
13508 device_param->kernel_params[16] = &device_param->d_digests_shown;
13509 device_param->kernel_params[17] = &device_param->d_salt_bufs;
13510 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
13511 device_param->kernel_params[19] = &device_param->d_result;
13512 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
13513 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
13514 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
13515 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
13516 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
13517 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
13518 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
13519 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
13520 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
13521 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
13522 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
13523 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
13524
13525 device_param->kernel_params_mp_buf64[3] = 0;
13526 device_param->kernel_params_mp_buf32[4] = 0;
13527 device_param->kernel_params_mp_buf32[5] = 0;
13528 device_param->kernel_params_mp_buf32[6] = 0;
13529 device_param->kernel_params_mp_buf32[7] = 0;
13530 device_param->kernel_params_mp_buf32[8] = 0;
13531
13532 device_param->kernel_params_mp[0] = NULL;
13533 device_param->kernel_params_mp[1] = NULL;
13534 device_param->kernel_params_mp[2] = NULL;
13535 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
13536 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
13537 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
13538 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
13539 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
13540 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
13541
13542 device_param->kernel_params_mp_l_buf64[3] = 0;
13543 device_param->kernel_params_mp_l_buf32[4] = 0;
13544 device_param->kernel_params_mp_l_buf32[5] = 0;
13545 device_param->kernel_params_mp_l_buf32[6] = 0;
13546 device_param->kernel_params_mp_l_buf32[7] = 0;
13547 device_param->kernel_params_mp_l_buf32[8] = 0;
13548 device_param->kernel_params_mp_l_buf32[9] = 0;
13549
13550 device_param->kernel_params_mp_l[0] = NULL;
13551 device_param->kernel_params_mp_l[1] = NULL;
13552 device_param->kernel_params_mp_l[2] = NULL;
13553 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
13554 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
13555 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
13556 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
13557 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
13558 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
13559 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
13560
13561 device_param->kernel_params_mp_r_buf64[3] = 0;
13562 device_param->kernel_params_mp_r_buf32[4] = 0;
13563 device_param->kernel_params_mp_r_buf32[5] = 0;
13564 device_param->kernel_params_mp_r_buf32[6] = 0;
13565 device_param->kernel_params_mp_r_buf32[7] = 0;
13566 device_param->kernel_params_mp_r_buf32[8] = 0;
13567
13568 device_param->kernel_params_mp_r[0] = NULL;
13569 device_param->kernel_params_mp_r[1] = NULL;
13570 device_param->kernel_params_mp_r[2] = NULL;
13571 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
13572 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
13573 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
13574 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
13575 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
13576 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
13577
13578 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
13579 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
13580
13581 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
13582 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
13583 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
13584 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
13585 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
13586 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
13587 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
13588
13589 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
13590
13591 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
13592 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
13593
13594 /**
13595 * kernel name
13596 */
13597
13598 char kernel_name[64];
13599
13600 memset (kernel_name, 0, sizeof (kernel_name));
13601
13602 if (attack_exec == ATTACK_EXEC_ON_GPU)
13603 {
13604 if (opti_type & OPTI_TYPE_SINGLE_HASH)
13605 {
13606 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
13607
13608 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
13609
13610 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
13611
13612 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
13613
13614 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
13615
13616 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
13617 }
13618 else
13619 {
13620 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
13621
13622 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
13623
13624 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
13625
13626 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
13627
13628 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
13629
13630 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
13631 }
13632
13633 if (data.attack_mode == ATTACK_MODE_BF)
13634 {
13635 if (opts_type & OPTS_TYPE_PT_BITSLICE)
13636 {
13637 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
13638
13639 device_param->kernel_tb = hc_clCreateKernel (device_param->program, kernel_name);
13640
13641 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
13642
13643 device_param->kernel_tm = hc_clCreateKernel (device_param->program, kernel_name);
13644 }
13645 }
13646 }
13647 else
13648 {
13649 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
13650
13651 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
13652
13653 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
13654
13655 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
13656
13657 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
13658
13659 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
13660
13661 if (opts_type & OPTS_TYPE_HOOK12)
13662 {
13663 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
13664
13665 device_param->kernel12 = hc_clCreateKernel (device_param->program, kernel_name);
13666 }
13667
13668 if (opts_type & OPTS_TYPE_HOOK23)
13669 {
13670 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
13671
13672 device_param->kernel23 = hc_clCreateKernel (device_param->program, kernel_name);
13673 }
13674 }
13675
13676 for (uint i = 0; i <= 20; i++)
13677 {
13678 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
13679 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
13680 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
13681
13682 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
13683 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
13684 }
13685
13686 for (uint i = 21; i <= 31; i++)
13687 {
13688 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
13689 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
13690 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
13691
13692 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
13693 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
13694 }
13695
13696 if (attack_mode == ATTACK_MODE_BF)
13697 {
13698 device_param->kernel_mp_l = hc_clCreateKernel (device_param->program_mp, "l_markov");
13699 device_param->kernel_mp_r = hc_clCreateKernel (device_param->program_mp, "r_markov");
13700
13701 if (opts_type & OPTS_TYPE_PT_BITSLICE)
13702 {
13703 hc_clSetKernelArg (device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
13704
13705 hc_clSetKernelArg (device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
13706 hc_clSetKernelArg (device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
13707 }
13708 }
13709 else if (attack_mode == ATTACK_MODE_HYBRID1)
13710 {
13711 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
13712 }
13713 else if (attack_mode == ATTACK_MODE_HYBRID2)
13714 {
13715 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
13716 }
13717
13718 if (attack_exec == ATTACK_EXEC_ON_GPU)
13719 {
13720 // nothing to do
13721 }
13722 else
13723 {
13724 for (uint i = 0; i < 5; i++)
13725 {
13726 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
13727 }
13728
13729 for (uint i = 5; i < 7; i++)
13730 {
13731 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
13732 }
13733 }
13734
13735 /**
13736 * Store initial fanspeed if gpu_temp_retain is enabled
13737 */
13738
13739 int gpu_temp_retain_set = 0;
13740
13741 if (gpu_temp_disable == 0)
13742 {
13743 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
13744 {
13745 hc_thread_mutex_lock (mux_adl);
13746
13747 if (data.hm_device[device_id].fan_supported == 1)
13748 {
13749 if (gpu_temp_retain_chgd == 0)
13750 {
13751 uint cur_temp = 0;
13752 uint default_temp = 0;
13753
13754 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);
13755
13756 if (ADL_rc == ADL_OK)
13757 {
13758 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
13759
13760 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
13761
13762 // special case with multi gpu setups: always use minimum retain
13763
13764 if (gpu_temp_retain_set == 0)
13765 {
13766 gpu_temp_retain = gpu_temp_retain_target;
13767 gpu_temp_retain_set = 1;
13768 }
13769 else
13770 {
13771 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
13772 }
13773
13774 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
13775 }
13776 }
13777
13778 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
13779
13780 temp_retain_fanspeed_value[device_id] = fan_speed;
13781
13782 if (fan_speed == -1)
13783 {
13784 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
13785
13786 temp_retain_fanspeed_value[device_id] = 0;
13787 }
13788 }
13789
13790 hc_thread_mutex_unlock (mux_adl);
13791 }
13792 }
13793
13794 /**
13795 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
13796 */
13797
13798 if (powertune_enable == 1) // VENDOR_ID_AMD implied
13799 {
13800 hc_thread_mutex_lock (mux_adl);
13801
13802 if (data.hm_device[device_id].od_version == 6)
13803 {
13804 int ADL_rc;
13805
13806 // check powertune capabilities first, if not available then skip device
13807
13808 int powertune_supported = 0;
13809
13810 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13811 {
13812 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13813
13814 return (-1);
13815 }
13816
13817 if (powertune_supported != 0)
13818 {
13819 // powercontrol settings
13820
13821 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13822
13823 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
13824 {
13825 ADL_rc = hc_ADL_Overdrive_PowerControl_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
13826 }
13827
13828 if (ADL_rc != ADL_OK)
13829 {
13830 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13831
13832 return (-1);
13833 }
13834
13835 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13836 {
13837 log_error ("ERROR: Failed to set new ADL PowerControl values");
13838
13839 return (-1);
13840 }
13841
13842 // clocks
13843
13844 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
13845
13846 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
13847
13848 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)
13849 {
13850 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
13851
13852 return (-1);
13853 }
13854
13855 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
13856
13857 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
13858
13859 if ((ADL_rc = hc_ADL_Overdrive_Capabilities_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
13860 {
13861 log_error ("ERROR: Failed to get ADL device capabilities");
13862
13863 return (-1);
13864 }
13865
13866 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
13867 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
13868
13869 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
13870 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
13871
13872 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
13873 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
13874
13875 // warning if profile has to low max values
13876
13877 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
13878 {
13879 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
13880 }
13881
13882 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
13883 {
13884 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
13885 }
13886
13887 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
13888
13889 performance_state->iNumberOfPerformanceLevels = 2;
13890
13891 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
13892 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
13893 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
13894 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
13895
13896 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)
13897 {
13898 log_info ("ERROR: Failed to set ADL performance state");
13899
13900 return (-1);
13901 }
13902
13903 local_free (performance_state);
13904 }
13905 }
13906
13907 hc_thread_mutex_unlock (mux_adl);
13908 }
13909 }
13910
13911 data.gpu_blocks_all = gpu_blocks_all;
13912
13913 if (data.quiet == 0) log_info ("");
13914
13915 /**
13916 * Inform user which algorithm is checked and at which workload setting
13917 */
13918
13919 if (benchmark == 1)
13920 {
13921 quiet = 0;
13922
13923 data.quiet = quiet;
13924
13925 char *hash_type = strhashtype (data.hash_mode); // not a bug
13926
13927 log_info ("Hashtype: %s", hash_type);
13928 log_info ("Workload: %u loops, %u accel", gpu_loops, gpu_accel);
13929 log_info ("");
13930 }
13931
13932 /**
13933 * keep track of the progress
13934 */
13935
13936 data.words_progress_done = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
13937 data.words_progress_rejected = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
13938 data.words_progress_restored = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
13939
13940 /**
13941 * open filehandles
13942 */
13943
13944 #if _WIN
13945 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
13946 {
13947 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
13948
13949 return (-1);
13950 }
13951
13952 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
13953 {
13954 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
13955
13956 return (-1);
13957 }
13958
13959 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
13960 {
13961 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
13962
13963 return (-1);
13964 }
13965 #endif
13966
13967 /**
13968 * dictionary pad
13969 */
13970
13971 segment_size *= (1024 * 1024);
13972
13973 data.segment_size = segment_size;
13974
13975 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
13976
13977 wl_data->buf = (char *) mymalloc (segment_size);
13978 wl_data->avail = segment_size;
13979 wl_data->incr = segment_size;
13980 wl_data->cnt = 0;
13981 wl_data->pos = 0;
13982
13983 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
13984
13985 data.wordlist_mode = wordlist_mode;
13986
13987 cs_t *css_buf = NULL;
13988 uint css_cnt = 0;
13989 uint dictcnt = 0;
13990 uint maskcnt = 1;
13991 char **masks = NULL;
13992 char **dictfiles = NULL;
13993
13994 uint mask_from_file = 0;
13995
13996 if (attack_mode == ATTACK_MODE_STRAIGHT)
13997 {
13998 if (wordlist_mode == WL_MODE_FILE)
13999 {
14000 int wls_left = myargc - (optind + 1);
14001
14002 for (int i = 0; i < wls_left; i++)
14003 {
14004 char *l0_filename = myargv[optind + 1 + i];
14005
14006 struct stat l0_stat;
14007
14008 if (stat (l0_filename, &l0_stat) == -1)
14009 {
14010 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14011
14012 return (-1);
14013 }
14014
14015 uint is_dir = S_ISDIR (l0_stat.st_mode);
14016
14017 if (is_dir == 0)
14018 {
14019 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14020
14021 dictcnt++;
14022
14023 dictfiles[dictcnt - 1] = l0_filename;
14024 }
14025 else
14026 {
14027 // do not allow --keyspace w/ a directory
14028
14029 if (keyspace == 1)
14030 {
14031 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14032
14033 return (-1);
14034 }
14035
14036 char **dictionary_files = NULL;
14037
14038 dictionary_files = scan_directory (l0_filename);
14039
14040 if (dictionary_files != NULL)
14041 {
14042 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14043
14044 for (int d = 0; dictionary_files[d] != NULL; d++)
14045 {
14046 char *l1_filename = dictionary_files[d];
14047
14048 struct stat l1_stat;
14049
14050 if (stat (l1_filename, &l1_stat) == -1)
14051 {
14052 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14053
14054 return (-1);
14055 }
14056
14057 if (S_ISREG (l1_stat.st_mode))
14058 {
14059 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14060
14061 dictcnt++;
14062
14063 dictfiles[dictcnt - 1] = strdup (l1_filename);
14064 }
14065 }
14066 }
14067
14068 local_free (dictionary_files);
14069 }
14070 }
14071
14072 if (dictcnt < 1)
14073 {
14074 log_error ("ERROR: No usable dictionary file found.");
14075
14076 return (-1);
14077 }
14078 }
14079 else if (wordlist_mode == WL_MODE_STDIN)
14080 {
14081 dictcnt = 1;
14082 }
14083 }
14084 else if (attack_mode == ATTACK_MODE_COMBI)
14085 {
14086 // display
14087
14088 char *dictfile1 = myargv[optind + 1 + 0];
14089 char *dictfile2 = myargv[optind + 1 + 1];
14090
14091 // find the bigger dictionary and use as base
14092
14093 FILE *fp1;
14094 FILE *fp2;
14095
14096 struct stat tmp_stat;
14097
14098 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14099 {
14100 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14101
14102 return (-1);
14103 }
14104
14105 if (stat (dictfile1, &tmp_stat) == -1)
14106 {
14107 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14108
14109 fclose (fp1);
14110
14111 return (-1);
14112 }
14113
14114 if (S_ISDIR (tmp_stat.st_mode))
14115 {
14116 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14117
14118 fclose (fp1);
14119
14120 return (-1);
14121 }
14122
14123 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14124 {
14125 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14126
14127 fclose (fp1);
14128
14129 return (-1);
14130 }
14131
14132 if (stat (dictfile2, &tmp_stat) == -1)
14133 {
14134 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14135
14136 fclose (fp1);
14137 fclose (fp2);
14138
14139 return (-1);
14140 }
14141
14142 if (S_ISDIR (tmp_stat.st_mode))
14143 {
14144 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14145
14146 fclose (fp1);
14147 fclose (fp2);
14148
14149 return (-1);
14150 }
14151
14152 data.combs_cnt = 1;
14153
14154 data.quiet = 1;
14155
14156 const uint64_t words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14157
14158 data.quiet = quiet;
14159
14160 if (words1_cnt == 0)
14161 {
14162 log_error ("ERROR: %s: empty file", dictfile1);
14163
14164 fclose (fp1);
14165 fclose (fp2);
14166
14167 return (-1);
14168 }
14169
14170 data.combs_cnt = 1;
14171
14172 data.quiet = 1;
14173
14174 const uint64_t words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14175
14176 data.quiet = quiet;
14177
14178 if (words2_cnt == 0)
14179 {
14180 log_error ("ERROR: %s: empty file", dictfile2);
14181
14182 fclose (fp1);
14183 fclose (fp2);
14184
14185 return (-1);
14186 }
14187
14188 fclose (fp1);
14189 fclose (fp2);
14190
14191 data.dictfile = dictfile1;
14192 data.dictfile2 = dictfile2;
14193
14194 if (words1_cnt >= words2_cnt)
14195 {
14196 data.combs_cnt = words2_cnt;
14197 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14198
14199 dictfiles = &data.dictfile;
14200
14201 dictcnt = 1;
14202 }
14203 else
14204 {
14205 data.combs_cnt = words1_cnt;
14206 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14207
14208 dictfiles = &data.dictfile2;
14209
14210 dictcnt = 1;
14211
14212 // we also have to switch wordlist related rules!
14213
14214 char *tmpc = data.rule_buf_l;
14215
14216 data.rule_buf_l = data.rule_buf_r;
14217 data.rule_buf_r = tmpc;
14218
14219 int tmpi = data.rule_len_l;
14220
14221 data.rule_len_l = data.rule_len_r;
14222 data.rule_len_r = tmpi;
14223 }
14224 }
14225 else if (attack_mode == ATTACK_MODE_BF)
14226 {
14227 char *mask = NULL;
14228
14229 maskcnt = 0;
14230
14231 if (benchmark == 0)
14232 {
14233 mask = myargv[optind + 1];
14234
14235 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
14236
14237 if ((optind + 2) <= myargc)
14238 {
14239 struct stat file_stat;
14240
14241 if (stat (mask, &file_stat) == -1)
14242 {
14243 maskcnt = 1;
14244
14245 masks[maskcnt - 1] = mystrdup (mask);
14246 }
14247 else
14248 {
14249 int wls_left = myargc - (optind + 1);
14250
14251 uint masks_avail = INCR_MASKS;
14252
14253 for (int i = 0; i < wls_left; i++)
14254 {
14255 if (i != 0)
14256 {
14257 mask = myargv[optind + 1 + i];
14258
14259 if (stat (mask, &file_stat) == -1)
14260 {
14261 log_error ("ERROR: %s: %s", mask, strerror (errno));
14262
14263 return (-1);
14264 }
14265 }
14266
14267 uint is_file = S_ISREG (file_stat.st_mode);
14268
14269 if (is_file == 1)
14270 {
14271 FILE *mask_fp;
14272
14273 if ((mask_fp = fopen (mask, "r")) == NULL)
14274 {
14275 log_error ("ERROR: %s: %s", mask, strerror (errno));
14276
14277 return (-1);
14278 }
14279
14280 char line_buf[BUFSIZ];
14281
14282 while (!feof (mask_fp))
14283 {
14284 memset (line_buf, 0, BUFSIZ);
14285
14286 int line_len = fgetl (mask_fp, line_buf);
14287
14288 if (line_len == 0) continue;
14289
14290 if (line_buf[0] == '#') continue;
14291
14292 if (masks_avail == maskcnt)
14293 {
14294 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14295
14296 masks_avail += INCR_MASKS;
14297 }
14298
14299 masks[maskcnt] = mystrdup (line_buf);
14300
14301 maskcnt++;
14302 }
14303
14304 fclose (mask_fp);
14305 }
14306 else
14307 {
14308 log_error ("ERROR: %s: unsupported file-type", mask);
14309
14310 return (-1);
14311 }
14312 }
14313
14314 mask_from_file = 1;
14315 }
14316 }
14317 else
14318 {
14319 custom_charset_1 = (char *) "?l?d?u";
14320 custom_charset_2 = (char *) "?l?d";
14321 custom_charset_3 = (char *) "?l?d*!$@_";
14322
14323 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
14324 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
14325 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
14326
14327 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
14328
14329 wordlist_mode = WL_MODE_MASK;
14330
14331 data.wordlist_mode = wordlist_mode;
14332
14333 increment = 1;
14334
14335 maskcnt = 1;
14336 }
14337 }
14338 else
14339 {
14340 /**
14341 * generate full masks and charsets
14342 */
14343
14344 masks = (char **) mymalloc (sizeof (char *));
14345
14346 switch (hash_mode)
14347 {
14348 case 1731: pw_min = 5;
14349 pw_max = 5;
14350 mask = mystrdup ("?b?b?b?b?b");
14351 break;
14352 case 12500: pw_min = 5;
14353 pw_max = 5;
14354 mask = mystrdup ("?b?b?b?b?b");
14355 break;
14356 default: pw_min = 7;
14357 pw_max = 7;
14358 mask = mystrdup ("?b?b?b?b?b?b?b");
14359 break;
14360 }
14361
14362 maskcnt = 1;
14363
14364 masks[maskcnt - 1] = mystrdup (mask);
14365
14366 wordlist_mode = WL_MODE_MASK;
14367
14368 data.wordlist_mode = wordlist_mode;
14369
14370 increment = 1;
14371 }
14372
14373 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
14374
14375 if (increment)
14376 {
14377 if (increment_min > pw_min) pw_min = increment_min;
14378
14379 if (increment_max < pw_max) pw_max = increment_max;
14380 }
14381 }
14382 else if (attack_mode == ATTACK_MODE_HYBRID1)
14383 {
14384 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14385
14386 // display
14387
14388 char *mask = myargv[myargc - 1];
14389
14390 maskcnt = 0;
14391
14392 masks = (char **) mymalloc (1 * sizeof (char *));
14393
14394 // mod
14395
14396 struct stat file_stat;
14397
14398 if (stat (mask, &file_stat) == -1)
14399 {
14400 maskcnt = 1;
14401
14402 masks[maskcnt - 1] = mystrdup (mask);
14403 }
14404 else
14405 {
14406 uint is_file = S_ISREG (file_stat.st_mode);
14407
14408 if (is_file == 1)
14409 {
14410 FILE *mask_fp;
14411
14412 if ((mask_fp = fopen (mask, "r")) == NULL)
14413 {
14414 log_error ("ERROR: %s: %s", mask, strerror (errno));
14415
14416 return (-1);
14417 }
14418
14419 char line_buf[BUFSIZ];
14420
14421 uint masks_avail = 1;
14422
14423 while (!feof (mask_fp))
14424 {
14425 memset (line_buf, 0, BUFSIZ);
14426
14427 int line_len = fgetl (mask_fp, line_buf);
14428
14429 if (line_len == 0) continue;
14430
14431 if (line_buf[0] == '#') continue;
14432
14433 if (masks_avail == maskcnt)
14434 {
14435 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14436
14437 masks_avail += INCR_MASKS;
14438 }
14439
14440 masks[maskcnt] = mystrdup (line_buf);
14441
14442 maskcnt++;
14443 }
14444
14445 fclose (mask_fp);
14446
14447 mask_from_file = 1;
14448 }
14449 else
14450 {
14451 maskcnt = 1;
14452
14453 masks[maskcnt - 1] = mystrdup (mask);
14454 }
14455 }
14456
14457 // base
14458
14459 int wls_left = myargc - (optind + 2);
14460
14461 for (int i = 0; i < wls_left; i++)
14462 {
14463 char *filename = myargv[optind + 1 + i];
14464
14465 struct stat file_stat;
14466
14467 if (stat (filename, &file_stat) == -1)
14468 {
14469 log_error ("ERROR: %s: %s", filename, strerror (errno));
14470
14471 return (-1);
14472 }
14473
14474 uint is_dir = S_ISDIR (file_stat.st_mode);
14475
14476 if (is_dir == 0)
14477 {
14478 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14479
14480 dictcnt++;
14481
14482 dictfiles[dictcnt - 1] = filename;
14483 }
14484 else
14485 {
14486 // do not allow --keyspace w/ a directory
14487
14488 if (keyspace == 1)
14489 {
14490 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14491
14492 return (-1);
14493 }
14494
14495 char **dictionary_files = NULL;
14496
14497 dictionary_files = scan_directory (filename);
14498
14499 if (dictionary_files != NULL)
14500 {
14501 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14502
14503 for (int d = 0; dictionary_files[d] != NULL; d++)
14504 {
14505 char *l1_filename = dictionary_files[d];
14506
14507 struct stat l1_stat;
14508
14509 if (stat (l1_filename, &l1_stat) == -1)
14510 {
14511 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14512
14513 return (-1);
14514 }
14515
14516 if (S_ISREG (l1_stat.st_mode))
14517 {
14518 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14519
14520 dictcnt++;
14521
14522 dictfiles[dictcnt - 1] = strdup (l1_filename);
14523 }
14524 }
14525 }
14526
14527 local_free (dictionary_files);
14528 }
14529 }
14530
14531 if (dictcnt < 1)
14532 {
14533 log_error ("ERROR: No usable dictionary file found.");
14534
14535 return (-1);
14536 }
14537
14538 if (increment)
14539 {
14540 maskcnt = 0;
14541
14542 uint mask_min = increment_min; // we can't reject smaller masks here
14543 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
14544
14545 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
14546 {
14547 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
14548
14549 if (cur_mask == NULL) break;
14550
14551 masks[maskcnt] = cur_mask;
14552
14553 maskcnt++;
14554
14555 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
14556 }
14557 }
14558 }
14559 else if (attack_mode == ATTACK_MODE_HYBRID2)
14560 {
14561 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14562
14563 // display
14564
14565 char *mask = myargv[optind + 1 + 0];
14566
14567 maskcnt = 0;
14568
14569 masks = (char **) mymalloc (1 * sizeof (char *));
14570
14571 // mod
14572
14573 struct stat file_stat;
14574
14575 if (stat (mask, &file_stat) == -1)
14576 {
14577 maskcnt = 1;
14578
14579 masks[maskcnt - 1] = mystrdup (mask);
14580 }
14581 else
14582 {
14583 uint is_file = S_ISREG (file_stat.st_mode);
14584
14585 if (is_file == 1)
14586 {
14587 FILE *mask_fp;
14588
14589 if ((mask_fp = fopen (mask, "r")) == NULL)
14590 {
14591 log_error ("ERROR: %s: %s", mask, strerror (errno));
14592
14593 return (-1);
14594 }
14595
14596 char line_buf[BUFSIZ];
14597
14598 uint masks_avail = 1;
14599
14600 while (!feof (mask_fp))
14601 {
14602 memset (line_buf, 0, BUFSIZ);
14603
14604 int line_len = fgetl (mask_fp, line_buf);
14605
14606 if (line_len == 0) continue;
14607
14608 if (line_buf[0] == '#') continue;
14609
14610 if (masks_avail == maskcnt)
14611 {
14612 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14613
14614 masks_avail += INCR_MASKS;
14615 }
14616
14617 masks[maskcnt] = mystrdup (line_buf);
14618
14619 maskcnt++;
14620 }
14621
14622 fclose (mask_fp);
14623
14624 mask_from_file = 1;
14625 }
14626 else
14627 {
14628 maskcnt = 1;
14629
14630 masks[maskcnt - 1] = mystrdup (mask);
14631 }
14632 }
14633
14634 // base
14635
14636 int wls_left = myargc - (optind + 2);
14637
14638 for (int i = 0; i < wls_left; i++)
14639 {
14640 char *filename = myargv[optind + 2 + i];
14641
14642 struct stat file_stat;
14643
14644 if (stat (filename, &file_stat) == -1)
14645 {
14646 log_error ("ERROR: %s: %s", filename, strerror (errno));
14647
14648 return (-1);
14649 }
14650
14651 uint is_dir = S_ISDIR (file_stat.st_mode);
14652
14653 if (is_dir == 0)
14654 {
14655 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14656
14657 dictcnt++;
14658
14659 dictfiles[dictcnt - 1] = filename;
14660 }
14661 else
14662 {
14663 // do not allow --keyspace w/ a directory
14664
14665 if (keyspace == 1)
14666 {
14667 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14668
14669 return (-1);
14670 }
14671
14672 char **dictionary_files = NULL;
14673
14674 dictionary_files = scan_directory (filename);
14675
14676 if (dictionary_files != NULL)
14677 {
14678 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14679
14680 for (int d = 0; dictionary_files[d] != NULL; d++)
14681 {
14682 char *l1_filename = dictionary_files[d];
14683
14684 struct stat l1_stat;
14685
14686 if (stat (l1_filename, &l1_stat) == -1)
14687 {
14688 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14689
14690 return (-1);
14691 }
14692
14693 if (S_ISREG (l1_stat.st_mode))
14694 {
14695 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14696
14697 dictcnt++;
14698
14699 dictfiles[dictcnt - 1] = strdup (l1_filename);
14700 }
14701 }
14702 }
14703
14704 local_free (dictionary_files);
14705 }
14706 }
14707
14708 if (dictcnt < 1)
14709 {
14710 log_error ("ERROR: No usable dictionary file found.");
14711
14712 return (-1);
14713 }
14714
14715 if (increment)
14716 {
14717 maskcnt = 0;
14718
14719 uint mask_min = increment_min; // we can't reject smaller masks here
14720 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
14721
14722 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
14723 {
14724 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
14725
14726 if (cur_mask == NULL) break;
14727
14728 masks[maskcnt] = cur_mask;
14729
14730 maskcnt++;
14731
14732 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
14733 }
14734 }
14735 }
14736
14737 data.pw_min = pw_min;
14738 data.pw_max = pw_max;
14739
14740 /**
14741 * weak hash check
14742 */
14743
14744 if (weak_hash_threshold >= salts_cnt)
14745 {
14746 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
14747
14748 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
14749 {
14750 weak_hash_check (&data.devices_param[0], salt_pos, gpu_loops);
14751 }
14752 }
14753
14754 // Display hack, guarantee that there is at least one \r before real start
14755
14756 if (data.quiet == 0) log_info_nn ("");
14757
14758 /**
14759 * status and monitor threads
14760 */
14761
14762 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
14763
14764 hc_thread_t i_thread = 0;
14765
14766 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
14767 {
14768 hc_thread_create (i_thread, thread_keypress, &benchmark);
14769 }
14770
14771 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
14772
14773 uint ni_threads_cnt = 0;
14774
14775 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
14776
14777 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
14778
14779 ni_threads_cnt++;
14780
14781 /**
14782 * Outfile remove
14783 */
14784
14785 if (keyspace == 0)
14786 {
14787 if (outfile_check_timer != 0)
14788 {
14789 if (data.outfile_check_directory != NULL)
14790 {
14791 if ((hash_mode != 5200) &&
14792 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
14793 (hash_mode != 9000))
14794 {
14795 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
14796
14797 ni_threads_cnt++;
14798 }
14799 else
14800 {
14801 outfile_check_timer = 0;
14802 }
14803 }
14804 else
14805 {
14806 outfile_check_timer = 0;
14807 }
14808 }
14809 }
14810
14811 /**
14812 * Inform the user if we got some hashes remove because of the pot file remove feature
14813 */
14814
14815 if (data.quiet == 0)
14816 {
14817 if (potfile_remove_cracks > 0)
14818 {
14819 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
14820 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
14821 }
14822 }
14823
14824 data.outfile_check_timer = outfile_check_timer;
14825
14826 /**
14827 * main loop
14828 */
14829
14830 char **induction_dictionaries = NULL;
14831
14832 int induction_dictionaries_cnt = 0;
14833
14834 hcstat_table_t *root_table_buf = NULL;
14835 hcstat_table_t *markov_table_buf = NULL;
14836
14837 uint initial_restore_done = 0;
14838
14839 data.maskcnt = maskcnt;
14840
14841 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
14842 {
14843 if (data.devices_status == STATUS_CRACKED) break;
14844
14845 data.devices_status = STATUS_INIT;
14846
14847 if (maskpos > rd->maskpos)
14848 {
14849 rd->dictpos = 0;
14850 }
14851
14852 rd->maskpos = maskpos;
14853 data.maskpos = maskpos;
14854
14855 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
14856 {
14857 char *mask = masks[maskpos];
14858
14859 if (mask_from_file == 1)
14860 {
14861 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
14862
14863 char *str_ptr;
14864 uint str_pos;
14865
14866 uint mask_offset = 0;
14867
14868 uint separator_cnt;
14869
14870 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
14871 {
14872 str_ptr = strstr (mask + mask_offset, ",");
14873
14874 if (str_ptr == NULL) break;
14875
14876 str_pos = str_ptr - mask;
14877
14878 // escaped separator, i.e. "\,"
14879
14880 if (str_pos > 0)
14881 {
14882 if (mask[str_pos - 1] == '\\')
14883 {
14884 separator_cnt --;
14885
14886 mask_offset = str_pos + 1;
14887
14888 continue;
14889 }
14890 }
14891
14892 // reset the offset
14893
14894 mask_offset = 0;
14895
14896 mask[str_pos] = '\0';
14897
14898 switch (separator_cnt)
14899 {
14900 case 0:
14901 mp_reset_usr (mp_usr, 0);
14902
14903 custom_charset_1 = mask;
14904 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
14905 break;
14906
14907 case 1:
14908 mp_reset_usr (mp_usr, 1);
14909
14910 custom_charset_2 = mask;
14911 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
14912 break;
14913
14914 case 2:
14915 mp_reset_usr (mp_usr, 2);
14916
14917 custom_charset_3 = mask;
14918 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
14919 break;
14920
14921 case 3:
14922 mp_reset_usr (mp_usr, 3);
14923
14924 custom_charset_4 = mask;
14925 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
14926 break;
14927 }
14928
14929 mask = mask + str_pos + 1;
14930 }
14931 }
14932
14933 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
14934 {
14935 if (maskpos > 0)
14936 {
14937 local_free (css_buf);
14938 local_free (data.root_css_buf);
14939 local_free (data.markov_css_buf);
14940
14941 local_free (masks[maskpos - 1]);
14942 }
14943
14944 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
14945
14946 data.mask = mask;
14947 data.css_cnt = css_cnt;
14948 data.css_buf = css_buf;
14949
14950 uint uniq_tbls[SP_PW_MAX][CHARSIZ];
14951
14952 memset (uniq_tbls, 0, sizeof (uniq_tbls));
14953
14954 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
14955
14956 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
14957 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
14958
14959 sp_setup_tbl (install_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
14960
14961 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
14962
14963 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
14964 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
14965
14966 data.root_css_buf = root_css_buf;
14967 data.markov_css_buf = markov_css_buf;
14968
14969 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
14970
14971 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
14972
14973 local_free (root_table_buf);
14974 local_free (markov_table_buf);
14975
14976 // args
14977
14978 for (uint device_id = 0; device_id < devices_cnt; device_id++)
14979 {
14980 hc_device_param_t *device_param = &data.devices_param[device_id];
14981
14982 device_param->kernel_params_mp[0] = &device_param->d_combs;
14983 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
14984 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
14985
14986 device_param->kernel_params_mp_buf64[3] = 0;
14987 device_param->kernel_params_mp_buf32[4] = css_cnt;
14988 device_param->kernel_params_mp_buf32[5] = 0;
14989 device_param->kernel_params_mp_buf32[6] = 0;
14990 device_param->kernel_params_mp_buf32[7] = 0;
14991
14992 if (attack_mode == ATTACK_MODE_HYBRID1)
14993 {
14994 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
14995 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
14996 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
14997 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
14998 }
14999 else if (attack_mode == ATTACK_MODE_HYBRID2)
15000 {
15001 device_param->kernel_params_mp_buf32[5] = 0;
15002 device_param->kernel_params_mp_buf32[6] = 0;
15003 device_param->kernel_params_mp_buf32[7] = 0;
15004 }
15005
15006 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp[i]);
15007 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp[i]);
15008 for (uint i = 4; i < 8; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp[i]);
15009
15010 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);
15011 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);
15012 }
15013 }
15014 else if (attack_mode == ATTACK_MODE_BF)
15015 {
15016 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15017
15018 if (increment)
15019 {
15020 for (uint i = 0; i < dictcnt; i++)
15021 {
15022 local_free (dictfiles[i]);
15023 }
15024
15025 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15026 {
15027 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15028
15029 if (l1_filename == NULL) break;
15030
15031 dictcnt++;
15032
15033 dictfiles[dictcnt - 1] = l1_filename;
15034 }
15035 }
15036 else
15037 {
15038 dictcnt++;
15039
15040 dictfiles[dictcnt - 1] = mask;
15041 }
15042
15043 if (dictcnt == 0)
15044 {
15045 log_error ("ERROR: Mask is too small");
15046
15047 return (-1);
15048 }
15049 }
15050 }
15051
15052 free (induction_dictionaries);
15053
15054 // induction_dictionaries_cnt = 0; // implied
15055
15056 if (attack_mode != ATTACK_MODE_BF)
15057 {
15058 if (keyspace == 0)
15059 {
15060 induction_dictionaries = scan_directory (induction_directory);
15061
15062 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15063 }
15064 }
15065
15066 if (induction_dictionaries_cnt)
15067 {
15068 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15069 }
15070
15071 /**
15072 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15073 */
15074 if (keyspace == 1)
15075 {
15076 if ((maskcnt > 1) || (dictcnt > 1))
15077 {
15078 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15079
15080 return (-1);
15081 }
15082 }
15083
15084 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15085 {
15086 char *subid = logfile_generate_subid ();
15087
15088 data.subid = subid;
15089
15090 logfile_sub_msg ("START");
15091
15092 data.devices_status = STATUS_INIT;
15093
15094 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (uint64_t));
15095 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (uint64_t));
15096 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (uint64_t));
15097
15098 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15099
15100 data.cpt_pos = 0;
15101
15102 data.cpt_start = time (NULL);
15103
15104 data.cpt_total = 0;
15105
15106 if (data.restore == 0)
15107 {
15108 rd->words_cur = skip;
15109
15110 skip = 0;
15111
15112 data.skip = 0;
15113 }
15114
15115 data.ms_paused = 0;
15116
15117 data.words_cur = rd->words_cur;
15118
15119 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15120 {
15121 hc_device_param_t *device_param = &data.devices_param[device_id];
15122
15123 device_param->speed_pos = 0;
15124
15125 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (uint64_t));
15126 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15127 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15128
15129 device_param->gpu_power = device_param->gpu_power_user;
15130 device_param->gpu_blocks = device_param->gpu_blocks_user;
15131
15132 device_param->outerloop_pos = 0;
15133 device_param->outerloop_left = 0;
15134 device_param->innerloop_pos = 0;
15135 device_param->innerloop_left = 0;
15136
15137 // some more resets:
15138
15139 memset (device_param->pw_caches, 0, 64 * sizeof (pw_cache_t));
15140
15141 memset (device_param->pws_buf, 0, device_param->size_pws);
15142
15143 device_param->pw_cnt = 0;
15144 device_param->pws_cnt = 0;
15145
15146 device_param->words_off = 0;
15147 device_param->words_done = 0;
15148 }
15149
15150 data.gpu_blocks_div = 0;
15151
15152 // figure out some workload
15153
15154 if (attack_mode == ATTACK_MODE_STRAIGHT)
15155 {
15156 if (data.wordlist_mode == WL_MODE_FILE)
15157 {
15158 char *dictfile = NULL;
15159
15160 if (induction_dictionaries_cnt)
15161 {
15162 dictfile = induction_dictionaries[0];
15163 }
15164 else
15165 {
15166 dictfile = dictfiles[dictpos];
15167 }
15168
15169 data.dictfile = dictfile;
15170
15171 logfile_sub_string (dictfile);
15172
15173 for (uint i = 0; i < rp_files_cnt; i++)
15174 {
15175 logfile_sub_var_string ("rulefile", rp_files[i]);
15176 }
15177
15178 FILE *fd2 = fopen (dictfile, "rb");
15179
15180 if (fd2 == NULL)
15181 {
15182 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15183
15184 return (-1);
15185 }
15186
15187 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15188
15189 fclose (fd2);
15190
15191 if (data.words_cnt == 0)
15192 {
15193 if (data.devices_status == STATUS_CRACKED) break;
15194 if (data.devices_status == STATUS_ABORTED) break;
15195
15196 dictpos++;
15197
15198 continue;
15199 }
15200 }
15201 }
15202 else if (attack_mode == ATTACK_MODE_COMBI)
15203 {
15204 char *dictfile = data.dictfile;
15205 char *dictfile2 = data.dictfile2;
15206
15207 logfile_sub_string (dictfile);
15208 logfile_sub_string (dictfile2);
15209
15210 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
15211 {
15212 FILE *fd2 = fopen (dictfile, "rb");
15213
15214 if (fd2 == NULL)
15215 {
15216 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15217
15218 return (-1);
15219 }
15220
15221 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15222
15223 fclose (fd2);
15224 }
15225 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
15226 {
15227 FILE *fd2 = fopen (dictfile2, "rb");
15228
15229 if (fd2 == NULL)
15230 {
15231 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15232
15233 return (-1);
15234 }
15235
15236 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
15237
15238 fclose (fd2);
15239 }
15240
15241 if (data.words_cnt == 0)
15242 {
15243 if (data.devices_status == STATUS_CRACKED) break;
15244 if (data.devices_status == STATUS_ABORTED) break;
15245
15246 dictpos++;
15247
15248 continue;
15249 }
15250 }
15251 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15252 {
15253 char *dictfile = NULL;
15254
15255 if (induction_dictionaries_cnt)
15256 {
15257 dictfile = induction_dictionaries[0];
15258 }
15259 else
15260 {
15261 dictfile = dictfiles[dictpos];
15262 }
15263
15264 data.dictfile = dictfile;
15265
15266 char *mask = data.mask;
15267
15268 logfile_sub_string (dictfile);
15269 logfile_sub_string (mask);
15270
15271 FILE *fd2 = fopen (dictfile, "rb");
15272
15273 if (fd2 == NULL)
15274 {
15275 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15276
15277 return (-1);
15278 }
15279
15280 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15281
15282 fclose (fd2);
15283
15284 if (data.words_cnt == 0)
15285 {
15286 if (data.devices_status == STATUS_CRACKED) break;
15287 if (data.devices_status == STATUS_ABORTED) break;
15288
15289 dictpos++;
15290
15291 continue;
15292 }
15293 }
15294 else if (attack_mode == ATTACK_MODE_BF)
15295 {
15296 local_free (css_buf);
15297 local_free (data.root_css_buf);
15298 local_free (data.markov_css_buf);
15299
15300 char *mask = dictfiles[dictpos];
15301
15302 logfile_sub_string (mask);
15303
15304 // base
15305
15306 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15307
15308 if (opts_type & OPTS_TYPE_PT_UNICODE)
15309 {
15310 uint css_cnt_unicode = css_cnt * 2;
15311
15312 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
15313
15314 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
15315 {
15316 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
15317
15318 css_buf_unicode[j + 1].cs_buf[0] = 0;
15319 css_buf_unicode[j + 1].cs_len = 1;
15320 }
15321
15322 free (css_buf);
15323
15324 css_buf = css_buf_unicode;
15325 css_cnt = css_cnt_unicode;
15326 }
15327
15328 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
15329
15330 uint mask_min = pw_min;
15331 uint mask_max = pw_max;
15332
15333 if (opts_type & OPTS_TYPE_PT_UNICODE)
15334 {
15335 mask_min *= 2;
15336 mask_max *= 2;
15337 }
15338
15339 if ((css_cnt < mask_min) || (css_cnt > mask_max))
15340 {
15341 if (css_cnt < mask_min)
15342 {
15343 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
15344 }
15345
15346 if (css_cnt > mask_max)
15347 {
15348 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
15349 }
15350
15351 // skip to next mask
15352
15353 dictpos++;
15354
15355 rd->dictpos = dictpos;
15356
15357 logfile_sub_msg ("STOP");
15358
15359 continue;
15360 }
15361
15362 uint save_css_cnt = css_cnt;
15363
15364 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15365 {
15366 if (opti_type & OPTI_TYPE_APPENDED_SALT)
15367 {
15368 uint salt_len = (uint) data.salts_buf[0].salt_len;
15369 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
15370
15371 uint css_cnt_salt = css_cnt + salt_len;
15372
15373 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
15374
15375 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
15376
15377 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
15378 {
15379 css_buf_salt[j].cs_buf[0] = salt_buf[i];
15380 css_buf_salt[j].cs_len = 1;
15381 }
15382
15383 free (css_buf);
15384
15385 css_buf = css_buf_salt;
15386 css_cnt = css_cnt_salt;
15387 }
15388 }
15389
15390 data.mask = mask;
15391 data.css_cnt = css_cnt;
15392 data.css_buf = css_buf;
15393
15394 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
15395
15396 uint uniq_tbls[SP_PW_MAX][CHARSIZ];
15397
15398 memset (uniq_tbls, 0, sizeof (uniq_tbls));
15399
15400 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15401
15402 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15403 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15404
15405 sp_setup_tbl (install_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15406
15407 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15408
15409 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15410 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15411
15412 data.root_css_buf = root_css_buf;
15413 data.markov_css_buf = markov_css_buf;
15414
15415 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15416
15417 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15418
15419 local_free (root_table_buf);
15420 local_free (markov_table_buf);
15421
15422 // copy + args
15423
15424 uint css_cnt_l = css_cnt;
15425 uint css_cnt_r;
15426
15427 if (attack_exec == ATTACK_EXEC_ON_GPU)
15428 {
15429 if (save_css_cnt < 6)
15430 {
15431 css_cnt_r = 1;
15432 }
15433 else if (save_css_cnt == 6)
15434 {
15435 css_cnt_r = 2;
15436 }
15437 else
15438 {
15439 if (opts_type & OPTS_TYPE_PT_UNICODE)
15440 {
15441 if (save_css_cnt == 8 || save_css_cnt == 10)
15442 {
15443 css_cnt_r = 2;
15444 }
15445 else
15446 {
15447 css_cnt_r = 4;
15448 }
15449 }
15450 else
15451 {
15452 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
15453 {
15454 css_cnt_r = 3;
15455 }
15456 else
15457 {
15458 css_cnt_r = 4;
15459 }
15460 }
15461 }
15462 }
15463 else
15464 {
15465 css_cnt_r = 1;
15466
15467 /* unfinished code?
15468 int sum = css_buf[css_cnt_r - 1].cs_len;
15469
15470 for (uint i = 1; i < 4 && i < css_cnt; i++)
15471 {
15472 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
15473
15474 css_cnt_r++;
15475
15476 sum *= css_buf[css_cnt_r - 1].cs_len;
15477 }
15478 */
15479 }
15480
15481 css_cnt_l -= css_cnt_r;
15482
15483 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
15484
15485 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15486 {
15487 hc_device_param_t *device_param = &data.devices_param[device_id];
15488
15489 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
15490 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
15491 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
15492
15493 device_param->kernel_params_mp_l_buf64[3] = 0;
15494 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
15495 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
15496 device_param->kernel_params_mp_l_buf32[6] = 0;
15497 device_param->kernel_params_mp_l_buf32[7] = 0;
15498 device_param->kernel_params_mp_l_buf32[8] = 0;
15499
15500 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
15501 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
15502 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
15503 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
15504
15505 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
15506 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
15507 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
15508
15509 device_param->kernel_params_mp_r_buf64[3] = 0;
15510 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
15511 device_param->kernel_params_mp_r_buf32[5] = 0;
15512 device_param->kernel_params_mp_r_buf32[6] = 0;
15513 device_param->kernel_params_mp_r_buf32[7] = 0;
15514
15515 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]);
15516 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]);
15517 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]);
15518
15519 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]);
15520 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]);
15521 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]);
15522
15523 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);
15524 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);
15525 }
15526 }
15527
15528 uint64_t words_base = data.words_cnt;
15529
15530 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
15531 {
15532 if (data.gpu_rules_cnt)
15533 {
15534 words_base /= data.gpu_rules_cnt;
15535 }
15536 }
15537 else if (data.attack_kern == ATTACK_KERN_COMBI)
15538 {
15539 if (data.combs_cnt)
15540 {
15541 words_base /= data.combs_cnt;
15542 }
15543 }
15544 else if (data.attack_kern == ATTACK_KERN_BF)
15545 {
15546 if (data.bfs_cnt)
15547 {
15548 words_base /= data.bfs_cnt;
15549 }
15550 }
15551
15552 data.words_base = words_base;
15553
15554 if (keyspace == 1)
15555 {
15556 log_info ("%llu", (unsigned long long int) words_base);
15557
15558 return (0);
15559 }
15560
15561 if (data.words_cur > data.words_base)
15562 {
15563 log_error ("ERROR: restore value greater keyspace");
15564
15565 return (-1);
15566 }
15567
15568 if (data.words_cur)
15569 {
15570 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
15571 {
15572 for (uint i = 0; i < data.salts_cnt; i++)
15573 {
15574 data.words_progress_restored[i] = data.words_cur * data.gpu_rules_cnt;
15575 }
15576 }
15577 else if (data.attack_kern == ATTACK_KERN_COMBI)
15578 {
15579 for (uint i = 0; i < data.salts_cnt; i++)
15580 {
15581 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
15582 }
15583 }
15584 else if (data.attack_kern == ATTACK_KERN_BF)
15585 {
15586 for (uint i = 0; i < data.salts_cnt; i++)
15587 {
15588 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
15589 }
15590 }
15591 }
15592
15593 /*
15594 * Inform user about possible slow speeds
15595 */
15596
15597 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
15598 {
15599 if (data.words_base < gpu_blocks_all)
15600 {
15601 if (quiet == 0)
15602 {
15603 log_info ("");
15604 log_info ("ATTENTION!");
15605 log_info (" The wordlist or mask you are using is too small.");
15606 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your GPU(s).");
15607 log_info (" The cracking speed will drop.");
15608 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
15609 log_info ("");
15610 }
15611 }
15612 }
15613
15614 /*
15615 * Update loopback file
15616 */
15617
15618 if (loopback == 1)
15619 {
15620 time_t now;
15621
15622 time (&now);
15623
15624 uint random_num = get_random_num (0, 9999);
15625
15626 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
15627
15628 data.loopback_file = loopback_file;
15629 }
15630
15631 /*
15632 * Update dictionary statistic
15633 */
15634
15635 if (keyspace == 0)
15636 {
15637 dictstat_fp = fopen (dictstat, "wb");
15638
15639 if (dictstat_fp)
15640 {
15641 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
15642
15643 fclose (dictstat_fp);
15644 }
15645 }
15646
15647 data.devices_status = STATUS_RUNNING;
15648
15649 if (initial_restore_done == 0)
15650 {
15651 if (data.restore_disable == 0) cycle_restore ();
15652
15653 initial_restore_done = 1;
15654 }
15655
15656 hc_timer_set (&data.timer_running);
15657
15658 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
15659 {
15660 if ((quiet == 0) && (status == 0) && (benchmark == 0))
15661 {
15662 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
15663 if (quiet == 0) fflush (stdout);
15664 }
15665 }
15666 else if (wordlist_mode == WL_MODE_STDIN)
15667 {
15668 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
15669 if (data.quiet == 0) log_info ("");
15670 }
15671
15672 time_t runtime_start;
15673
15674 time (&runtime_start);
15675
15676 data.runtime_start = runtime_start;
15677
15678 /**
15679 * create cracker threads
15680 */
15681
15682 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (devices_cnt, sizeof (hc_thread_t));
15683
15684 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15685 {
15686 hc_device_param_t *device_param = &devices_param[device_id];
15687
15688 device_param->device_id = device_id;
15689
15690 if (wordlist_mode == WL_MODE_STDIN)
15691 {
15692 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
15693 }
15694 else
15695 {
15696 hc_thread_create (c_threads[device_id], thread_calc, device_param);
15697 }
15698 }
15699
15700 // wait for crack threads to exit
15701
15702 hc_thread_wait (devices_cnt, c_threads);
15703
15704 local_free (c_threads);
15705
15706 data.restore = 0;
15707
15708 // finalize task
15709
15710 logfile_sub_var_uint ("status-after-work", data.devices_status);
15711
15712 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
15713
15714 if (data.devices_status == STATUS_CRACKED) break;
15715 if (data.devices_status == STATUS_ABORTED) break;
15716
15717 if (data.devices_status == STATUS_BYPASS)
15718 {
15719 data.devices_status = STATUS_RUNNING;
15720 }
15721
15722 if (induction_dictionaries_cnt)
15723 {
15724 unlink (induction_dictionaries[0]);
15725 }
15726
15727 free (induction_dictionaries);
15728
15729 if (attack_mode != ATTACK_MODE_BF)
15730 {
15731 induction_dictionaries = scan_directory (induction_directory);
15732
15733 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15734 }
15735
15736 if (benchmark == 0)
15737 {
15738 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
15739 {
15740 if (quiet == 0) clear_prompt ();
15741
15742 if (quiet == 0) log_info ("");
15743
15744 if (status == 1)
15745 {
15746 status_display ();
15747 }
15748 else
15749 {
15750 if (quiet == 0) status_display ();
15751 }
15752
15753 if (quiet == 0) log_info ("");
15754 }
15755 }
15756
15757 if (attack_mode == ATTACK_MODE_BF)
15758 {
15759 dictpos++;
15760
15761 rd->dictpos = dictpos;
15762 }
15763 else
15764 {
15765 if (induction_dictionaries_cnt)
15766 {
15767 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15768 }
15769 else
15770 {
15771 dictpos++;
15772
15773 rd->dictpos = dictpos;
15774 }
15775 }
15776
15777 time_t runtime_stop;
15778
15779 time (&runtime_stop);
15780
15781 data.runtime_stop = runtime_stop;
15782
15783 logfile_sub_uint (runtime_start);
15784 logfile_sub_uint (runtime_stop);
15785
15786 logfile_sub_msg ("STOP");
15787
15788 global_free (subid);
15789 }
15790
15791 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
15792
15793 if (data.devices_status == STATUS_CRACKED) break;
15794 if (data.devices_status == STATUS_ABORTED) break;
15795 if (data.devices_status == STATUS_QUIT) break;
15796
15797 if (data.devices_status == STATUS_BYPASS)
15798 {
15799 data.devices_status = STATUS_RUNNING;
15800 }
15801 }
15802
15803 // 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
15804
15805 if (attack_mode == ATTACK_MODE_STRAIGHT)
15806 {
15807 if (data.wordlist_mode == WL_MODE_FILE)
15808 {
15809 if (data.dictfile == NULL)
15810 {
15811 if (dictfiles != NULL)
15812 {
15813 data.dictfile = dictfiles[0];
15814
15815 hc_timer_set (&data.timer_running);
15816 }
15817 }
15818 }
15819 }
15820 // NOTE: combi is okay because it is already set beforehand
15821 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
15822 {
15823 if (data.dictfile == NULL)
15824 {
15825 if (dictfiles != NULL)
15826 {
15827 hc_timer_set (&data.timer_running);
15828
15829 data.dictfile = dictfiles[0];
15830 }
15831 }
15832 }
15833 else if (attack_mode == ATTACK_MODE_BF)
15834 {
15835 if (data.mask == NULL)
15836 {
15837 hc_timer_set (&data.timer_running);
15838
15839 data.mask = masks[0];
15840 }
15841 }
15842
15843 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
15844 {
15845 data.devices_status = STATUS_EXHAUSTED;
15846 }
15847
15848 // if cracked / aborted remove last induction dictionary
15849
15850 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
15851 {
15852 struct stat induct_stat;
15853
15854 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
15855 {
15856 unlink (induction_dictionaries[file_pos]);
15857 }
15858 }
15859
15860 // wait for non-interactive threads
15861
15862 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
15863 {
15864 hc_thread_wait (1, &ni_threads[thread_idx]);
15865 }
15866
15867 local_free (ni_threads);
15868
15869 // wait for interactive threads
15870
15871 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15872 {
15873 hc_thread_wait (1, &i_thread);
15874 }
15875
15876 // we dont need restore file anymore
15877 if (data.restore_disable == 0)
15878 {
15879 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
15880 {
15881 unlink (eff_restore_file);
15882 unlink (new_restore_file);
15883 }
15884 else
15885 {
15886 cycle_restore ();
15887 }
15888 }
15889
15890 // finally save left hashes
15891
15892 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
15893 {
15894 save_hash ();
15895 }
15896
15897 /**
15898 * Clean up
15899 */
15900
15901 if (benchmark == 1)
15902 {
15903 status_benchmark ();
15904
15905 log_info ("");
15906 }
15907 else
15908 {
15909 if (quiet == 0) clear_prompt ();
15910
15911 if (quiet == 0) log_info ("");
15912
15913 if (status == 1)
15914 {
15915 status_display ();
15916 }
15917 else
15918 {
15919 if (quiet == 0) status_display ();
15920 }
15921
15922 if (quiet == 0) log_info ("");
15923 }
15924
15925 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15926 {
15927 hc_device_param_t *device_param = &data.devices_param[device_id];
15928
15929 local_free (device_param->result);
15930
15931 local_free (device_param->pw_caches);
15932
15933 local_free (device_param->combs_buf);
15934
15935 local_free (device_param->hooks_buf);
15936
15937 local_free (device_param->device_name);
15938
15939 local_free (device_param->device_version);
15940
15941 local_free (device_param->driver_version);
15942
15943 if (device_param->pws_buf) myfree (device_param->pws_buf);
15944 if (device_param->d_pws_buf) hc_clReleaseMemObject (device_param->d_pws_buf);
15945 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (device_param->d_pws_amp_buf);
15946 if (device_param->d_rules) hc_clReleaseMemObject (device_param->d_rules);
15947 if (device_param->d_rules_c) hc_clReleaseMemObject (device_param->d_rules_c);
15948 if (device_param->d_combs) hc_clReleaseMemObject (device_param->d_combs);
15949 if (device_param->d_combs_c) hc_clReleaseMemObject (device_param->d_combs_c);
15950 if (device_param->d_bfs) hc_clReleaseMemObject (device_param->d_bfs);
15951 if (device_param->d_bfs_c) hc_clReleaseMemObject (device_param->d_bfs_c);
15952 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (device_param->d_bitmap_s1_a);
15953 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (device_param->d_bitmap_s1_b);
15954 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (device_param->d_bitmap_s1_c);
15955 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (device_param->d_bitmap_s1_d);
15956 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (device_param->d_bitmap_s2_a);
15957 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (device_param->d_bitmap_s2_b);
15958 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (device_param->d_bitmap_s2_c);
15959 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (device_param->d_bitmap_s2_d);
15960 if (device_param->d_plain_bufs) hc_clReleaseMemObject (device_param->d_plain_bufs);
15961 if (device_param->d_digests_buf) hc_clReleaseMemObject (device_param->d_digests_buf);
15962 if (device_param->d_digests_shown) hc_clReleaseMemObject (device_param->d_digests_shown);
15963 if (device_param->d_salt_bufs) hc_clReleaseMemObject (device_param->d_salt_bufs);
15964 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (device_param->d_esalt_bufs);
15965 if (device_param->d_tmps) hc_clReleaseMemObject (device_param->d_tmps);
15966 if (device_param->d_hooks) hc_clReleaseMemObject (device_param->d_hooks);
15967 if (device_param->d_result) hc_clReleaseMemObject (device_param->d_result);
15968 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (device_param->d_scryptV_buf);
15969 if (device_param->d_root_css_buf) hc_clReleaseMemObject (device_param->d_root_css_buf);
15970 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (device_param->d_markov_css_buf);
15971
15972 if (device_param->kernel1) hc_clReleaseKernel (device_param->kernel1);
15973 if (device_param->kernel12) hc_clReleaseKernel (device_param->kernel12);
15974 if (device_param->kernel2) hc_clReleaseKernel (device_param->kernel2);
15975 if (device_param->kernel23) hc_clReleaseKernel (device_param->kernel23);
15976 if (device_param->kernel3) hc_clReleaseKernel (device_param->kernel3);
15977 if (device_param->kernel_mp) hc_clReleaseKernel (device_param->kernel_mp);
15978 if (device_param->kernel_mp_l) hc_clReleaseKernel (device_param->kernel_mp_l);
15979 if (device_param->kernel_mp_r) hc_clReleaseKernel (device_param->kernel_mp_r);
15980
15981 if (device_param->program) hc_clReleaseProgram (device_param->program);
15982 if (device_param->program_mp) hc_clReleaseProgram (device_param->program_mp);
15983 if (device_param->command_queue) hc_clReleaseCommandQueue (device_param->command_queue);
15984 if (device_param->context) hc_clReleaseContext (device_param->context);
15985 }
15986
15987 // reset default fan speed
15988
15989 if (gpu_temp_disable == 0)
15990 {
15991 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
15992 {
15993 hc_thread_mutex_lock (mux_adl);
15994
15995 for (uint i = 0; i < data.devices_cnt; i++)
15996 {
15997 if (data.hm_device[i].fan_supported == 1)
15998 {
15999 int fanspeed = temp_retain_fanspeed_value[i];
16000
16001 if (fanspeed == -1) continue;
16002
16003 int rc = hm_set_fanspeed_with_device_id_amd (i, fanspeed);
16004
16005 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", i);
16006 }
16007 }
16008
16009 hc_thread_mutex_unlock (mux_adl);
16010 }
16011 }
16012
16013 // reset power tuning
16014
16015 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16016 {
16017 hc_thread_mutex_lock (mux_adl);
16018
16019 for (uint i = 0; i < data.devices_cnt; i++)
16020 {
16021 if (data.hm_device[i].od_version == 6)
16022 {
16023 // check powertune capabilities first, if not available then skip device
16024
16025 int powertune_supported = 0;
16026
16027 if ((hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll, data.hm_device[i].adapter_index.amd, &powertune_supported)) != ADL_OK)
16028 {
16029 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16030
16031 return (-1);
16032 }
16033
16034 if (powertune_supported != 0)
16035 {
16036 // powercontrol settings
16037
16038 if ((hc_ADL_Overdrive_PowerControl_Set (data.hm_dll, data.hm_device[i].adapter_index.amd, od_power_control_status[i])) != ADL_OK)
16039 {
16040 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16041
16042 return (-1);
16043 }
16044
16045 // clocks
16046
16047 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16048
16049 performance_state->iNumberOfPerformanceLevels = 2;
16050
16051 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[i].state.aLevels[0].iEngineClock;
16052 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[i].state.aLevels[1].iEngineClock;
16053 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[i].state.aLevels[0].iMemoryClock;
16054 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[i].state.aLevels[1].iMemoryClock;
16055
16056 if ((hc_ADL_Overdrive_State_Set (data.hm_dll, data.hm_device[i].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
16057 {
16058 log_info ("ERROR: Failed to restore ADL performance state");
16059
16060 return (-1);
16061 }
16062
16063 local_free (performance_state);
16064 }
16065 }
16066 }
16067
16068 hc_thread_mutex_unlock (mux_adl);
16069 }
16070
16071 if (gpu_temp_disable == 0)
16072 {
16073 if (vendor_id == VENDOR_ID_NV)
16074 {
16075 #ifdef LINUX
16076 hc_NVML_nvmlShutdown (data.hm_dll);
16077 #endif
16078
16079 #ifdef WIN
16080 NvAPI_Unload ();
16081 #endif
16082 }
16083
16084 if (vendor_id == VENDOR_ID_AMD)
16085 {
16086 hc_ADL_Main_Control_Destroy (data.hm_dll);
16087
16088 hm_close (data.hm_dll);
16089 }
16090
16091 #ifdef LINUX
16092 if (vendor_id == VENDOR_ID_NV)
16093 {
16094 hm_close (data.hm_dll);
16095 }
16096 #endif
16097 }
16098
16099 // free memory
16100
16101 local_free (masks);
16102
16103 local_free (dictstat_base);
16104
16105 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16106 {
16107 pot_t *pot_ptr = &pot[pot_pos];
16108
16109 hash_t *hash = &pot_ptr->hash;
16110
16111 local_free (hash->digest);
16112
16113 if (isSalted)
16114 {
16115 local_free (hash->salt);
16116 }
16117 }
16118
16119 local_free (pot);
16120
16121 local_free (all_gpu_rules_cnt);
16122 local_free (all_gpu_rules_buf);
16123
16124 local_free (wl_data->buf);
16125 local_free (wl_data);
16126
16127 local_free (bitmap_s1_a);
16128 local_free (bitmap_s1_b);
16129 local_free (bitmap_s1_c);
16130 local_free (bitmap_s1_d);
16131 local_free (bitmap_s2_a);
16132 local_free (bitmap_s2_b);
16133 local_free (bitmap_s2_c);
16134 local_free (bitmap_s2_d);
16135
16136 local_free (temp_retain_fanspeed_value);
16137 local_free (od_clock_mem_status);
16138 local_free (od_power_control_status);
16139
16140 global_free (devices_param);
16141
16142 global_free (gpu_rules_buf);
16143
16144 global_free (root_css_buf);
16145 global_free (markov_css_buf);
16146
16147 global_free (digests_buf);
16148 global_free (digests_shown);
16149 global_free (digests_shown_tmp);
16150
16151 global_free (salts_buf);
16152 global_free (salts_shown);
16153
16154 global_free (esalts_buf);
16155
16156 global_free (words_progress_done);
16157 global_free (words_progress_rejected);
16158 global_free (words_progress_restored);
16159
16160 if (pot_fp) fclose (pot_fp);
16161
16162 if (data.devices_status == STATUS_QUIT) break;
16163 }
16164
16165 // destroy others mutex
16166
16167 hc_thread_mutex_delete (mux_dispatcher);
16168 hc_thread_mutex_delete (mux_counter);
16169 hc_thread_mutex_delete (mux_display);
16170 hc_thread_mutex_delete (mux_adl);
16171
16172 // free memory
16173
16174 local_free (eff_restore_file);
16175 local_free (new_restore_file);
16176
16177 local_free (rd);
16178
16179 // loopback
16180
16181 local_free (loopback_file);
16182
16183 if (loopback == 1) unlink (loopback_file);
16184
16185 // induction directory
16186
16187 if (induction_dir == NULL)
16188 {
16189 if (attack_mode != ATTACK_MODE_BF)
16190 {
16191 if (rmdir (induction_directory) == -1)
16192 {
16193 if (errno == ENOENT)
16194 {
16195 // good, we can ignore
16196 }
16197 else if (errno == ENOTEMPTY)
16198 {
16199 // good, we can ignore
16200 }
16201 else
16202 {
16203 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
16204
16205 return (-1);
16206 }
16207 }
16208
16209 local_free (induction_directory);
16210 }
16211 }
16212
16213 // outfile-check directory
16214
16215 if (outfile_check_dir == NULL)
16216 {
16217 if (rmdir (outfile_check_directory) == -1)
16218 {
16219 if (errno == ENOENT)
16220 {
16221 // good, we can ignore
16222 }
16223 else if (errno == ENOTEMPTY)
16224 {
16225 // good, we can ignore
16226 }
16227 else
16228 {
16229 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
16230
16231 return (-1);
16232 }
16233 }
16234
16235 local_free (outfile_check_directory);
16236 }
16237
16238 time_t proc_stop;
16239
16240 time (&proc_stop);
16241
16242 logfile_top_uint (proc_start);
16243 logfile_top_uint (proc_stop);
16244
16245 logfile_top_msg ("STOP");
16246
16247 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
16248 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
16249
16250 if (data.devices_status == STATUS_ABORTED) return 2;
16251 if (data.devices_status == STATUS_QUIT) return 2;
16252 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
16253 if (data.devices_status == STATUS_EXHAUSTED) return 1;
16254 if (data.devices_status == STATUS_CRACKED) return 0;
16255
16256 return -1;
16257 }
Hashcat additions to support pwdhash