projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Update 9300 default tmto for NV
[hashcat.git] / src / oclHashcat.c
1 /**
2 * Author......: Jens Steube <jens.steube@gmail.com>
3 * License.....: MIT
4 */
5
6 #include <common.h>
7 #include <shared.h>
8 #include <rp_gpu_on_cpu.h>
9 #include <getopt.h>
10
11 const char *PROGNAME = "oclHashcat";
12 const char *VERSION_TXT = "2.01";
13 const uint VERSION_BIN = 201;
14 const uint RESTORE_MIN = 201;
15
16 #define INCR_RULES 10000
17 #define INCR_SALTS 100000
18 #define INCR_MASKS 1000
19 #define INCR_POT 1000
20
21 #define USAGE 0
22 #define VERSION 0
23 #define QUIET 0
24 #define MARKOV_THRESHOLD 0
25 #define MARKOV_DISABLE 0
26 #define MARKOV_CLASSIC 0
27 #define BENCHMARK 0
28 #define BENCHMARK_MODE 1
29 #define RESTORE 0
30 #define RESTORE_TIMER 60
31 #define RESTORE_DISABLE 0
32 #define STATUS 0
33 #define STATUS_TIMER 10
34 #define STATUS_AUTOMAT 0
35 #define LOOPBACK 0
36 #define WEAK_HASH_THRESHOLD 100
37 #define SHOW 0
38 #define LEFT 0
39 #define USERNAME 0
40 #define REMOVE 0
41 #define REMOVE_TIMER 60
42 #define SKIP 0
43 #define LIMIT 0
44 #define KEYSPACE 0
45 #define POTFILE_DISABLE 0
46 #define DEBUG_MODE 0
47 #define RP_GEN 0
48 #define RP_GEN_FUNC_MIN 1
49 #define RP_GEN_FUNC_MAX 4
50 #define RP_GEN_SEED 0
51 #define RULE_BUF_L ":"
52 #define RULE_BUF_R ":"
53 #define FORCE 0
54 #define RUNTIME 0
55 #define HEX_CHARSET 0
56 #define HEX_SALT 0
57 #define HEX_WORDLIST 0
58 #define OUTFILE_FORMAT 3
59 #define OUTFILE_AUTOHEX 1
60 #define OUTFILE_CHECK_TIMER 5
61 #define ATTACK_MODE 0
62 #define HASH_MODE 0
63 #define SEGMENT_SIZE 32
64 #define INCREMENT 0
65 #define INCREMENT_MIN 1
66 #define INCREMENT_MAX PW_MAX
67 #define SEPARATOR ':'
68 #define BITMAP_MIN 16
69 #define BITMAP_MAX 24
70 #define GPU_TEMP_DISABLE 0
71 #define GPU_TEMP_ABORT 90
72 #define GPU_TEMP_RETAIN 80
73 #define WORKLOAD_PROFILE 2
74 #define GPU_ACCEL 0
75 #define GPU_LOOPS 0
76 #define GPU_RULES 1024
77 #define GPU_COMBS 1024
78 #define GPU_BFS 1024
79 #define GPU_THREADS 64
80 #define POWERTUNE_ENABLE 0
81 #define LOGFILE_DISABLE 0
82 #define SCRYPT_TMTO 0
83
84 #define WL_MODE_STDIN 1
85 #define WL_MODE_FILE 2
86 #define WL_MODE_MASK 3
87
88 #define HL_MODE_FILE 4
89 #define HL_MODE_ARG 5
90
91 #define HLFMT_HASHCAT 0
92 #define HLFMT_PWDUMP 1
93 #define HLFMT_PASSWD 2
94 #define HLFMT_SHADOW 3
95 #define HLFMT_DCC 4
96 #define HLFMT_DCC2 5
97 #define HLFMT_NETNTLM1 7
98 #define HLFMT_NETNTLM2 8
99 #define HLFMT_NSLDAP 9
100 #define HLFMT_NSLDAPS 10
101 #define HLFMTS_CNT 11
102
103 #define ATTACK_MODE_STRAIGHT 0
104 #define ATTACK_MODE_COMBI 1
105 #define ATTACK_MODE_TOGGLE 2
106 #define ATTACK_MODE_BF 3
107 #define ATTACK_MODE_PERM 4
108 #define ATTACK_MODE_TABLE 5
109 #define ATTACK_MODE_HYBRID1 6
110 #define ATTACK_MODE_HYBRID2 7
111 #define ATTACK_MODE_NONE 100
112
113 #define ATTACK_KERN_STRAIGHT 0
114 #define ATTACK_KERN_COMBI 1
115 #define ATTACK_KERN_BF 3
116 #define ATTACK_KERN_NONE 100
117
118 #define ATTACK_EXEC_ON_CPU 10
119 #define ATTACK_EXEC_ON_GPU 11
120
121 #define COMBINATOR_MODE_BASE_LEFT 10001
122 #define COMBINATOR_MODE_BASE_RIGHT 10002
123
124 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
125 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
126
127 #define MAX_CUT_TRIES 4
128
129 #define MAX_DICTSTAT 10000
130
131 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 128
132
133 #define global_free(attr) \
134 { \
135 myfree ((void *) data.attr); \
136 \
137 data.attr = NULL; \
138 }
139
140 #define local_free(attr) \
141 { \
142 myfree ((void *) attr); \
143 \
144 attr = NULL; \
145 }
146
147 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
148 {
149 900,
150 0,
151 5100,
152 100,
153 1400,
154 10800,
155 1700,
156 5000,
157 10100,
158 6000,
159 6100,
160 6900,
161 11700,
162 11800,
163 400,
164 8900,
165 11900,
166 12000,
167 10900,
168 12100,
169 23,
170 2500,
171 5300,
172 5400,
173 5500,
174 5600,
175 7300,
176 7500,
177 8300,
178 11100,
179 11200,
180 11400,
181 121,
182 2611,
183 2711,
184 2811,
185 8400,
186 11,
187 2612,
188 7900,
189 21,
190 11000,
191 124,
192 10000,
193 3711,
194 7600,
195 12,
196 131,
197 132,
198 1731,
199 200,
200 300,
201 3100,
202 112,
203 12300,
204 8000,
205 141,
206 1441,
207 1600,
208 12600,
209 1421,
210 101,
211 111,
212 1711,
213 3000,
214 1000,
215 1100,
216 2100,
217 12800,
218 1500,
219 12400,
220 500,
221 3200,
222 7400,
223 1800,
224 122,
225 1722,
226 7100,
227 6300,
228 6700,
229 6400,
230 6500,
231 2400,
232 2410,
233 5700,
234 9200,
235 9300,
236 22,
237 501,
238 5800,
239 8100,
240 8500,
241 7200,
242 9900,
243 7700,
244 7800,
245 10300,
246 8600,
247 8700,
248 9100,
249 133,
250 11600,
251 12500,
252 6211,
253 6221,
254 6231,
255 6241,
256 8800,
257 12200,
258 9700,
259 9710,
260 9800,
261 9810,
262 9400,
263 9500,
264 9600,
265 10400,
266 10410,
267 10500,
268 10600,
269 10700,
270 9000,
271 5200,
272 6800,
273 6600,
274 8200,
275 11300,
276 12700
277 };
278
279 /**
280 * types
281 */
282
283 static void (*get_next_word_func) (char *, uint32_t, uint32_t *, uint32_t *);
284
285 /**
286 * globals
287 */
288
289 static unsigned int full01 = 0x01010101;
290 static unsigned int full80 = 0x80808080;
291
292 int SUPPRESS_OUTPUT = 0;
293
294 hc_thread_mutex_t mux_adl;
295 hc_thread_mutex_t mux_counter;
296 hc_thread_mutex_t mux_dispatcher;
297 hc_thread_mutex_t mux_display;
298
299 hc_global_data_t data;
300
301 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
302
303 const char *USAGE_MINI[] =
304 {
305 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
306 "",
307 "Try --help for more help.",
308 NULL
309 };
310
311 const char *USAGE_BIG[] =
312 {
313 "%s, advanced password recovery",
314 "",
315 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
316 "",
317 "=======",
318 "Options",
319 "=======",
320 "",
321 "* General:",
322 "",
323 " -m, --hash-type=NUM Hash-type, see references below",
324 " -a, --attack-mode=NUM Attack-mode, see references below",
325 " -V, --version Print version",
326 " -h, --help Print help",
327 " --quiet Suppress output",
328 "",
329 "* Benchmark:",
330 "",
331 " -b, --benchmark Run benchmark",
332 " --benchmark-mode=NUM Benchmark-mode, see references below",
333 "",
334 "* Misc:",
335 "",
336 " --hex-charset Assume charset is given in hex",
337 " --hex-salt Assume salt is given in hex",
338 " --hex-wordlist Assume words in wordlist is given in hex",
339 " --force Ignore warnings",
340 " --status Enable automatic update of the status-screen",
341 " --status-timer=NUM Seconds between status-screen update",
342 " --status-automat Display the status view in a machine readable format",
343 " --loopback Add new plains to induct directory",
344 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
345 "",
346 "* Markov:",
347 "",
348 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
349 " --markov-disable Disables markov-chains, emulates classic brute-force",
350 " --markov-classic Enables classic markov-chains, no per-position enhancement",
351 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
352 "",
353 "* Session:",
354 "",
355 " --runtime=NUM Abort session after NUM seconds of runtime",
356 " --session=STR Define specific session name",
357 " --restore Restore session from --session",
358 " --restore-disable Do not write restore file",
359 "",
360 "* Files:",
361 "",
362 " -o, --outfile=FILE Define outfile for recovered hash",
363 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
364 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
365 " --outfile-check-timer=NUM Seconds between outfile checks",
366 " -p, --separator=CHAR Separator char for hashlists and outfile",
367 " --show Show cracked passwords only",
368 " --left Show un-cracked passwords only",
369 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
370 " --remove Enable remove of hash once it is cracked",
371 " --remove-timer=NUM Update input hash file each NUM seconds",
372 " --potfile-disable Do not write potfile",
373 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
374 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
375 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
376 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
377 " --logfile-disable Disable the logfile",
378 " --truecrypt-keyfiles=FILE Keyfiles used, seperate with comma",
379 "",
380 "* Resources:",
381 "",
382 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
383 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
384 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
385 " --cpu-affinity=STR Locks to CPU devices, seperate with comma",
386 " -d, --gpu-devices=STR OpenCL devices to use, separate with comma",
387 " --gpu-platform=STR OpenCL platform to use, in case multiple OpenCL platforms are present",
388 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
389 " -n, --gpu-accel=NUM Workload tuning: 1, 8, 40, 80, 160",
390 " -u, --gpu-loops=NUM Workload fine-tuning: 8 - 1024",
391 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
392 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
393 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
394 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
395 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
396 "",
397 "* Distributed:",
398 "",
399 " -s, --skip=NUM Skip number of words",
400 " -l, --limit=NUM Limit number of words",
401 " --keyspace Show keyspace base:mod values and quit",
402 "",
403 "* Rules:",
404 "",
405 " -j, --rule-left=RULE Single rule applied to each word from left dict",
406 " -k, --rule-right=RULE Single rule applied to each word from right dict",
407 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
408 " -g, --generate-rules=NUM Generate NUM random rules",
409 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
410 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
411 " --generate-rules-seed=NUM Force RNG seed to NUM",
412 "",
413 "* Custom charsets:",
414 "",
415 " -1, --custom-charset1=CS User-defined charsets",
416 " -2, --custom-charset2=CS Example:",
417 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
418 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
419 "",
420 "* Increment:",
421 "",
422 " -i, --increment Enable increment mode",
423 " --increment-min=NUM Start incrementing at NUM",
424 " --increment-max=NUM Stop incrementing at NUM",
425 "",
426 "==========",
427 "References",
428 "==========",
429 "",
430 "* Workload Profile:",
431 "",
432 " 1 = Reduced performance profile (low latency desktop)",
433 " 2 = Default performance profile",
434 " 3 = Tuned performance profile (high latency desktop)",
435 "",
436 "* Benchmark Settings:",
437 "",
438 " 0 = Manual Tuning",
439 " 1 = Performance Tuning, default",
440 "",
441 "* Outfile Formats:",
442 "",
443 " 1 = hash[:salt]",
444 " 2 = plain",
445 " 3 = hash[:salt]:plain",
446 " 4 = hex_plain",
447 " 5 = hash[:salt]:hex_plain",
448 " 6 = plain:hex_plain",
449 " 7 = hash[:salt]:plain:hex_plain",
450 " 8 = crackpos",
451 " 9 = hash[:salt]:crackpos",
452 " 10 = plain:crackpos",
453 " 11 = hash[:salt]:plain:crackpos",
454 " 12 = hex_plain:crackpos",
455 " 13 = hash[:salt]:hex_plain:crackpos",
456 " 14 = plain:hex_plain:crackpos",
457 " 15 = hash[:salt]:plain:hex_plain:crackpos",
458 "",
459 "* Debug mode output formats (for hybrid mode only, by using rules):",
460 "",
461 " 1 = save finding rule",
462 " 2 = save original word",
463 " 3 = save original word and finding rule",
464 " 4 = save original word, finding rule and modified plain",
465 "",
466 "* Built-in charsets:",
467 "",
468 " ?l = abcdefghijklmnopqrstuvwxyz",
469 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
470 " ?d = 0123456789",
471 " ?s = !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~",
472 " ?a = ?l?u?d?s",
473 " ?b = 0x00 - 0xff",
474 "",
475 "* Attack modes:",
476 "",
477 " 0 = Straight",
478 " 1 = Combination",
479 " 3 = Brute-force",
480 " 6 = Hybrid dict + mask",
481 " 7 = Hybrid mask + dict",
482 "",
483 "* Hash types:",
484 "",
485 "[[ Roll-your-own: Raw Hashes ]]",
486 "",
487 " 900 = MD4",
488 " 0 = MD5",
489 " 5100 = Half MD5",
490 " 100 = SHA1",
491 " 10800 = SHA-384",
492 " 1400 = SHA-256",
493 " 1700 = SHA-512",
494 " 5000 = SHA-3(Keccak)",
495 " 10100 = SipHash",
496 " 6000 = RipeMD160",
497 " 6100 = Whirlpool",
498 " 6900 = GOST R 34.11-94",
499 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
500 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
501 "",
502 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
503 "",
504 " 10 = md5($pass.$salt)",
505 " 20 = md5($salt.$pass)",
506 " 30 = md5(unicode($pass).$salt)",
507 " 40 = md5($salt.unicode($pass))",
508 " 3800 = md5($salt.$pass.$salt)",
509 " 3710 = md5($salt.md5($pass))",
510 " 2600 = md5(md5($pass)",
511 " 4300 = md5(strtoupper(md5($pass)))",
512 " 4400 = md5(sha1($pass))",
513 " 110 = sha1($pass.$salt)",
514 " 120 = sha1($salt.$pass)",
515 " 130 = sha1(unicode($pass).$salt)",
516 " 140 = sha1($salt.unicode($pass))",
517 " 4500 = sha1(sha1($pass)",
518 " 4700 = sha1(md5($pass))",
519 " 4900 = sha1($salt.$pass.$salt)",
520 " 1410 = sha256($pass.$salt)",
521 " 1420 = sha256($salt.$pass)",
522 " 1430 = sha256(unicode($pass).$salt)",
523 " 1440 = sha256($salt.unicode($pass))",
524 " 1710 = sha512($pass.$salt)",
525 " 1720 = sha512($salt.$pass)",
526 " 1730 = sha512(unicode($pass).$salt)",
527 " 1740 = sha512($salt.unicode($pass))",
528 "",
529 "[[ Roll-your-own: Authenticated Hashes ]]",
530 "",
531 " 50 = HMAC-MD5 (key = $pass)",
532 " 60 = HMAC-MD5 (key = $salt)",
533 " 150 = HMAC-SHA1 (key = $pass)",
534 " 160 = HMAC-SHA1 (key = $salt)",
535 " 1450 = HMAC-SHA256 (key = $pass)",
536 " 1460 = HMAC-SHA256 (key = $salt)",
537 " 1750 = HMAC-SHA512 (key = $pass)",
538 " 1760 = HMAC-SHA512 (key = $salt)",
539 "",
540 "[[ Generic KDF ]]",
541 "",
542 " 400 = phpass",
543 " 8900 = scrypt",
544 " 11900 = PBKDF2-HMAC-MD5",
545 " 12000 = PBKDF2-HMAC-SHA1",
546 " 10900 = PBKDF2-HMAC-SHA256",
547 " 12100 = PBKDF2-HMAC-SHA512",
548 "",
549 "[[ Network protocols, Challenge-Response ]]",
550 "",
551 " 23 = Skype",
552 " 2500 = WPA/WPA2",
553 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
554 " 5300 = IKE-PSK MD5",
555 " 5400 = IKE-PSK SHA1",
556 " 5500 = NetNTLMv1",
557 " 5500 = NetNTLMv1 + ESS",
558 " 5600 = NetNTLMv2",
559 " 7300 = IPMI2 RAKP HMAC-SHA1",
560 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
561 " 8300 = DNSSEC (NSEC3)",
562 " 10200 = Cram MD5",
563 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
564 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
565 " 11400 = SIP digest authentication (MD5)",
566 "",
567 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
568 "",
569 " 121 = SMF (Simple Machines Forum)",
570 " 400 = phpBB3",
571 " 2611 = vBulletin < v3.8.5",
572 " 2711 = vBulletin > v3.8.5",
573 " 2811 = MyBB",
574 " 2811 = IPB (Invison Power Board)",
575 " 8400 = WBB3 (Woltlab Burning Board)",
576 " 11 = Joomla < 2.5.18",
577 " 400 = Joomla > 2.5.18",
578 " 400 = Wordpress",
579 " 2612 = PHPS",
580 " 7900 = Drupal7",
581 " 21 = osCommerce",
582 " 21 = xt:Commerce",
583 " 11000 = PrestaShop",
584 " 124 = Django (SHA-1)",
585 " 10000 = Django (PBKDF2-SHA256)",
586 " 3711 = Mediawiki B type",
587 " 7600 = Redmine",
588 "",
589 "[[ Database Server ]]",
590 "",
591 " 12 = PostgreSQL",
592 " 131 = MSSQL(2000)",
593 " 132 = MSSQL(2005)",
594 " 1731 = MSSQL(2012)",
595 " 1731 = MSSQL(2014)",
596 " 200 = MySQL323",
597 " 300 = MySQL4.1/MySQL5",
598 " 3100 = Oracle H: Type (Oracle 7+)",
599 " 112 = Oracle S: Type (Oracle 11+)",
600 " 12300 = Oracle T: Type (Oracle 12+)",
601 " 8000 = Sybase ASE",
602 "",
603 "[[ HTTP, SMTP, LDAP Server]]",
604 "",
605 " 141 = EPiServer 6.x < v4",
606 " 1441 = EPiServer 6.x > v4",
607 " 1600 = Apache $apr1$",
608 " 12600 = ColdFusion 10+",
609 " 1421 = hMailServer",
610 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
611 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
612 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
613 "",
614 "[[ Checksums ]]",
615 "",
616 " 11500 = CRC32",
617 "",
618 "[[ Operating-Systems ]]",
619 "",
620 " 3000 = LM",
621 " 1000 = NTLM",
622 " 1100 = Domain Cached Credentials (DCC), MS Cache",
623 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
624 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
625 " 1500 = descrypt, DES(Unix), Traditional DES",
626 " 12400 = BSDiCrypt, Extended DES",
627 " 500 = md5crypt $1$, MD5(Unix)",
628 " 3200 = bcrypt $2*$, Blowfish(Unix)",
629 " 7400 = sha256crypt $5$, SHA256(Unix)",
630 " 1800 = sha512crypt $6$, SHA512(Unix)",
631 " 122 = OSX v10.4",
632 " 122 = OSX v10.5",
633 " 122 = OSX v10.6",
634 " 1722 = OSX v10.7",
635 " 7100 = OSX v10.8",
636 " 7100 = OSX v10.9",
637 " 7100 = OSX v10.10",
638 " 6300 = AIX {smd5}",
639 " 6700 = AIX {ssha1}",
640 " 6400 = AIX {ssha256}",
641 " 6500 = AIX {ssha512}",
642 " 2400 = Cisco-PIX",
643 " 2410 = Cisco-ASA",
644 " 500 = Cisco-IOS $1$",
645 " 5700 = Cisco-IOS $4$",
646 " 9200 = Cisco-IOS $8$",
647 " 9300 = Cisco-IOS $9$",
648 " 22 = Juniper Netscreen/SSG (ScreenOS)",
649 " 501 = Juniper IVE",
650 " 5800 = Android PIN",
651 " 8100 = Citrix Netscaler",
652 " 8500 = RACF",
653 " 7200 = GRUB 2",
654 " 9900 = Radmin2",
655 "",
656 "[[ Enterprise Application Software (EAS) ]]",
657 "",
658 " 7700 = SAP CODVN B (BCODE)",
659 " 7800 = SAP CODVN F/G (PASSCODE)",
660 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
661 " 8600 = Lotus Notes/Domino 5",
662 " 8700 = Lotus Notes/Domino 6",
663 " 9100 = Lotus Notes/Domino 8",
664 " 133 = PeopleSoft",
665 "",
666 "[[ Archives ]]",
667 "",
668 " 11600 = 7-Zip",
669 " 12500 = RAR3-hp",
670 "",
671 "[[ Full-Disk encryptions (FDE) ]]",
672 "",
673 " 62XY = TrueCrypt 5.0+",
674 " X = 1 = PBKDF2-HMAC-RipeMD160",
675 " X = 2 = PBKDF2-HMAC-SHA512",
676 " X = 3 = PBKDF2-HMAC-Whirlpool",
677 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
678 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
679 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
680 " Y = 3 = XTS 1536 bit (Ciphers: All)",
681 " 8800 = Android FDE < v4.3",
682 " 12200 = eCryptfs",
683 "",
684 "[[ Documents ]]",
685 "",
686 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
687 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
688 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
689 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
690 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
691 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
692 " 9400 = MS Office 2007",
693 " 9500 = MS Office 2010",
694 " 9600 = MS Office 2013",
695 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
696 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
697 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
698 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
699 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
700 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
701 "",
702 "[[ Password Managers ]]",
703 "",
704 " 9000 = Password Safe v2",
705 " 5200 = Password Safe v3",
706 " 6800 = Lastpass",
707 " 6600 = 1Password, agilekeychain",
708 " 8200 = 1Password, cloudkeychain",
709 " 11300 = Bitcoin/Litecoin wallet.dat",
710 " 12700 = Blockchain, My Wallet",
711 "",
712 NULL
713 };
714
715 /**
716 * oclHashcat specific functions
717 */
718
719 void status_display_automat ()
720 {
721 FILE *out = stdout;
722
723 fprintf (out, "STATUS\t%u\t", data.devices_status);
724
725 /**
726 * speed new
727 */
728
729 fprintf (out, "SPEED\t");
730
731 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
732 {
733 hc_device_param_t *device_param = &data.devices_param[device_id];
734
735 uint64_t speed_cnt = 0;
736 float speed_ms = 0;
737
738 for (int i = 0; i < SPEED_CACHE; i++)
739 {
740 float rec_ms;
741
742 hc_timer_get (device_param->speed_rec[i], rec_ms);
743
744 if (rec_ms > SPEED_MAXAGE) continue;
745
746 speed_cnt += device_param->speed_cnt[i];
747 speed_ms += device_param->speed_ms[i];
748 }
749
750 speed_cnt /= SPEED_CACHE;
751 speed_ms /= SPEED_CACHE;
752
753 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
754 }
755
756 /**
757 * words_cur
758 */
759
760 uint64_t words_cur = get_lowest_words_done ();
761
762 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
763
764 /**
765 * counter
766 */
767
768 uint salts_left = data.salts_cnt - data.salts_done;
769
770 if (salts_left == 0) salts_left = 1;
771
772 uint64_t progress_total = data.words_cnt * salts_left;
773
774 uint64_t all_done = 0;
775 uint64_t all_rejected = 0;
776 uint64_t all_restored = 0;
777
778 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
779 {
780 if (salts_left > 1)
781 {
782 // otherwise the final cracked status shows 0/XXX progress
783
784 if (data.salts_shown[salt_pos] == 1) continue;
785 }
786
787 all_done += data.words_progress_done[salt_pos];
788 all_rejected += data.words_progress_rejected[salt_pos];
789 all_restored += data.words_progress_restored[salt_pos];
790 }
791
792 uint64_t progress_cur = all_restored + all_done + all_rejected;
793 uint64_t progress_end = progress_total;
794
795 uint64_t progress_skip = 0;
796
797 if (data.skip)
798 {
799 progress_skip = MIN (data.skip, data.words_base) * salts_left;
800
801 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.gpu_rules_cnt;
802 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
803 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
804 }
805
806 if (data.limit)
807 {
808 progress_end = MIN (data.limit, data.words_base) * salts_left;
809
810 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.gpu_rules_cnt;
811 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
812 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
813 }
814
815 uint64_t progress_cur_relative_skip = progress_cur - progress_skip;
816 uint64_t progress_end_relative_skip = progress_end - progress_skip;
817
818 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
819
820 /**
821 * cracks
822 */
823
824 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
825 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
826
827 /**
828 * temperature
829 */
830
831 if (data.gpu_temp_disable == 0)
832 {
833 fprintf (out, "TEMP\t");
834
835 hc_thread_mutex_lock (mux_adl);
836
837 for (uint i = 0; i < data.devices_cnt; i++)
838 {
839 int temp = hm_get_temperature_with_device_id (i);
840
841 fprintf (out, "%d\t", temp);
842 }
843
844 hc_thread_mutex_unlock (mux_adl);
845 }
846
847 #ifdef _WIN
848 fputc ('\r', out);
849 fputc ('\n', out);
850 #endif
851
852 #ifdef _POSIX
853 fputc ('\n', out);
854 #endif
855
856 fflush (out);
857 }
858
859 void status_display ()
860 {
861 if (data.devices_status == STATUS_INIT) return;
862 if (data.devices_status == STATUS_STARTING) return;
863 if (data.devices_status == STATUS_BYPASS) return;
864
865 if (data.status_automat == 1)
866 {
867 status_display_automat ();
868
869 return;
870 }
871
872 char tmp_buf[1000];
873
874 uint tmp_len = 0;
875
876 log_info ("Session.Name...: %s", data.session);
877
878 char *status_type = strstatus (data.devices_status);
879
880 uint hash_mode = data.hash_mode;
881
882 char *hash_type = strhashtype (hash_mode); // not a bug
883
884 log_info ("Status.........: %s", status_type);
885
886 /**
887 * show rules
888 */
889
890 if (data.rp_files_cnt)
891 {
892 uint i;
893
894 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
895 {
896 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
897 }
898
899 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
900
901 log_info ("Rules.Type.....: %s", tmp_buf);
902
903 tmp_len = 0;
904 }
905
906 if (data.rp_gen)
907 {
908 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
909
910 if (data.rp_gen_seed)
911 {
912 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
913 }
914 }
915
916 /**
917 * show input
918 */
919
920 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
921 {
922 if (data.wordlist_mode == WL_MODE_FILE)
923 {
924 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
925 }
926 else if (data.wordlist_mode == WL_MODE_STDIN)
927 {
928 log_info ("Input.Mode.....: Pipe");
929 }
930 }
931 else if (data.attack_mode == ATTACK_MODE_COMBI)
932 {
933 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
934 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
935 }
936 else if (data.attack_mode == ATTACK_MODE_BF)
937 {
938 char *mask = data.mask;
939
940 if (mask != NULL)
941 {
942 uint mask_len = data.css_cnt;
943
944 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
945
946 if (mask_len > 0)
947 {
948 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
949 {
950 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
951 {
952 mask_len -= data.salts_buf[0].salt_len;
953 }
954 }
955
956 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
957
958 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
959 }
960
961 if (data.maskcnt > 1)
962 {
963 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
964
965 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
966 }
967
968 log_info ("Input.Mode.....: %s", tmp_buf);
969 }
970
971 tmp_len = 0;
972 }
973 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
974 {
975 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
976 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
977 }
978 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
979 {
980 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
981 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
982 }
983
984 if (data.digests_cnt == 1)
985 {
986 if (data.hash_mode == 2500)
987 {
988 wpa_t *wpa = (wpa_t *) data.esalts_buf;
989
990 uint pke[25];
991
992 char *pke_ptr = (char *) pke;
993
994 for (uint i = 0; i < 25; i++)
995 {
996 pke[i] = byte_swap_32 (wpa->pke[i]);
997 }
998
999 char mac1[6];
1000 char mac2[6];
1001
1002 memcpy (mac1, pke_ptr + 23, 6);
1003 memcpy (mac2, pke_ptr + 29, 6);
1004
1005 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1006 (char *) data.salts_buf[0].salt_buf,
1007 mac1[0] & 0xff,
1008 mac1[1] & 0xff,
1009 mac1[2] & 0xff,
1010 mac1[3] & 0xff,
1011 mac1[4] & 0xff,
1012 mac1[5] & 0xff,
1013 mac2[0] & 0xff,
1014 mac2[1] & 0xff,
1015 mac2[2] & 0xff,
1016 mac2[3] & 0xff,
1017 mac2[4] & 0xff,
1018 mac2[5] & 0xff);
1019 }
1020 else if (data.hash_mode == 5200)
1021 {
1022 log_info ("Hash.Target....: File (%s)", data.hashfile);
1023 }
1024 else if (data.hash_mode == 9000)
1025 {
1026 log_info ("Hash.Target....: File (%s)", data.hashfile);
1027 }
1028 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1029 {
1030 log_info ("Hash.Target....: File (%s)", data.hashfile);
1031 }
1032 else
1033 {
1034 char out_buf[4096];
1035
1036 ascii_digest (out_buf, 0, 0);
1037
1038 // limit length
1039 if (strlen (out_buf) > 40)
1040 {
1041 out_buf[41] = '.';
1042 out_buf[42] = '.';
1043 out_buf[43] = '.';
1044 out_buf[44] = 0;
1045 }
1046
1047 log_info ("Hash.Target....: %s", out_buf);
1048 }
1049 }
1050 else
1051 {
1052 if (data.hash_mode == 3000)
1053 {
1054 char out_buf1[4096];
1055 char out_buf2[4096];
1056
1057 ascii_digest (out_buf1, 0, 0);
1058 ascii_digest (out_buf2, 0, 1);
1059
1060 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1061 }
1062 else
1063 {
1064 log_info ("Hash.Target....: File (%s)", data.hashfile);
1065 }
1066 }
1067
1068 log_info ("Hash.Type......: %s", hash_type);
1069
1070 /**
1071 * speed new
1072 */
1073
1074 uint64_t speed_cnt[DEVICES_MAX];
1075 float speed_ms[DEVICES_MAX];
1076
1077 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1078 {
1079 hc_device_param_t *device_param = &data.devices_param[device_id];
1080
1081 // we need to clear values (set to 0) because in case the gpu does
1082 // not get new candidates it idles around but speed display would
1083 // show it as working.
1084 // if we instantly set it to 0 after reading it happens that the
1085 // speed can be shown as zero if the users refreshs to fast.
1086 // therefore, we add a timestamp when a stat was recorded and if its
1087 // to old we will not use it
1088
1089 speed_cnt[device_id] = 0;
1090 speed_ms[device_id] = 0;
1091
1092 for (int i = 0; i < SPEED_CACHE; i++)
1093 {
1094 float rec_ms;
1095
1096 hc_timer_get (device_param->speed_rec[i], rec_ms);
1097
1098 if (rec_ms > SPEED_MAXAGE) continue;
1099
1100 speed_cnt[device_id] += device_param->speed_cnt[i];
1101 speed_ms[device_id] += device_param->speed_ms[i];
1102 }
1103
1104 speed_cnt[device_id] /= SPEED_CACHE;
1105 speed_ms[device_id] /= SPEED_CACHE;
1106 }
1107
1108 float hashes_all_ms = 0;
1109
1110 float hashes_dev_ms[DEVICES_MAX];
1111
1112 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1113 {
1114 hashes_dev_ms[device_id] = 0;
1115
1116 if (speed_ms[device_id])
1117 {
1118 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1119
1120 hashes_all_ms += hashes_dev_ms[device_id];
1121 }
1122 }
1123
1124 /**
1125 * timers
1126 */
1127
1128 float ms_running = 0;
1129
1130 hc_timer_get (data.timer_running, ms_running);
1131
1132 float ms_paused = data.ms_paused;
1133
1134 if (data.devices_status == STATUS_PAUSED)
1135 {
1136 float ms_paused_tmp = 0;
1137
1138 hc_timer_get (data.timer_paused, ms_paused_tmp);
1139
1140 ms_paused += ms_paused_tmp;
1141 }
1142
1143 #ifdef WIN
1144
1145 __time64_t sec_run = ms_running / 1000;
1146
1147 #else
1148
1149 time_t sec_run = ms_running / 1000;
1150
1151 #endif
1152
1153 if (sec_run)
1154 {
1155 char display_run[32];
1156
1157 struct tm tm_run;
1158
1159 struct tm *tmp;
1160
1161 #ifdef WIN
1162
1163 tmp = _gmtime64 (&sec_run);
1164
1165 #else
1166
1167 tmp = gmtime (&sec_run);
1168
1169 #endif
1170
1171 if (tmp != NULL)
1172 {
1173 memcpy (&tm_run, tmp, sizeof (struct tm));
1174
1175 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1176
1177 char *start = ctime (&data.proc_start);
1178
1179 size_t start_len = strlen (start);
1180
1181 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1182 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1183
1184 log_info ("Time.Started...: %s (%s)", start, display_run);
1185 }
1186 }
1187 else
1188 {
1189 log_info ("Time.Started...: 0 secs");
1190 }
1191
1192 /**
1193 * counters
1194 */
1195
1196 uint salts_left = data.salts_cnt - data.salts_done;
1197
1198 if (salts_left == 0) salts_left = 1;
1199
1200 uint64_t progress_total = data.words_cnt * salts_left;
1201
1202 uint64_t all_done = 0;
1203 uint64_t all_rejected = 0;
1204 uint64_t all_restored = 0;
1205
1206 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1207 {
1208 if (salts_left > 1)
1209 {
1210 // otherwise the final cracked status shows 0/XXX progress
1211
1212 if (data.salts_shown[salt_pos] == 1) continue;
1213 }
1214
1215 all_done += data.words_progress_done[salt_pos];
1216 all_rejected += data.words_progress_rejected[salt_pos];
1217 all_restored += data.words_progress_restored[salt_pos];
1218 }
1219
1220 uint64_t progress_cur = all_restored + all_done + all_rejected;
1221 uint64_t progress_end = progress_total;
1222
1223 uint64_t progress_skip = 0;
1224
1225 if (data.skip)
1226 {
1227 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1228
1229 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.gpu_rules_cnt;
1230 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1231 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1232 }
1233
1234 if (data.limit)
1235 {
1236 progress_end = MIN (data.limit, data.words_base) * salts_left;
1237
1238 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.gpu_rules_cnt;
1239 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1240 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1241 }
1242
1243 uint64_t progress_cur_relative_skip = progress_cur - progress_skip;
1244 uint64_t progress_end_relative_skip = progress_end - progress_skip;
1245
1246 float speed_ms_real = ms_running - ms_paused;
1247 uint64_t speed_plains_real = all_done;
1248
1249 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1250 {
1251 if (data.devices_status != STATUS_CRACKED)
1252 {
1253 uint64_t words_per_ms = 0;
1254
1255 if (speed_plains_real && speed_ms_real)
1256 {
1257 words_per_ms = speed_plains_real / speed_ms_real;
1258 }
1259
1260 #ifdef WIN
1261 __time64_t sec_etc = 0;
1262 #else
1263 time_t sec_etc = 0;
1264 #endif
1265
1266 if (words_per_ms)
1267 {
1268 uint64_t progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1269
1270 uint64_t ms_left = progress_left_relative_skip / words_per_ms;
1271
1272 sec_etc = ms_left / 1000;
1273 }
1274
1275 if (sec_etc == 0)
1276 {
1277 log_info ("Time.Estimated.: 0 secs");
1278 }
1279 else if ((uint64_t) sec_etc > ETC_MAX)
1280 {
1281 log_info ("Time.Estimated.: > 10 Years");
1282 }
1283 else
1284 {
1285 char display_etc[32];
1286
1287 struct tm tm_etc;
1288
1289 struct tm *tmp;
1290
1291 #ifdef WIN
1292
1293 tmp = _gmtime64 (&sec_etc);
1294
1295 #else
1296
1297 tmp = gmtime (&sec_etc);
1298
1299 #endif
1300
1301 if (tmp != NULL)
1302 {
1303 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1304
1305 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1306
1307 time_t now;
1308
1309 time (&now);
1310
1311 now += sec_etc;
1312
1313 char *etc = ctime (&now);
1314
1315 size_t etc_len = strlen (etc);
1316
1317 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1318 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1319
1320 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1321 }
1322 }
1323 }
1324 }
1325
1326 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1327 {
1328 char display_dev_cur[16];
1329
1330 memset (display_dev_cur, 0, sizeof (display_dev_cur));
1331
1332 strncpy (display_dev_cur, "0.00", 4);
1333
1334 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1335
1336 log_info ("Speed.GPU.#%d...: %9sH/s", device_id + 1, display_dev_cur);
1337 }
1338
1339 char display_all_cur[16];
1340
1341 memset (display_all_cur, 0, sizeof (display_all_cur));
1342
1343 strncpy (display_all_cur, "0.00", 4);
1344
1345 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1346
1347 if (data.devices_cnt > 1) log_info ("Speed.GPU.#*...: %9sH/s", display_all_cur);
1348
1349 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1350 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1351
1352 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);
1353
1354 // crack-per-time
1355
1356 if (data.digests_cnt > 100)
1357 {
1358 time_t now = time (NULL);
1359
1360 int cpt_cur_min = 0;
1361 int cpt_cur_hour = 0;
1362 int cpt_cur_day = 0;
1363
1364 for (int i = 0; i < CPT_BUF; i++)
1365 {
1366 const uint cracked = data.cpt_buf[i].cracked;
1367 const time_t timestamp = data.cpt_buf[i].timestamp;
1368
1369 if ((timestamp + 60) > now)
1370 {
1371 cpt_cur_min += cracked;
1372 }
1373
1374 if ((timestamp + 3600) > now)
1375 {
1376 cpt_cur_hour += cracked;
1377 }
1378
1379 if ((timestamp + 86400) > now)
1380 {
1381 cpt_cur_day += cracked;
1382 }
1383 }
1384
1385 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1386 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1387 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1388
1389 if ((data.cpt_start + 86400) < now)
1390 {
1391 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1392 cpt_cur_min,
1393 cpt_cur_hour,
1394 cpt_cur_day,
1395 cpt_avg_min,
1396 cpt_avg_hour,
1397 cpt_avg_day);
1398 }
1399 else if ((data.cpt_start + 3600) < now)
1400 {
1401 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1402 cpt_cur_min,
1403 cpt_cur_hour,
1404 cpt_avg_min,
1405 cpt_avg_hour,
1406 cpt_avg_day);
1407 }
1408 else if ((data.cpt_start + 60) < now)
1409 {
1410 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1411 cpt_cur_min,
1412 cpt_avg_min,
1413 cpt_avg_hour,
1414 cpt_avg_day);
1415 }
1416 else
1417 {
1418 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1419 cpt_avg_min,
1420 cpt_avg_hour,
1421 cpt_avg_day);
1422 }
1423 }
1424
1425 // Restore point
1426
1427 uint64_t restore_point = get_lowest_words_done ();
1428
1429 uint64_t restore_total = data.words_base;
1430
1431 float percent_restore = 0;
1432
1433 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1434
1435 if (progress_end_relative_skip)
1436 {
1437 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1438 {
1439 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1440 float percent_rejected = 0.0;
1441
1442 if (progress_cur)
1443 {
1444 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1445 }
1446
1447 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);
1448 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1449
1450 if (data.restore_disable == 0)
1451 {
1452 if (percent_finished != 1)
1453 {
1454 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1455 }
1456 }
1457 }
1458 }
1459 else
1460 {
1461 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1462 {
1463 log_info ("Progress.......: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1464 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1465
1466 if (data.restore_disable == 0)
1467 {
1468 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1469 }
1470 }
1471 else
1472 {
1473 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1474 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1475
1476 // --restore not allowed if stdin is used -- really? why?
1477
1478 //if (data.restore_disable == 0)
1479 //{
1480 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1481 //}
1482 }
1483 }
1484
1485 if (data.gpu_temp_disable == 0)
1486 {
1487 hc_thread_mutex_lock (mux_adl);
1488
1489 for (uint i = 0; i < data.devices_cnt; i++)
1490 {
1491 if (data.hm_device[i].fan_supported == 1)
1492 {
1493 const int temperature = hm_get_temperature_with_device_id (i);
1494 const int utilization = hm_get_utilization_with_device_id (i);
1495 const int fanspeed = hm_get_fanspeed_with_device_id (i);
1496
1497 if (data.vendor_id == VENDOR_ID_AMD)
1498 {
1499 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, %2d%% Fan", i + 1, utilization, temperature, fanspeed);
1500 }
1501
1502 if (data.vendor_id == VENDOR_ID_NV)
1503 {
1504 #ifdef LINUX
1505 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, %2d%% Fan", i + 1, utilization, temperature, fanspeed);
1506 #else
1507 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, %2drpm Fan", i + 1, utilization, temperature, fanspeed);
1508 #endif
1509 }
1510 }
1511 else
1512 {
1513 const int temperature = hm_get_temperature_with_device_id (i);
1514 const int utilization = hm_get_utilization_with_device_id (i);
1515
1516 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, N/A Fan", i + 1, utilization, temperature);
1517 }
1518 }
1519
1520 hc_thread_mutex_unlock (mux_adl);
1521 }
1522 }
1523
1524 static void status_benchmark ()
1525 {
1526 if (data.devices_status == STATUS_INIT) return;
1527 if (data.devices_status == STATUS_STARTING) return;
1528
1529 if (data.words_cnt == 0) return;
1530
1531 uint64_t speed_cnt[DEVICES_MAX];
1532 float speed_ms[DEVICES_MAX];
1533
1534 uint device_id;
1535
1536 for (device_id = 0; device_id < data.devices_cnt; device_id++)
1537 {
1538 hc_device_param_t *device_param = &data.devices_param[device_id];
1539
1540 speed_cnt[device_id] = 0;
1541 speed_ms[device_id] = 0;
1542
1543 for (int i = 0; i < SPEED_CACHE; i++)
1544 {
1545 speed_cnt[device_id] += device_param->speed_cnt[i];
1546 speed_ms[device_id] += device_param->speed_ms[i];
1547 }
1548
1549 speed_cnt[device_id] /= SPEED_CACHE;
1550 speed_ms[device_id] /= SPEED_CACHE;
1551 }
1552
1553 float hashes_all_ms = 0;
1554
1555 float hashes_dev_ms[DEVICES_MAX];
1556
1557 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1558 {
1559 hashes_dev_ms[device_id] = 0;
1560
1561 if (speed_ms[device_id])
1562 {
1563 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1564
1565 hashes_all_ms += hashes_dev_ms[device_id];
1566 }
1567 }
1568
1569 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1570 {
1571 char display_dev_cur[16];
1572
1573 memset (display_dev_cur, 0, sizeof (display_dev_cur));
1574
1575 strncpy (display_dev_cur, "0.00", 4);
1576
1577 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1578
1579 log_info ("Speed.GPU.#%d.: %9sH/s", device_id + 1, display_dev_cur);
1580 }
1581
1582 char display_all_cur[16];
1583
1584 memset (display_all_cur, 0, sizeof (display_all_cur));
1585
1586 strncpy (display_all_cur, "0.00", 4);
1587
1588 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1589
1590 if (data.devices_cnt > 1) log_info ("Speed.GPU.#*.: %9sH/s", display_all_cur);
1591 }
1592
1593 /**
1594 * oclHashcat -only- functions
1595 */
1596
1597 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *install_dir, char *source_file)
1598 {
1599 if (attack_exec == ATTACK_EXEC_ON_GPU)
1600 {
1601 if (attack_kern == ATTACK_KERN_STRAIGHT)
1602 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", install_dir, (int) kern_type);
1603 else if (attack_kern == ATTACK_KERN_COMBI)
1604 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", install_dir, (int) kern_type);
1605 else if (attack_kern == ATTACK_KERN_BF)
1606 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", install_dir, (int) kern_type);
1607 }
1608 else
1609 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", install_dir, (int) kern_type);
1610 }
1611
1612 static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *install_dir, char *device_name, char *device_version, char *driver_version, int vendor_id, char *cached_file)
1613 {
1614 if (attack_exec == ATTACK_EXEC_ON_GPU)
1615 {
1616 if (attack_kern == ATTACK_KERN_STRAIGHT)
1617 snprintf (cached_file, 255, "%s/kernels/%d/m%05d_a0.%s_%s_%s_%d.kernel", install_dir, vendor_id, (int) kern_type, device_name, device_version, driver_version, COMPTIME);
1618 else if (attack_kern == ATTACK_KERN_COMBI)
1619 snprintf (cached_file, 255, "%s/kernels/%d/m%05d_a1.%s_%s_%s_%d.kernel", install_dir, vendor_id, (int) kern_type, device_name, device_version, driver_version, COMPTIME);
1620 else if (attack_kern == ATTACK_KERN_BF)
1621 snprintf (cached_file, 255, "%s/kernels/%d/m%05d_a3.%s_%s_%s_%d.kernel", install_dir, vendor_id, (int) kern_type, device_name, device_version, driver_version, COMPTIME);
1622 }
1623 else
1624 {
1625 snprintf (cached_file, 255, "%s/kernels/%d/m%05d.%s_%s_%s_%d.kernel", install_dir, vendor_id, (int) kern_type, device_name, device_version, driver_version, COMPTIME);
1626 }
1627 }
1628
1629 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *install_dir, char *source_file)
1630 {
1631 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1632 {
1633 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", install_dir);
1634 }
1635 else
1636 {
1637 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", install_dir);
1638 }
1639 }
1640
1641 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *install_dir, char *device_name, char *device_version, char *driver_version, int vendor_id, char *cached_file)
1642 {
1643 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1644 {
1645 snprintf (cached_file, 255, "%s/kernels/%d/markov_be.%s_%s_%s_%d.kernel", install_dir, vendor_id, device_name, device_version, driver_version, COMPTIME);
1646 }
1647 else
1648 {
1649 snprintf (cached_file, 255, "%s/kernels/%d/markov_le.%s_%s_%s_%d.kernel", install_dir, vendor_id, device_name, device_version, driver_version, COMPTIME);
1650 }
1651 }
1652
1653 static void generate_source_kernel_amp_filename (const uint attack_kern, char *install_dir, char *source_file)
1654 {
1655 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", install_dir, attack_kern);
1656 }
1657
1658 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *install_dir, char *device_name, char *device_version, char *driver_version, int vendor_id, char *cached_file)
1659 {
1660 snprintf (cached_file, 255, "%s/kernels/%d/amp_a%d.%s_%s_%s_%d.kernel", install_dir, vendor_id, attack_kern, device_name, device_version, driver_version, COMPTIME);
1661 }
1662
1663 static uint convert_from_hex (char *line_buf, const uint line_len)
1664 {
1665 if (line_len & 1) return (line_len); // not in hex
1666
1667 if (data.hex_wordlist == 1)
1668 {
1669 uint i;
1670 uint j;
1671
1672 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1673 {
1674 line_buf[i] = hex_to_char (&line_buf[j]);
1675 }
1676
1677 memset (line_buf + i, 0, line_len - i);
1678
1679 return (i);
1680 }
1681 else if (line_len >= 6) // $HEX[] = 6
1682 {
1683 if (line_buf[0] != '$') return (line_len);
1684 if (line_buf[1] != 'H') return (line_len);
1685 if (line_buf[2] != 'E') return (line_len);
1686 if (line_buf[3] != 'X') return (line_len);
1687 if (line_buf[4] != '[') return (line_len);
1688 if (line_buf[line_len - 1] != ']') return (line_len);
1689
1690 uint i;
1691 uint j;
1692
1693 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1694 {
1695 line_buf[i] = hex_to_char (&line_buf[j]);
1696 }
1697
1698 memset (line_buf + i, 0, line_len - i);
1699
1700 return (i);
1701 }
1702
1703 return (line_len);
1704 }
1705
1706 static uint count_lines (FILE *fd)
1707 {
1708 uint cnt = 0;
1709
1710 char *buf = (char *) mymalloc (BUFSIZ);
1711
1712 size_t nread_tmp = 0;
1713
1714 char *ptr = buf;
1715
1716 while (!feof (fd))
1717 {
1718 size_t nread = fread (buf, sizeof (char), BUFSIZ, fd);
1719 nread_tmp = nread;
1720
1721 if (nread < 1) continue;
1722
1723 ptr = buf;
1724
1725 do
1726 {
1727 if (*ptr++ == '\n') cnt++;
1728
1729 } while (nread--);
1730 }
1731
1732 // special case (if last line did not contain a newline char ... at the very end of the file)
1733
1734 if (nread_tmp > 3)
1735 {
1736 ptr -= 2;
1737
1738 if (*ptr != '\n')
1739 {
1740 ptr--;
1741
1742 if (*ptr != '\n') // needed ? different on windows systems?
1743 {
1744 cnt++;
1745 }
1746 }
1747 }
1748
1749 myfree (buf);
1750
1751 return cnt;
1752 }
1753
1754 static void clear_prompt ()
1755 {
1756 fputc ('\r', stdout);
1757
1758 for (size_t i = 0; i < strlen (PROMPT); i++)
1759 {
1760 fputc (' ', stdout);
1761 }
1762
1763 fputc ('\r', stdout);
1764
1765 fflush (stdout);
1766 }
1767
1768 static void gidd_to_pw_t (hc_device_param_t *device_param, const uint64_t gidd, pw_t *pw)
1769 {
1770 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1771 }
1772
1773 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1774 {
1775 char *outfile = data.outfile;
1776 uint quiet = data.quiet;
1777 FILE *pot_fp = data.pot_fp;
1778 uint loopback = data.loopback;
1779 uint debug_mode = data.debug_mode;
1780 char *debug_file = data.debug_file;
1781
1782 char debug_rule_buf[BLOCK_SIZE];
1783 int debug_rule_len = 0; // -1 error
1784 uint debug_plain_len = 0;
1785
1786 unsigned char debug_plain_ptr[BLOCK_SIZE];
1787
1788 // hash
1789
1790 char out_buf[4096]; memset (out_buf, 0, sizeof (out_buf));
1791
1792 ascii_digest (out_buf, salt_pos, digest_pos);
1793
1794 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1795
1796 // plain
1797
1798 plain_t plain;
1799
1800 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, idx * sizeof (plain_t), sizeof (plain_t), &plain, 0, NULL, NULL);
1801
1802 uint gidvid = plain.gidvid;
1803 uint il_pos = plain.il_pos;
1804
1805 uint64_t crackpos = device_param->words_off;
1806
1807 uint plain_buf[16];
1808
1809 unsigned char *plain_ptr = (unsigned char *) plain_buf;
1810 unsigned int plain_len = 0;
1811
1812 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1813 {
1814 uint64_t gidd = gidvid;
1815 uint64_t gidm = 0;
1816
1817 pw_t pw;
1818
1819 gidd_to_pw_t (device_param, gidd, &pw);
1820
1821 for (int i = 0, j = gidm; i < 16; i++, j++)
1822 {
1823 plain_buf[i] = pw.hi1[0][j];
1824 }
1825
1826 plain_len = pw.pw_len;
1827
1828 const uint off = device_param->innerloop_pos + il_pos;
1829
1830 if (debug_mode > 0)
1831 {
1832 debug_rule_len = 0;
1833
1834 // save rule
1835 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1836 {
1837 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1838
1839 debug_rule_len = gpu_rule_to_cpu_rule (debug_rule_buf, &data.gpu_rules_buf[off]);
1840 }
1841
1842 // save plain
1843 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1844 {
1845 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1846
1847 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1848
1849 debug_plain_len = plain_len;
1850 }
1851 }
1852
1853 plain_len = apply_rules (data.gpu_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1854
1855 crackpos += gidvid;
1856 crackpos *= data.gpu_rules_cnt;
1857 crackpos += device_param->innerloop_pos + il_pos;
1858
1859 if (plain_len > data.pw_max) plain_len = data.pw_max;
1860 }
1861 else if (data.attack_mode == ATTACK_MODE_COMBI)
1862 {
1863 uint64_t gidd = gidvid;
1864 uint64_t gidm = 0;
1865
1866 pw_t pw;
1867
1868 gidd_to_pw_t (device_param, gidd, &pw);
1869
1870 for (int i = 0, j = gidm; i < 16; i++, j++)
1871 {
1872 plain_buf[i] = pw.hi1[0][j];
1873 }
1874
1875 plain_len = pw.pw_len;
1876
1877 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1878 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1879
1880 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1881 {
1882 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1883 }
1884 else
1885 {
1886 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1887
1888 memcpy (plain_ptr, comb_buf, comb_len);
1889 }
1890
1891 plain_len += comb_len;
1892
1893 crackpos += gidvid;
1894 crackpos *= data.combs_cnt;
1895 crackpos += device_param->innerloop_pos + il_pos;
1896
1897 if (data.pw_max != PW_DICTMAX1)
1898 {
1899 if (plain_len > data.pw_max) plain_len = data.pw_max;
1900 }
1901 }
1902 else if (data.attack_mode == ATTACK_MODE_BF)
1903 {
1904 uint64_t l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1905 uint64_t r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1906
1907 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1908 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1909
1910 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1911 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1912
1913 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1914 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1915
1916 plain_len = data.css_cnt;
1917
1918 crackpos += gidvid;
1919 crackpos *= data.bfs_cnt;
1920 crackpos += device_param->innerloop_pos + il_pos;
1921 }
1922 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1923 {
1924 uint64_t gidd = gidvid;
1925 uint64_t gidm = 0;
1926
1927 pw_t pw;
1928
1929 gidd_to_pw_t (device_param, gidd, &pw);
1930
1931 for (int i = 0, j = gidm; i < 16; i++, j++)
1932 {
1933 plain_buf[i] = pw.hi1[0][j];
1934 }
1935
1936 plain_len = pw.pw_len;
1937
1938 uint64_t off = device_param->kernel_params_mp_buf64[3] + il_pos;
1939
1940 uint start = 0;
1941 uint stop = device_param->kernel_params_mp_buf32[4];
1942
1943 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
1944
1945 plain_len += start + stop;
1946
1947 crackpos += gidvid;
1948 crackpos *= data.combs_cnt;
1949 crackpos += device_param->innerloop_pos + il_pos;
1950
1951 if (data.pw_max != PW_DICTMAX1)
1952 {
1953 if (plain_len > data.pw_max) plain_len = data.pw_max;
1954 }
1955 }
1956 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1957 {
1958 uint64_t gidd = gidvid;
1959 uint64_t gidm = 0;
1960
1961 pw_t pw;
1962
1963 gidd_to_pw_t (device_param, gidd, &pw);
1964
1965 for (int i = 0, j = gidm; i < 16; i++, j++)
1966 {
1967 plain_buf[i] = pw.hi1[0][j];
1968 }
1969
1970 plain_len = pw.pw_len;
1971
1972 uint64_t off = device_param->kernel_params_mp_buf64[3] + il_pos;
1973
1974 uint start = 0;
1975 uint stop = device_param->kernel_params_mp_buf32[4];
1976
1977 memmove (plain_ptr + stop, plain_ptr, plain_len);
1978
1979 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
1980
1981 plain_len += start + stop;
1982
1983 crackpos += gidvid;
1984 crackpos *= data.combs_cnt;
1985 crackpos += device_param->innerloop_pos + il_pos;
1986
1987 if (data.pw_max != PW_DICTMAX1)
1988 {
1989 if (plain_len > data.pw_max) plain_len = data.pw_max;
1990 }
1991 }
1992
1993 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
1994 {
1995 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1996 {
1997 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1998 {
1999 plain_len = plain_len - data.salts_buf[0].salt_len;
2000 }
2001 }
2002
2003 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2004 {
2005 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2006 {
2007 plain_ptr[j] = plain_ptr[i];
2008 }
2009
2010 plain_len = plain_len / 2;
2011 }
2012 }
2013
2014 // if enabled, update also the potfile
2015
2016 if (pot_fp)
2017 {
2018 fprintf (pot_fp, "%s:", out_buf);
2019
2020 format_plain (pot_fp, plain_ptr, plain_len, 1);
2021
2022 fputc ('\n', pot_fp);
2023
2024 fflush (pot_fp);
2025 }
2026
2027 // outfile
2028
2029 FILE *out_fp = NULL;
2030
2031 if (outfile != NULL)
2032 {
2033 if ((out_fp = fopen (outfile, "ab")) == NULL)
2034 {
2035 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2036
2037 out_fp = stdout;
2038 }
2039 }
2040 else
2041 {
2042 out_fp = stdout;
2043
2044 if (quiet == 0) clear_prompt ();
2045 }
2046
2047 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2048
2049 if (outfile != NULL)
2050 {
2051 if (out_fp != stdout)
2052 {
2053 fclose (out_fp);
2054 }
2055 }
2056 else
2057 {
2058 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2059 {
2060 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2061 {
2062 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2063 if (quiet == 0) fflush (stdout);
2064 }
2065 }
2066 }
2067
2068 // loopback
2069
2070 if (loopback)
2071 {
2072 char *loopback_file = data.loopback_file;
2073
2074 FILE *fb_fp = NULL;
2075
2076 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2077 {
2078 format_plain (fb_fp, plain_ptr, plain_len, 1);
2079
2080 fputc ('\n', fb_fp);
2081
2082 fclose (fb_fp);
2083 }
2084 }
2085
2086 // (rule) debug mode
2087
2088 // the next check implies that:
2089 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2090 // - debug_mode > 0
2091
2092 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2093 {
2094 if (debug_rule_len < 0) debug_rule_len = 0;
2095
2096 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2097
2098 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2099
2100 if ((quiet == 0) && (debug_file == NULL))
2101 {
2102 fprintf (stdout, "%s", PROMPT);
2103 fflush (stdout);
2104 }
2105 }
2106 }
2107
2108 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2109 {
2110 salt_t *salt_buf = &data.salts_buf[salt_pos];
2111
2112 int found = 0;
2113
2114 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2115
2116 for (uint i = 0; i < GPU_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2117
2118 if (found == 1)
2119 {
2120 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2121
2122 log_info_nn ("");
2123
2124 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);
2125
2126 uint cpt_cracked = 0;
2127
2128 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2129 {
2130 uint idx = salt_buf->digests_offset + digest_pos;
2131
2132 if (data.digests_shown_tmp[idx] == 0) continue;
2133
2134 if (data.digests_shown[idx] == 1) continue;
2135
2136 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2137 {
2138 data.digests_shown[idx] = 1;
2139
2140 data.digests_done++;
2141
2142 cpt_cracked++;
2143
2144 salt_buf->digests_done++;
2145
2146 if (salt_buf->digests_done == salt_buf->digests_cnt)
2147 {
2148 data.salts_shown[salt_pos] = 1;
2149
2150 data.salts_done++;
2151 }
2152 }
2153
2154 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2155
2156 check_hash (device_param, salt_pos, digest_pos);
2157 }
2158
2159 if (cpt_cracked > 0)
2160 {
2161 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2162 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2163
2164 data.cpt_pos++;
2165
2166 data.cpt_total += cpt_cracked;
2167
2168 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2169 }
2170
2171 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2172 {
2173 // we need to reset cracked state on the gpu
2174 // otherwise host thinks again and again the hash was cracked
2175 // and returns invalid password each time
2176
2177 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2178
2179 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);
2180 }
2181
2182 memset (device_param->result, 0, device_param->size_results);
2183
2184 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2185 }
2186 }
2187
2188 static void save_hash ()
2189 {
2190 char *hashfile = data.hashfile;
2191
2192 char new_hashfile[256];
2193 char old_hashfile[256];
2194
2195 memset (new_hashfile, 0, sizeof (new_hashfile));
2196 memset (old_hashfile, 0, sizeof (old_hashfile));
2197
2198 snprintf (new_hashfile, 255, "%s.new", hashfile);
2199 snprintf (old_hashfile, 255, "%s.old", hashfile);
2200
2201 unlink (new_hashfile);
2202
2203 char separator = data.separator;
2204
2205 FILE *fp = fopen (new_hashfile, "wb");
2206
2207 if (fp == NULL)
2208 {
2209 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2210
2211 exit (-1);
2212 }
2213
2214 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2215 {
2216 if (data.salts_shown[salt_pos] == 1) continue;
2217
2218 salt_t *salt_buf = &data.salts_buf[salt_pos];
2219
2220 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2221 {
2222 uint idx = salt_buf->digests_offset + digest_pos;
2223
2224 if (data.digests_shown[idx] == 1) continue;
2225
2226 if (data.hash_mode != 2500)
2227 {
2228 char out_buf[4096];
2229
2230 memset (out_buf, 0, sizeof (out_buf));
2231
2232 if (data.username == 1)
2233 {
2234 user_t *user = data.hash_info[idx]->user;
2235
2236 uint i;
2237
2238 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2239
2240 fputc (separator, fp);
2241 }
2242
2243 ascii_digest (out_buf, salt_pos, digest_pos);
2244
2245 fputs (out_buf, fp);
2246
2247 log_out (fp, "");
2248 }
2249 else
2250 {
2251 hccap_t hccap;
2252
2253 to_hccap_t (&hccap, salt_pos, digest_pos);
2254
2255 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2256 }
2257 }
2258 }
2259
2260 fflush (fp);
2261
2262 fclose (fp);
2263
2264 unlink (old_hashfile);
2265
2266 if (rename (hashfile, old_hashfile) != 0)
2267 {
2268 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2269
2270 exit (-1);
2271 }
2272
2273 unlink (hashfile);
2274
2275 if (rename (new_hashfile, hashfile) != 0)
2276 {
2277 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2278
2279 exit (-1);
2280 }
2281
2282 unlink (old_hashfile);
2283 }
2284
2285 static float find_gpu_blocks_div (const uint64_t total_left, const uint gpu_blocks_all)
2286 {
2287 // function called only in case gpu_blocks_all > words_left)
2288
2289 float gpu_blocks_div = (float) (total_left) / gpu_blocks_all;
2290
2291 gpu_blocks_div += gpu_blocks_div / 100;
2292
2293 uint32_t gpu_blocks_new = (uint32_t) (gpu_blocks_all * gpu_blocks_div);
2294
2295 while (gpu_blocks_new < total_left)
2296 {
2297 gpu_blocks_div += gpu_blocks_div / 100;
2298
2299 gpu_blocks_new = (uint32_t) (gpu_blocks_all * gpu_blocks_div);
2300 }
2301
2302 if (data.quiet == 0)
2303 {
2304 clear_prompt ();
2305
2306 log_info ("");
2307
2308 log_info ("INFO: approaching final keyspace, workload adjusted");
2309
2310 log_info ("");
2311
2312 fprintf (stdout, "%s", PROMPT);
2313
2314 fflush (stdout);
2315 }
2316
2317 if ((gpu_blocks_all * gpu_blocks_div) < 8) return 1;
2318
2319 return gpu_blocks_div;
2320 }
2321
2322 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num)
2323 {
2324 uint num_elements = num;
2325
2326 device_param->kernel_params_buf32[30] = data.combs_mode;
2327 device_param->kernel_params_buf32[31] = num;
2328
2329 uint gpu_threads = device_param->gpu_threads;
2330
2331 while (num_elements % gpu_threads) num_elements++;
2332
2333 cl_kernel kernel = NULL;
2334
2335 switch (kern_run)
2336 {
2337 case KERN_RUN_1: kernel = device_param->kernel1; break;
2338 case KERN_RUN_12: kernel = device_param->kernel12; break;
2339 case KERN_RUN_2: kernel = device_param->kernel2; break;
2340 case KERN_RUN_23: kernel = device_param->kernel23; break;
2341 case KERN_RUN_3: kernel = device_param->kernel3; break;
2342 }
2343
2344 hc_clSetKernelArg (kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2345 hc_clSetKernelArg (kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2346 hc_clSetKernelArg (kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2347 hc_clSetKernelArg (kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2348 hc_clSetKernelArg (kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2349 hc_clSetKernelArg (kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2350 hc_clSetKernelArg (kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2351 hc_clSetKernelArg (kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2352 hc_clSetKernelArg (kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2353 hc_clSetKernelArg (kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2354 hc_clSetKernelArg (kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2355
2356 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2357 {
2358 const size_t global_work_size[3] = { num_elements, 32, 1 };
2359 const size_t local_work_size[3] = { gpu_threads / 32, 32, 1 };
2360
2361 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2362 }
2363 else
2364 {
2365 const size_t global_work_size[3] = { num_elements, 1, 1 };
2366 const size_t local_work_size[3] = { gpu_threads, 1, 1 };
2367
2368 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2369 }
2370
2371 hc_clFlush (device_param->command_queue);
2372
2373 hc_clFinish (device_param->command_queue);
2374 }
2375
2376 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2377 {
2378 uint num_elements = num;
2379
2380 switch (kern_run)
2381 {
2382 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2383 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2384 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2385 }
2386
2387 // causes problems with special threads like in bcrypt
2388 // const uint gpu_threads = device_param->gpu_threads;
2389
2390 const uint gpu_threads = GPU_THREADS;
2391
2392 while (num_elements % gpu_threads) num_elements++;
2393
2394 cl_kernel kernel = NULL;
2395
2396 switch (kern_run)
2397 {
2398 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2399 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2400 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2401 }
2402
2403 switch (kern_run)
2404 {
2405 case KERN_RUN_MP: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2406 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2407 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2408 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2409 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2410 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2411 break;
2412 case KERN_RUN_MP_R: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2413 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2414 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2415 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2416 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2417 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2418 break;
2419 case KERN_RUN_MP_L: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2420 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2421 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2422 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2423 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2424 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2425 hc_clSetKernelArg (kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2426 break;
2427 }
2428
2429 const size_t global_work_size[3] = { num_elements, 1, 1 };
2430 const size_t local_work_size[3] = { gpu_threads, 1, 1 };
2431
2432 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2433
2434 hc_clFlush (device_param->command_queue);
2435
2436 hc_clFinish (device_param->command_queue);
2437 }
2438
2439 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2440 {
2441 uint num_elements = num;
2442
2443 uint gpu_threads = device_param->gpu_threads;
2444
2445 while (num_elements % gpu_threads) num_elements++;
2446
2447 cl_kernel kernel = device_param->kernel_tb;
2448
2449 const size_t global_work_size[3] = { num_elements, 1, 1 };
2450 const size_t local_work_size[3] = { gpu_threads, 1, 1 };
2451
2452 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2453
2454 hc_clFlush (device_param->command_queue);
2455
2456 hc_clFinish (device_param->command_queue);
2457 }
2458
2459 static void run_kernel_tm (hc_device_param_t *device_param)
2460 {
2461 const uint num_elements = 1024; // fixed
2462
2463 const uint gpu_threads = 32;
2464
2465 cl_kernel kernel = device_param->kernel_tm;
2466
2467 const size_t global_work_size[3] = { num_elements, 1, 1 };
2468 const size_t local_work_size[3] = { gpu_threads, 1, 1 };
2469
2470 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2471
2472 hc_clFlush (device_param->command_queue);
2473
2474 hc_clFinish (device_param->command_queue);
2475 }
2476
2477 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2478 {
2479 uint num_elements = num;
2480
2481 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2482 device_param->kernel_params_amp_buf32[6] = num_elements;
2483
2484 // causes problems with special threads like in bcrypt
2485 // const uint gpu_threads = device_param->gpu_threads;
2486
2487 const uint gpu_threads = GPU_THREADS;
2488
2489 while (num_elements % gpu_threads) num_elements++;
2490
2491 cl_kernel kernel = device_param->kernel_amp;
2492
2493 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2494 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2495
2496 const size_t global_work_size[3] = { num_elements, 1, 1 };
2497 const size_t local_work_size[3] = { gpu_threads, 1, 1 };
2498
2499 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2500
2501 hc_clFlush (device_param->command_queue);
2502
2503 hc_clFinish (device_param->command_queue);
2504 }
2505
2506 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2507 {
2508 if (data.vendor_id == VENDOR_ID_AMD)
2509 {
2510 const cl_uchar zero = 0;
2511
2512 hc_clEnqueueFillBuffer (device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2513 }
2514
2515 if (data.vendor_id == VENDOR_ID_NV)
2516 {
2517 // NOTE: clEnqueueFillBuffer () always fails with -59
2518 // IOW, it's not supported by Nvidia ForceWare <= 352.21,
2519 // How's that possible, OpenCL 1.2 support is advertised??
2520 // We need to workaround...
2521
2522 #define FILLSZ 0x100000
2523
2524 char *tmp = (char *) mymalloc (FILLSZ);
2525
2526 memset (tmp, 0, FILLSZ);
2527
2528 for (uint i = 0; i < size; i += FILLSZ)
2529 {
2530 const int left = size - i;
2531
2532 const int fillsz = MIN (FILLSZ, left);
2533
2534 hc_clEnqueueWriteBuffer (device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2535 }
2536
2537 myfree (tmp);
2538 }
2539 }
2540
2541 static int run_rule_engine (const int rule_len, const char *rule_buf)
2542 {
2543 if (rule_len == 0)
2544 {
2545 return 0;
2546 }
2547 else if (rule_len == 1)
2548 {
2549 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2550 }
2551
2552 return 1;
2553 }
2554
2555 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2556 {
2557 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2558 {
2559 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);
2560 }
2561 else if (data.attack_kern == ATTACK_KERN_COMBI)
2562 {
2563 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);
2564 }
2565 else if (data.attack_kern == ATTACK_KERN_BF)
2566 {
2567 const uint64_t off = device_param->words_off;
2568
2569 device_param->kernel_params_mp_l_buf64[3] = off;
2570
2571 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2572 }
2573 }
2574
2575 static void run_cracker (hc_device_param_t *device_param, const uint pw_cnt, const uint pws_cnt)
2576 {
2577 const uint gpu_loops = data.gpu_loops;
2578
2579 // init speed timer
2580
2581 uint speed_pos = device_param->speed_pos;
2582
2583 #ifdef _POSIX
2584 if (device_param->timer_speed.tv_sec == 0)
2585 {
2586 hc_timer_set (&device_param->timer_speed);
2587 }
2588 #endif
2589
2590 #ifdef _WIN
2591 if (device_param->timer_speed.QuadPart == 0)
2592 {
2593 hc_timer_set (&device_param->timer_speed);
2594 }
2595 #endif
2596
2597 // find higest password length, this is for optimization stuff
2598
2599 uint highest_pw_len = 0;
2600
2601 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2602 {
2603 }
2604 else if (data.attack_kern == ATTACK_KERN_COMBI)
2605 {
2606 }
2607 else if (data.attack_kern == ATTACK_KERN_BF)
2608 {
2609 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
2610 + device_param->kernel_params_mp_l_buf32[5];
2611 }
2612
2613 // bitslice optimization stuff
2614
2615 if (data.attack_mode == ATTACK_MODE_BF)
2616 {
2617 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2618 {
2619 run_kernel_tb (device_param, pws_cnt);
2620 }
2621 }
2622
2623 // iteration type
2624
2625 uint innerloop_step = 0;
2626 uint innerloop_cnt = 0;
2627
2628 if (data.attack_exec == ATTACK_EXEC_ON_GPU) innerloop_step = gpu_loops;
2629 else innerloop_step = 1;
2630
2631 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.gpu_rules_cnt;
2632 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
2633 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
2634
2635 // loop start: most outer loop = salt iteration, then innerloops (if multi)
2636
2637 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2638 {
2639 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2640
2641 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2642
2643 if (data.devices_status == STATUS_CRACKED) break;
2644 if (data.devices_status == STATUS_ABORTED) break;
2645 if (data.devices_status == STATUS_QUIT) break;
2646 if (data.devices_status == STATUS_BYPASS) break;
2647
2648 if (data.salts_shown[salt_pos] == 1) continue;
2649
2650 salt_t *salt_buf = &data.salts_buf[salt_pos];
2651
2652 device_param->kernel_params_buf32[24] = salt_pos;
2653 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
2654 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
2655
2656 FILE *combs_fp = device_param->combs_fp;
2657
2658 if (data.attack_mode == ATTACK_MODE_COMBI)
2659 {
2660 rewind (combs_fp);
2661 }
2662
2663 // innerloops
2664
2665 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
2666 {
2667 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2668
2669 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2670
2671 if (data.devices_status == STATUS_CRACKED) break;
2672 if (data.devices_status == STATUS_ABORTED) break;
2673 if (data.devices_status == STATUS_QUIT) break;
2674 if (data.devices_status == STATUS_BYPASS) break;
2675
2676 uint innerloop_left = innerloop_cnt - innerloop_pos;
2677
2678 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
2679
2680 device_param->innerloop_pos = innerloop_pos;
2681 device_param->innerloop_left = innerloop_left;
2682
2683 device_param->kernel_params_buf32[27] = innerloop_left;
2684
2685 if (innerloop_left == 0) continue;
2686
2687 // initialize amplifiers
2688
2689 if (data.attack_mode == ATTACK_MODE_COMBI)
2690 {
2691 char line_buf[BUFSIZ];
2692
2693 uint i = 0;
2694
2695 while (i < innerloop_left)
2696 {
2697 if (feof (combs_fp)) break;
2698
2699 int line_len = fgetl (combs_fp, line_buf);
2700
2701 if (line_len >= PW_MAX1) continue;
2702
2703 line_len = convert_from_hex (line_buf, line_len);
2704
2705 char *line_buf_new = line_buf;
2706
2707 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
2708 {
2709 char rule_buf_out[BLOCK_SIZE];
2710
2711 memset (rule_buf_out, 0, sizeof (rule_buf_out));
2712
2713 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
2714
2715 if (rule_len_out < 0)
2716 {
2717 data.words_progress_rejected[salt_pos] += pw_cnt;
2718
2719 continue;
2720 }
2721
2722 line_len = rule_len_out;
2723
2724 line_buf_new = rule_buf_out;
2725 }
2726
2727 line_len = MIN (line_len, PW_DICTMAX);
2728
2729 char *ptr = (char *) device_param->combs_buf[i].i;
2730
2731 memcpy (ptr, line_buf_new, line_len);
2732
2733 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
2734
2735 if (data.opts_type & OPTS_TYPE_PT_UPPER)
2736 {
2737 uppercase (ptr, line_len);
2738 }
2739
2740 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2741 {
2742 if (data.opts_type & OPTS_TYPE_PT_ADD80)
2743 {
2744 ptr[line_len] = 0x80;
2745 }
2746
2747 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2748 {
2749 ptr[line_len] = 0x01;
2750 }
2751 }
2752
2753 device_param->combs_buf[i].pw_len = line_len;
2754
2755 i++;
2756 }
2757
2758 for (uint j = i; j < innerloop_left; j++)
2759 {
2760 device_param->combs_buf[j].i[0] = 0;
2761 device_param->combs_buf[j].i[1] = 0;
2762 device_param->combs_buf[j].i[2] = 0;
2763 device_param->combs_buf[j].i[3] = 0;
2764 device_param->combs_buf[j].i[4] = 0;
2765 device_param->combs_buf[j].i[5] = 0;
2766 device_param->combs_buf[j].i[6] = 0;
2767 device_param->combs_buf[j].i[7] = 0;
2768
2769 device_param->combs_buf[j].pw_len = 0;
2770 }
2771
2772 innerloop_left = i;
2773 }
2774 else if (data.attack_mode == ATTACK_MODE_BF)
2775 {
2776 uint64_t off = innerloop_pos;
2777
2778 device_param->kernel_params_mp_r_buf64[3] = off;
2779
2780 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
2781 }
2782 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2783 {
2784 uint64_t off = innerloop_pos;
2785
2786 device_param->kernel_params_mp_buf64[3] = off;
2787
2788 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2789 }
2790 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2791 {
2792 uint64_t off = innerloop_pos;
2793
2794 device_param->kernel_params_mp_buf64[3] = off;
2795
2796 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2797 }
2798
2799 // copy amplifiers
2800
2801 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2802 {
2803 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);
2804 }
2805 else if (data.attack_mode == ATTACK_MODE_COMBI)
2806 {
2807 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);
2808 }
2809 else if (data.attack_mode == ATTACK_MODE_BF)
2810 {
2811 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);
2812 }
2813 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2814 {
2815 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);
2816 }
2817 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2818 {
2819 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);
2820 }
2821
2822 if (data.attack_exec == ATTACK_EXEC_ON_GPU)
2823 {
2824 if (data.attack_mode == ATTACK_MODE_BF)
2825 {
2826 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2827 {
2828 const uint size_tm = 32 * sizeof (bs_word_t);
2829
2830 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2831
2832 run_kernel_tm (device_param);
2833
2834 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2835 }
2836 }
2837
2838 if (highest_pw_len < 16)
2839 {
2840 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2841 }
2842 else if (highest_pw_len < 32)
2843 {
2844 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2845 }
2846 else
2847 {
2848 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2849 }
2850 }
2851 else
2852 {
2853 run_kernel_amp (device_param, pws_cnt);
2854
2855 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2856
2857 if (data.opts_type & OPTS_TYPE_HOOK12)
2858 {
2859 run_kernel (KERN_RUN_12, device_param, pws_cnt);
2860 }
2861
2862 uint iter = salt_buf->salt_iter;
2863
2864 for (uint loop_pos = 0; loop_pos < iter; loop_pos += gpu_loops)
2865 {
2866 uint loop_left = iter - loop_pos;
2867
2868 loop_left = MIN (loop_left, gpu_loops);
2869
2870 device_param->kernel_params_buf32[25] = loop_pos;
2871 device_param->kernel_params_buf32[26] = loop_left;
2872
2873 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2874
2875 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2876
2877 if (data.devices_status == STATUS_CRACKED) break;
2878 if (data.devices_status == STATUS_ABORTED) break;
2879 if (data.devices_status == STATUS_QUIT) break;
2880 }
2881
2882 if (data.opts_type & OPTS_TYPE_HOOK23)
2883 {
2884 run_kernel (KERN_RUN_23, device_param, pws_cnt);
2885
2886 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2887
2888 // do something with data
2889
2890 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2891 }
2892
2893 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2894 }
2895
2896 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2897
2898 if (data.devices_status == STATUS_CRACKED) break;
2899 if (data.devices_status == STATUS_ABORTED) break;
2900 if (data.devices_status == STATUS_QUIT) break;
2901
2902 /**
2903 * result
2904 */
2905
2906 hc_thread_mutex_lock (mux_display);
2907
2908 check_cracked (device_param, salt_pos);
2909
2910 hc_thread_mutex_unlock (mux_display);
2911
2912 /**
2913 * progress
2914 */
2915
2916 uint64_t perf_sum_all = (uint64_t) pw_cnt * (uint64_t) innerloop_left;
2917
2918 hc_thread_mutex_lock (mux_counter);
2919
2920 data.words_progress_done[salt_pos] += perf_sum_all;
2921
2922 hc_thread_mutex_unlock (mux_counter);
2923
2924 /**
2925 * speed
2926 */
2927
2928 float speed_ms;
2929
2930 hc_timer_get (device_param->timer_speed, speed_ms);
2931
2932 hc_timer_set (&device_param->timer_speed);
2933
2934 hc_thread_mutex_lock (mux_display);
2935
2936 device_param->speed_cnt[speed_pos] = perf_sum_all;
2937
2938 device_param->speed_ms[speed_pos] = speed_ms;
2939
2940 device_param->speed_rec[speed_pos] = device_param->timer_speed;
2941
2942 hc_thread_mutex_unlock (mux_display);
2943
2944 speed_pos++;
2945
2946 if (speed_pos == SPEED_CACHE)
2947 {
2948 speed_pos = 0;
2949 }
2950 }
2951 }
2952
2953 device_param->speed_pos = speed_pos;
2954 }
2955
2956 static void load_segment (wl_data_t *wl_data, FILE *fd)
2957 {
2958 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
2959
2960 wl_data->pos = 0;
2961
2962 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
2963
2964 wl_data->buf[wl_data->cnt] = 0;
2965
2966 if (wl_data->cnt == 0) return;
2967
2968 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
2969
2970 while (!feof (fd))
2971 {
2972 if (wl_data->cnt == wl_data->avail)
2973 {
2974 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
2975
2976 wl_data->avail += wl_data->incr;
2977 }
2978
2979 const int c = fgetc (fd);
2980
2981 if (c == EOF) break;
2982
2983 wl_data->buf[wl_data->cnt] = (char) c;
2984
2985 wl_data->cnt++;
2986
2987 if (c == '\n') break;
2988 }
2989
2990 // ensure stream ends with a newline
2991
2992 if (wl_data->buf[wl_data->cnt - 1] != '\n')
2993 {
2994 wl_data->cnt++;
2995
2996 wl_data->buf[wl_data->cnt - 1] = '\n';
2997 }
2998
2999 return;
3000 }
3001
3002 static void get_next_word_lm (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
3003 {
3004 char *ptr = buf;
3005
3006 for (uint32_t i = 0; i < sz; i++, ptr++)
3007 {
3008 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3009
3010 if (i == 7)
3011 {
3012 *off = i;
3013 *len = i;
3014
3015 return;
3016 }
3017
3018 if (*ptr != '\n') continue;
3019
3020 *off = i + 1;
3021
3022 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3023
3024 *len = i;
3025
3026 return;
3027 }
3028
3029 *off = sz;
3030 *len = sz;
3031 }
3032
3033 static void get_next_word_uc (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
3034 {
3035 char *ptr = buf;
3036
3037 for (uint32_t i = 0; i < sz; i++, ptr++)
3038 {
3039 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3040
3041 if (*ptr != '\n') continue;
3042
3043 *off = i + 1;
3044
3045 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3046
3047 *len = i;
3048
3049 return;
3050 }
3051
3052 *off = sz;
3053 *len = sz;
3054 }
3055
3056 static void get_next_word_std (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
3057 {
3058 char *ptr = buf;
3059
3060 for (uint32_t i = 0; i < sz; i++, ptr++)
3061 {
3062 if (*ptr != '\n') continue;
3063
3064 *off = i + 1;
3065
3066 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3067
3068 *len = i;
3069
3070 return;
3071 }
3072
3073 *off = sz;
3074 *len = sz;
3075 }
3076
3077 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3078 {
3079 while (wl_data->pos < wl_data->cnt)
3080 {
3081 uint off;
3082 uint len;
3083
3084 char *ptr = wl_data->buf + wl_data->pos;
3085
3086 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3087
3088 wl_data->pos += off;
3089
3090 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3091 {
3092 char rule_buf_out[BLOCK_SIZE];
3093
3094 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3095
3096 int rule_len_out = -1;
3097
3098 if (len < BLOCK_SIZE)
3099 {
3100 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3101 }
3102
3103 if (rule_len_out < 0)
3104 {
3105 continue;
3106 }
3107
3108 if (rule_len_out > PW_MAX)
3109 {
3110 continue;
3111 }
3112 }
3113 else
3114 {
3115 if (len > PW_MAX)
3116 {
3117 continue;
3118 }
3119 }
3120
3121 *out_buf = ptr;
3122 *out_len = len;
3123
3124 return;
3125 }
3126
3127 if (feof (fd))
3128 {
3129 fprintf (stderr, "bug!!\n");
3130
3131 return;
3132 }
3133
3134 load_segment (wl_data, fd);
3135
3136 get_next_word (wl_data, fd, out_buf, out_len);
3137 }
3138
3139 #ifdef _POSIX
3140 static uint64_t count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3141 #endif
3142
3143 #ifdef _WIN
3144 static uint64_t count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3145 #endif
3146 {
3147 hc_signal (NULL);
3148
3149 dictstat_t d;
3150
3151 d.cnt = 0;
3152
3153 #ifdef _POSIX
3154 fstat (fileno (fd), &d.stat);
3155 #endif
3156
3157 #ifdef _WIN
3158 _fstat64 (fileno (fd), &d.stat);
3159 #endif
3160
3161 d.stat.st_mode = 0;
3162 d.stat.st_nlink = 0;
3163 d.stat.st_uid = 0;
3164 d.stat.st_gid = 0;
3165 d.stat.st_rdev = 0;
3166 d.stat.st_atime = 0;
3167
3168 #ifdef _POSIX
3169 d.stat.st_blksize = 0;
3170 d.stat.st_blocks = 0;
3171 #endif
3172
3173 if (d.stat.st_size == 0) return 0;
3174
3175 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3176
3177 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3178 {
3179 if (d_cache)
3180 {
3181 uint64_t cnt = d_cache->cnt;
3182
3183 uint64_t keyspace = cnt;
3184
3185 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3186 {
3187 keyspace *= data.gpu_rules_cnt;
3188 }
3189 else if (data.attack_kern == ATTACK_KERN_COMBI)
3190 {
3191 keyspace *= data.combs_cnt;
3192 }
3193
3194 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);
3195 if (data.quiet == 0) log_info ("");
3196
3197 hc_signal (sigHandler_default);
3198
3199 return (keyspace);
3200 }
3201 }
3202
3203 time_t now = 0;
3204 time_t prev = 0;
3205
3206 uint64_t comp = 0;
3207 uint64_t cnt = 0;
3208 uint64_t cnt2 = 0;
3209
3210 while (!feof (fd))
3211 {
3212 load_segment (wl_data, fd);
3213
3214 comp += wl_data->cnt;
3215
3216 uint32_t i = 0;
3217
3218 while (i < wl_data->cnt)
3219 {
3220 uint32_t len;
3221 uint32_t off;
3222
3223 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3224
3225 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3226 {
3227 char rule_buf_out[BLOCK_SIZE];
3228
3229 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3230
3231 int rule_len_out = -1;
3232
3233 if (len < BLOCK_SIZE)
3234 {
3235 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3236 }
3237
3238 if (rule_len_out < 0)
3239 {
3240 len = PW_MAX1;
3241 }
3242 else
3243 {
3244 len = rule_len_out;
3245 }
3246 }
3247
3248 if (len < PW_MAX1)
3249 {
3250 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3251 {
3252 cnt += data.gpu_rules_cnt;
3253 }
3254 else if (data.attack_kern == ATTACK_KERN_COMBI)
3255 {
3256 cnt += data.combs_cnt;
3257 }
3258
3259 d.cnt++;
3260 }
3261
3262 i += off;
3263
3264 cnt2++;
3265 }
3266
3267 time (&now);
3268
3269 if ((now - prev) == 0) continue;
3270
3271 float percent = (float) comp / (float) d.stat.st_size;
3272
3273 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);
3274
3275 time (&prev);
3276 }
3277
3278 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);
3279 if (data.quiet == 0) log_info ("");
3280
3281 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3282
3283 hc_signal (sigHandler_default);
3284
3285 return (cnt);
3286 }
3287
3288 static void pw_transpose_to_hi1 (const pw_t *p1, pw_t *p2)
3289 {
3290 memcpy (p2->hi1, p1->hi1, 64 * sizeof (uint));
3291 }
3292
3293 static uint pw_add_to_hc1 (hc_device_param_t *device_param, const uint8_t *pw_buf, const uint pw_len)
3294 {
3295 if (data.devices_status == STATUS_BYPASS) return 0;
3296
3297 pw_cache_t *pw_cache = device_param->pw_caches + pw_len;
3298
3299 uint cache_cnt = pw_cache->cnt;
3300
3301 uint8_t *pw_hc1 = pw_cache->pw_buf.hc1[cache_cnt];
3302
3303 memcpy (pw_hc1, pw_buf, pw_len);
3304
3305 memset (pw_hc1 + pw_len, 0, 256 - pw_len);
3306
3307 uint pws_cnt = device_param->pws_cnt;
3308
3309 cache_cnt++;
3310
3311 pw_t *pw = device_param->pws_buf + pws_cnt;
3312
3313 device_param->pw_transpose (&pw_cache->pw_buf, pw);
3314
3315 pw->pw_len = pw_len;
3316
3317 pws_cnt++;
3318
3319 device_param->pws_cnt = pws_cnt;
3320 device_param->pw_cnt = pws_cnt * 1;
3321
3322 cache_cnt = 0;
3323
3324 pw_cache->cnt = cache_cnt;
3325
3326 return pws_cnt;
3327 }
3328
3329 static void *thread_monitor (void *p)
3330 {
3331 uint runtime_check = 0;
3332 uint remove_check = 0;
3333 uint status_check = 0;
3334 uint hwmon_check = 0;
3335 uint restore_check = 0;
3336
3337 uint restore_left = data.restore_timer;
3338 uint remove_left = data.remove_timer;
3339 uint status_left = data.status_timer;
3340
3341 // these variables are mainly used for fan control (AMD only)
3342
3343 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3344
3345 // temperature controller "loopback" values
3346
3347 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3348 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3349
3350 int temp_threshold = 1; // degrees celcius
3351
3352 int fan_speed_min = 15; // in percentage
3353 int fan_speed_max = 100;
3354
3355 time_t last_temp_check_time;
3356
3357 uint sleep_time = 1;
3358
3359 if (data.runtime)
3360 {
3361 runtime_check = 1;
3362 }
3363
3364 if (data.restore_timer)
3365 {
3366 restore_check = 1;
3367 }
3368
3369 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3370 {
3371 remove_check = 1;
3372 }
3373
3374 if (data.status == 1)
3375 {
3376 status_check = 1;
3377 }
3378
3379 if (data.gpu_temp_disable == 0)
3380 {
3381 time (&last_temp_check_time);
3382
3383 hwmon_check = 1;
3384 }
3385
3386 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (hwmon_check == 0) && (restore_check == 0))
3387 {
3388 return (p);
3389 }
3390
3391 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3392 {
3393 hc_sleep (sleep_time);
3394
3395 if (data.devices_status != STATUS_RUNNING) continue;
3396
3397 if (hwmon_check == 1)
3398 {
3399 hc_thread_mutex_lock (mux_adl);
3400
3401 time_t temp_check_time;
3402
3403 time (&temp_check_time);
3404
3405 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3406
3407 if (Ta == 0) Ta = 1;
3408
3409 for (uint i = 0; i < data.devices_cnt; i++)
3410 {
3411 const int temperature = hm_get_temperature_with_device_id (i);
3412
3413 if (temperature > (int) data.gpu_temp_abort)
3414 {
3415 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", i + 1);
3416
3417 if (data.devices_status != STATUS_QUIT) myabort ();
3418
3419 break;
3420 }
3421
3422 const int gpu_temp_retain = data.gpu_temp_retain;
3423
3424 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3425 {
3426 if (data.hm_device[i].fan_supported == 1)
3427 {
3428 int temp_cur = temperature;
3429
3430 int temp_diff_new = gpu_temp_retain - temp_cur;
3431
3432 temp_diff_sum[i] = temp_diff_sum[i] + temp_diff_new;
3433
3434 // calculate Ta value (time difference in seconds between the last check and this check)
3435
3436 last_temp_check_time = temp_check_time;
3437
3438 float Kp = 1.8;
3439 float Ki = 0.005;
3440 float Kd = 6;
3441
3442 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3443
3444 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);
3445
3446 if (abs (fan_diff_required) >= temp_threshold)
3447 {
3448 const int fan_speed_cur = hm_get_fanspeed_with_device_id (i);
3449
3450 int fan_speed_level = fan_speed_cur;
3451
3452 if (fan_speed_chgd[i] == 0) fan_speed_level = temp_cur;
3453
3454 int fan_speed_new = fan_speed_level - fan_diff_required;
3455
3456 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3457 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3458
3459 if (fan_speed_new != fan_speed_cur)
3460 {
3461 int freely_change_fan_speed = (fan_speed_chgd[i] == 1);
3462 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3463
3464 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3465 {
3466 hm_set_fanspeed_with_device_id_amd (i, fan_speed_new);
3467
3468 fan_speed_chgd[i] = 1;
3469 }
3470
3471 temp_diff_old[i] = temp_diff_new;
3472 }
3473 }
3474 }
3475 }
3476 }
3477
3478 hc_thread_mutex_unlock (mux_adl);
3479 }
3480
3481 if (restore_check == 1)
3482 {
3483 restore_left--;
3484
3485 if (restore_left == 0)
3486 {
3487 if (data.restore_disable == 0) cycle_restore ();
3488
3489 restore_left = data.restore_timer;
3490 }
3491 }
3492
3493 if ((runtime_check == 1) && (data.runtime_start > 0))
3494 {
3495 time_t runtime_cur;
3496
3497 time (&runtime_cur);
3498
3499 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3500
3501 if (runtime_left <= 0)
3502 {
3503 if (data.benchmark == 0)
3504 {
3505 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3506 }
3507
3508 if (data.devices_status != STATUS_QUIT) myabort ();
3509 }
3510 }
3511
3512 if (remove_check == 1)
3513 {
3514 remove_left--;
3515
3516 if (remove_left == 0)
3517 {
3518 if (data.digests_saved != data.digests_done)
3519 {
3520 data.digests_saved = data.digests_done;
3521
3522 save_hash ();
3523 }
3524
3525 remove_left = data.remove_timer;
3526 }
3527 }
3528
3529 if (status_check == 1)
3530 {
3531 status_left--;
3532
3533 if (status_left == 0)
3534 {
3535 hc_thread_mutex_lock (mux_display);
3536
3537 if (data.quiet == 0) clear_prompt ();
3538
3539 if (data.quiet == 0) log_info ("");
3540
3541 status_display ();
3542
3543 if (data.quiet == 0) log_info ("");
3544
3545 hc_thread_mutex_unlock (mux_display);
3546
3547 status_left = data.status_timer;
3548 }
3549 }
3550 }
3551
3552 myfree (fan_speed_chgd);
3553
3554 myfree (temp_diff_old);
3555 myfree (temp_diff_sum);
3556
3557 p = NULL;
3558
3559 return (p);
3560 }
3561
3562 static void *thread_outfile_remove (void *p)
3563 {
3564 // some hash-dependent constants
3565 char *outfile_dir = data.outfile_check_directory;
3566 uint dgst_size = data.dgst_size;
3567 uint isSalted = data.isSalted;
3568 uint esalt_size = data.esalt_size;
3569 uint hash_mode = data.hash_mode;
3570
3571 uint outfile_check_timer = data.outfile_check_timer;
3572
3573 char separator = data.separator;
3574
3575 // some hash-dependent functions
3576 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3577 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3578
3579 // buffers
3580 hash_t hash_buf;
3581
3582 memset (&hash_buf, 0, sizeof (hash_buf));
3583
3584 hash_buf.digest = mymalloc (dgst_size);
3585
3586 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3587
3588 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3589
3590 uint digest_buf[64];
3591
3592 outfile_data_t *out_info = NULL;
3593
3594 char **out_files = NULL;
3595
3596 time_t folder_mtime = 0;
3597
3598 int out_cnt = 0;
3599
3600 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3601
3602 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3603 {
3604 hc_sleep (1);
3605
3606 if (data.devices_status != STATUS_RUNNING) continue;
3607
3608 check_left--;
3609
3610 if (check_left == 0)
3611 {
3612 struct stat outfile_check_stat;
3613
3614 if (stat (outfile_dir, &outfile_check_stat) == 0)
3615 {
3616 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3617
3618 if (is_dir == 1)
3619 {
3620 if (outfile_check_stat.st_mtime > folder_mtime)
3621 {
3622 char **out_files_new = scan_directory (outfile_dir);
3623
3624 int out_cnt_new = count_dictionaries (out_files_new);
3625
3626 outfile_data_t *out_info_new = NULL;
3627
3628 if (out_cnt_new > 0)
3629 {
3630 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3631
3632 for (int i = 0; i < out_cnt_new; i++)
3633 {
3634 out_info_new[i].file_name = out_files_new[i];
3635
3636 // check if there are files that we have seen/checked before (and not changed)
3637
3638 for (int j = 0; j < out_cnt; j++)
3639 {
3640 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
3641 {
3642 struct stat outfile_stat;
3643
3644 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
3645 {
3646 if (outfile_stat.st_ctime == out_info[j].ctime)
3647 {
3648 out_info_new[i].ctime = out_info[j].ctime;
3649 out_info_new[i].seek = out_info[j].seek;
3650 }
3651 }
3652 }
3653 }
3654 }
3655 }
3656
3657 local_free (out_info);
3658 local_free (out_files);
3659
3660 out_files = out_files_new;
3661 out_cnt = out_cnt_new;
3662 out_info = out_info_new;
3663
3664 folder_mtime = outfile_check_stat.st_mtime;
3665 }
3666
3667 for (int j = 0; j < out_cnt; j++)
3668 {
3669 FILE *fp = fopen (out_info[j].file_name, "rb");
3670
3671 if (fp != NULL)
3672 {
3673 //hc_thread_mutex_lock (mux_display);
3674
3675 #ifdef _POSIX
3676 struct stat outfile_stat;
3677
3678 fstat (fileno (fp), &outfile_stat);
3679 #endif
3680
3681 #ifdef _WIN
3682 struct stat64 outfile_stat;
3683
3684 _fstat64 (fileno (fp), &outfile_stat);
3685 #endif
3686
3687 if (outfile_stat.st_ctime > out_info[j].ctime)
3688 {
3689 out_info[j].ctime = outfile_stat.st_ctime;
3690 out_info[j].seek = 0;
3691 }
3692
3693 fseek (fp, out_info[j].seek, SEEK_SET);
3694
3695 while (!feof (fp))
3696 {
3697 char line_buf[BUFSIZ];
3698
3699 memset (line_buf, 0, BUFSIZ);
3700
3701 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
3702
3703 if (ptr == NULL) break;
3704
3705 int line_len = strlen (line_buf);
3706
3707 if (line_len <= 0) continue;
3708
3709 int iter = MAX_CUT_TRIES;
3710
3711 for (uint i = line_len - 1; i && iter; i--, line_len--)
3712 {
3713 if (line_buf[i] != separator) continue;
3714
3715 int parser_status = PARSER_OK;
3716
3717 if ((hash_mode != 2500) && (hash_mode != 6800))
3718 {
3719 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
3720 }
3721
3722 uint found = 0;
3723
3724 if (parser_status == PARSER_OK)
3725 {
3726 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
3727 {
3728 if (data.salts_shown[salt_pos] == 1) continue;
3729
3730 salt_t *salt_buf = &data.salts_buf[salt_pos];
3731
3732 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
3733 {
3734 uint idx = salt_buf->digests_offset + digest_pos;
3735
3736 if (data.digests_shown[idx] == 1) continue;
3737
3738 uint cracked = 0;
3739
3740 if (hash_mode == 6800)
3741 {
3742 if (i == salt_buf->salt_len)
3743 {
3744 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3745 }
3746 }
3747 else if (hash_mode == 2500)
3748 {
3749 // BSSID : MAC1 : MAC2 (:plain)
3750 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
3751 {
3752 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3753
3754 if (!cracked) continue;
3755
3756 // now compare MAC1 and MAC2 too, since we have this additional info
3757 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
3758 char *mac2_pos = mac1_pos + 12 + 1;
3759
3760 wpa_t *wpas = (wpa_t *) data.esalts_buf;
3761 wpa_t *wpa = &wpas[salt_pos];
3762
3763 uint pke[25];
3764
3765 char *pke_ptr = (char *) pke;
3766
3767 for (uint i = 0; i < 25; i++)
3768 {
3769 pke[i] = byte_swap_32 (wpa->pke[i]);
3770 }
3771
3772 unsigned char mac1[6];
3773 unsigned char mac2[6];
3774
3775 memcpy (mac1, pke_ptr + 23, 6);
3776 memcpy (mac2, pke_ptr + 29, 6);
3777
3778 // compare hex string(s) vs binary MAC address(es)
3779
3780 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3781 {
3782 if (mac1[i] != (unsigned char) hex_to_char (&mac1_pos[j]))
3783 {
3784 cracked = 0;
3785 break;
3786 }
3787 }
3788
3789 // early skip ;)
3790 if (!cracked) continue;
3791
3792 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3793 {
3794 if (mac2[i] != (unsigned char) hex_to_char (&mac2_pos[j]))
3795 {
3796 cracked = 0;
3797 break;
3798 }
3799 }
3800 }
3801 }
3802 else
3803 {
3804 char *digests_buf_ptr = (char *) data.digests_buf;
3805
3806 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
3807
3808 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
3809 }
3810
3811 if (cracked == 1)
3812 {
3813 found = 1;
3814
3815 data.digests_shown[idx] = 1;
3816
3817 data.digests_done++;
3818
3819 salt_buf->digests_done++;
3820
3821 if (salt_buf->digests_done == salt_buf->digests_cnt)
3822 {
3823 data.salts_shown[salt_pos] = 1;
3824
3825 data.salts_done++;
3826
3827 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
3828 }
3829 }
3830 }
3831
3832 if (data.devices_status == STATUS_CRACKED) break;
3833 }
3834 }
3835
3836 if (found) break;
3837
3838 if (data.devices_status == STATUS_CRACKED) break;
3839
3840 iter--;
3841 }
3842
3843 if (data.devices_status == STATUS_CRACKED) break;
3844 }
3845
3846 out_info[j].seek = ftell (fp);
3847
3848 //hc_thread_mutex_unlock (mux_display);
3849
3850 fclose (fp);
3851 }
3852 }
3853 }
3854 }
3855
3856 check_left = outfile_check_timer;
3857 }
3858 }
3859
3860 if (esalt_size) local_free (hash_buf.esalt);
3861
3862 if (isSalted) local_free (hash_buf.salt);
3863
3864 local_free (hash_buf.digest);
3865
3866 local_free (out_info);
3867
3868 local_free (out_files);
3869
3870 p = NULL;
3871
3872 return (p);
3873 }
3874
3875 static uint get_work (hc_device_param_t *device_param, const uint64_t max)
3876 {
3877 hc_thread_mutex_lock (mux_dispatcher);
3878
3879 const uint64_t words_cur = data.words_cur;
3880 const uint64_t words_base = (data.limit == 0) ? data.words_base : data.limit;
3881
3882 device_param->words_off = words_cur;
3883
3884 const uint64_t words_left = words_base - words_cur;
3885
3886 if (data.gpu_blocks_all > words_left)
3887 {
3888 if (data.gpu_blocks_div == 0)
3889 {
3890 data.gpu_blocks_div = find_gpu_blocks_div (words_left, data.gpu_blocks_all);
3891 }
3892 }
3893
3894 if (data.gpu_blocks_div)
3895 {
3896 if (device_param->gpu_blocks == device_param->gpu_blocks_user)
3897 {
3898 const uint32_t gpu_blocks_new = (float) device_param->gpu_blocks * data.gpu_blocks_div;
3899 const uint32_t gpu_power_new = gpu_blocks_new;
3900
3901 if (gpu_blocks_new < device_param->gpu_blocks)
3902 {
3903 device_param->gpu_blocks = gpu_blocks_new;
3904 device_param->gpu_power = gpu_power_new;
3905 }
3906 }
3907 }
3908
3909 const uint gpu_blocks = device_param->gpu_blocks;
3910
3911 uint work = MIN (words_left, gpu_blocks);
3912
3913 work = MIN (work, max);
3914
3915 data.words_cur += work;
3916
3917 hc_thread_mutex_unlock (mux_dispatcher);
3918
3919 return work;
3920 }
3921
3922 static void *thread_calc_stdin (void *p)
3923 {
3924 hc_device_param_t *device_param = (hc_device_param_t *) p;
3925
3926 const uint attack_kern = data.attack_kern;
3927
3928 const uint gpu_blocks = device_param->gpu_blocks;
3929
3930 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3931 {
3932 hc_thread_mutex_lock (mux_dispatcher);
3933
3934 if (feof (stdin) != 0)
3935 {
3936 hc_thread_mutex_unlock (mux_dispatcher);
3937
3938 break;
3939 }
3940
3941 uint words_cur = 0;
3942
3943 while (words_cur < gpu_blocks)
3944 {
3945 char buf[BUFSIZ];
3946
3947 char *line_buf = fgets (buf, sizeof (buf), stdin);
3948
3949 if (line_buf == NULL) break;
3950
3951 uint line_len = in_superchop (line_buf);
3952
3953 line_len = convert_from_hex (line_buf, line_len);
3954
3955 // post-process rule engine
3956
3957 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3958 {
3959 char rule_buf_out[BLOCK_SIZE];
3960
3961 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3962
3963 int rule_len_out = -1;
3964
3965 if (line_len < BLOCK_SIZE)
3966 {
3967 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
3968 }
3969
3970 if (rule_len_out < 0) continue;
3971
3972 line_buf = rule_buf_out;
3973 line_len = rule_len_out;
3974 }
3975
3976 if (line_len > PW_MAX)
3977 {
3978 continue;
3979 }
3980
3981 if (attack_kern == ATTACK_KERN_STRAIGHT)
3982 {
3983 if ((line_len < data.pw_min) || (line_len > data.pw_max))
3984 {
3985 hc_thread_mutex_lock (mux_counter);
3986
3987 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3988 {
3989 data.words_progress_rejected[salt_pos] += data.gpu_rules_cnt;
3990 }
3991
3992 hc_thread_mutex_unlock (mux_counter);
3993
3994 continue;
3995 }
3996 }
3997 else if (attack_kern == ATTACK_KERN_COMBI)
3998 {
3999 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4000 // since we still need to combine the plains
4001
4002 if (line_len > data.pw_max)
4003 {
4004 hc_thread_mutex_lock (mux_counter);
4005
4006 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4007 {
4008 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4009 }
4010
4011 hc_thread_mutex_unlock (mux_counter);
4012
4013 continue;
4014 }
4015 }
4016
4017 device_param->pw_add (device_param, (uint8_t *) line_buf, line_len);
4018
4019 words_cur++;
4020
4021 if (data.devices_status == STATUS_CRACKED) break;
4022 if (data.devices_status == STATUS_ABORTED) break;
4023 if (data.devices_status == STATUS_QUIT) break;
4024 if (data.devices_status == STATUS_BYPASS) break;
4025 }
4026
4027 hc_thread_mutex_unlock (mux_dispatcher);
4028
4029 if (data.devices_status == STATUS_CRACKED) break;
4030 if (data.devices_status == STATUS_ABORTED) break;
4031 if (data.devices_status == STATUS_QUIT) break;
4032 if (data.devices_status == STATUS_BYPASS) break;
4033
4034 // we need 2 flushing because we have two independant caches and it can occur
4035 // that one buffer is already at threshold plus for that length also exists
4036 // more data in the 2nd buffer so it would overflow
4037
4038 // flush session 1
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 if (pws_cnt == device_param->gpu_power_user) break;
4070 }
4071
4072 const uint pw_cnt = device_param->pw_cnt;
4073 const uint pws_cnt = device_param->pws_cnt;
4074
4075 if (pws_cnt)
4076 {
4077 run_copy (device_param, pws_cnt);
4078
4079 run_cracker (device_param, pw_cnt, pws_cnt);
4080
4081 device_param->pw_cnt = 0;
4082 device_param->pws_cnt = 0;
4083 }
4084 }
4085
4086 // flush session 2
4087
4088 {
4089 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4090 {
4091 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4092
4093 const uint pw_cache_cnt = pw_cache->cnt;
4094
4095 if (pw_cache_cnt == 0) continue;
4096
4097 pw_cache->cnt = 0;
4098
4099 uint pws_cnt = device_param->pws_cnt;
4100
4101 pw_t *pw = device_param->pws_buf + pws_cnt;
4102
4103 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4104
4105 pw->pw_len = pw_len;
4106
4107 uint pw_cnt = device_param->pw_cnt;
4108
4109 pw_cnt += pw_cache_cnt;
4110
4111 device_param->pw_cnt = pw_cnt;
4112
4113 pws_cnt++;
4114
4115 device_param->pws_cnt = pws_cnt;
4116 }
4117
4118 const uint pw_cnt = device_param->pw_cnt;
4119 const uint pws_cnt = device_param->pws_cnt;
4120
4121 if (pws_cnt)
4122 {
4123 run_copy (device_param, pws_cnt);
4124
4125 run_cracker (device_param, pw_cnt, pws_cnt);
4126
4127 device_param->pw_cnt = 0;
4128 device_param->pws_cnt = 0;
4129 }
4130 }
4131 }
4132
4133 return NULL;
4134 }
4135
4136 static void *thread_calc (void *p)
4137 {
4138 hc_device_param_t *device_param = (hc_device_param_t *) p;
4139
4140 const uint attack_mode = data.attack_mode;
4141 const uint attack_kern = data.attack_kern;
4142
4143 if (attack_mode == ATTACK_MODE_BF)
4144 {
4145 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4146 {
4147 const uint work = get_work (device_param, -1);
4148
4149 if (work == 0) break;
4150
4151 const uint64_t words_off = device_param->words_off;
4152 const uint64_t words_fin = words_off + work;
4153
4154 const uint pw_cnt = work;
4155 const uint pws_cnt = work;
4156
4157 device_param->pw_cnt = pw_cnt;
4158 device_param->pws_cnt = pws_cnt;
4159
4160 if (pws_cnt)
4161 {
4162 run_copy (device_param, pws_cnt);
4163
4164 run_cracker (device_param, pw_cnt, pws_cnt);
4165
4166 device_param->pw_cnt = 0;
4167 device_param->pws_cnt = 0;
4168 }
4169
4170 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4171
4172 if (data.devices_status == STATUS_CRACKED) break;
4173 if (data.devices_status == STATUS_ABORTED) break;
4174 if (data.devices_status == STATUS_QUIT) break;
4175 if (data.devices_status == STATUS_BYPASS) break;
4176
4177 device_param->words_done = words_fin;
4178 }
4179 }
4180 else
4181 {
4182 const uint segment_size = data.segment_size;
4183
4184 char *dictfile = data.dictfile;
4185
4186 if (attack_mode == ATTACK_MODE_COMBI)
4187 {
4188 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4189 {
4190 dictfile = data.dictfile2;
4191 }
4192 }
4193
4194 FILE *fd = fopen (dictfile, "rb");
4195
4196 if (fd == NULL)
4197 {
4198 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4199
4200 return NULL;
4201 }
4202
4203 if (attack_mode == ATTACK_MODE_COMBI)
4204 {
4205 const uint combs_mode = data.combs_mode;
4206
4207 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4208 {
4209 const char *dictfilec = data.dictfile2;
4210
4211 FILE *combs_fp = fopen (dictfilec, "rb");
4212
4213 if (combs_fp == NULL)
4214 {
4215 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4216
4217 fclose (fd);
4218
4219 return NULL;
4220 }
4221
4222 device_param->combs_fp = combs_fp;
4223 }
4224 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4225 {
4226 const char *dictfilec = data.dictfile;
4227
4228 FILE *combs_fp = fopen (dictfilec, "rb");
4229
4230 if (combs_fp == NULL)
4231 {
4232 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4233
4234 fclose (fd);
4235
4236 return NULL;
4237 }
4238
4239 device_param->combs_fp = combs_fp;
4240 }
4241 }
4242
4243 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4244
4245 wl_data->buf = (char *) mymalloc (segment_size);
4246 wl_data->avail = segment_size;
4247 wl_data->incr = segment_size;
4248 wl_data->cnt = 0;
4249 wl_data->pos = 0;
4250
4251 uint64_t words_cur = 0;
4252
4253 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4254 {
4255 uint64_t words_off = 0;
4256 uint64_t words_fin = 0;
4257
4258 uint64_t max = -1;
4259
4260 while (max)
4261 {
4262 const uint work = get_work (device_param, max);
4263
4264 if (work == 0) break;
4265
4266 words_off = device_param->words_off;
4267 words_fin = words_off + work;
4268
4269 char *line_buf;
4270 uint line_len;
4271
4272 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4273
4274 max = 0;
4275
4276 for ( ; words_cur < words_fin; words_cur++)
4277 {
4278 get_next_word (wl_data, fd, &line_buf, &line_len);
4279
4280 line_len = convert_from_hex (line_buf, line_len);
4281
4282 // post-process rule engine
4283
4284 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4285 {
4286 char rule_buf_out[BLOCK_SIZE];
4287
4288 memset (rule_buf_out, 0, sizeof (rule_buf_out));
4289
4290 int rule_len_out = -1;
4291
4292 if (line_len < BLOCK_SIZE)
4293 {
4294 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4295 }
4296
4297 if (rule_len_out < 0) continue;
4298
4299 line_buf = rule_buf_out;
4300 line_len = rule_len_out;
4301 }
4302
4303 if (attack_kern == ATTACK_KERN_STRAIGHT)
4304 {
4305 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4306 {
4307 max++;
4308
4309 hc_thread_mutex_lock (mux_counter);
4310
4311 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4312 {
4313 data.words_progress_rejected[salt_pos] += data.gpu_rules_cnt;
4314 }
4315
4316 hc_thread_mutex_unlock (mux_counter);
4317
4318 continue;
4319 }
4320 }
4321 else if (attack_kern == ATTACK_KERN_COMBI)
4322 {
4323 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4324 // since we still need to combine the plains
4325
4326 if (line_len > data.pw_max)
4327 {
4328 max++;
4329
4330 hc_thread_mutex_lock (mux_counter);
4331
4332 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4333 {
4334 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4335 }
4336
4337 hc_thread_mutex_unlock (mux_counter);
4338
4339 continue;
4340 }
4341 }
4342
4343 device_param->pw_add (device_param, (uint8_t *) line_buf, line_len);
4344
4345 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4346
4347 if (data.devices_status == STATUS_CRACKED) break;
4348 if (data.devices_status == STATUS_ABORTED) break;
4349 if (data.devices_status == STATUS_QUIT) break;
4350 if (data.devices_status == STATUS_BYPASS) break;
4351 }
4352
4353 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4354
4355 if (data.devices_status == STATUS_CRACKED) break;
4356 if (data.devices_status == STATUS_ABORTED) break;
4357 if (data.devices_status == STATUS_QUIT) break;
4358 if (data.devices_status == STATUS_BYPASS) break;
4359 }
4360
4361 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4362
4363 if (data.devices_status == STATUS_CRACKED) break;
4364 if (data.devices_status == STATUS_ABORTED) break;
4365 if (data.devices_status == STATUS_QUIT) break;
4366 if (data.devices_status == STATUS_BYPASS) break;
4367
4368 // we need 2 flushing because we have two independant caches and it can occur
4369 // that one buffer is already at threshold plus for that length also exists
4370 // more data in the 2nd buffer so it would overflow
4371
4372 //
4373 // flush session 1
4374 //
4375
4376 {
4377 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4378 {
4379 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4380
4381 const uint pw_cache_cnt = pw_cache->cnt;
4382
4383 if (pw_cache_cnt == 0) continue;
4384
4385 pw_cache->cnt = 0;
4386
4387 uint pws_cnt = device_param->pws_cnt;
4388
4389 pw_t *pw = device_param->pws_buf + pws_cnt;
4390
4391 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4392
4393 pw->pw_len = pw_len;
4394
4395 uint pw_cnt = device_param->pw_cnt;
4396
4397 pw_cnt += pw_cache_cnt;
4398
4399 device_param->pw_cnt = pw_cnt;
4400
4401 pws_cnt++;
4402
4403 device_param->pws_cnt = pws_cnt;
4404
4405 if (pws_cnt == device_param->gpu_power_user) break;
4406 }
4407
4408 const uint pw_cnt = device_param->pw_cnt;
4409 const uint pws_cnt = device_param->pws_cnt;
4410
4411 if (pws_cnt)
4412 {
4413 run_copy (device_param, pws_cnt);
4414
4415 run_cracker (device_param, pw_cnt, pws_cnt);
4416
4417 device_param->pw_cnt = 0;
4418 device_param->pws_cnt = 0;
4419 }
4420
4421 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4422
4423 if (data.devices_status == STATUS_CRACKED) break;
4424 if (data.devices_status == STATUS_ABORTED) break;
4425 if (data.devices_status == STATUS_QUIT) break;
4426 if (data.devices_status == STATUS_BYPASS) break;
4427 }
4428
4429 //
4430 // flush session 2
4431 //
4432
4433 {
4434 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4435 {
4436 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4437
4438 const uint pw_cache_cnt = pw_cache->cnt;
4439
4440 if (pw_cache_cnt == 0) continue;
4441
4442 pw_cache->cnt = 0;
4443
4444 uint pws_cnt = device_param->pws_cnt;
4445
4446 pw_t *pw = device_param->pws_buf + pws_cnt;
4447
4448 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4449
4450 pw->pw_len = pw_len;
4451
4452 uint pw_cnt = device_param->pw_cnt;
4453
4454 pw_cnt += pw_cache_cnt;
4455
4456 device_param->pw_cnt = pw_cnt;
4457
4458 pws_cnt++;
4459
4460 device_param->pws_cnt = pws_cnt;
4461 }
4462
4463 const uint pw_cnt = device_param->pw_cnt;
4464 const uint pws_cnt = device_param->pws_cnt;
4465
4466 if (pws_cnt)
4467 {
4468 run_copy (device_param, pws_cnt);
4469
4470 run_cracker (device_param, pw_cnt, pws_cnt);
4471
4472 device_param->pw_cnt = 0;
4473 device_param->pws_cnt = 0;
4474 }
4475
4476 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4477
4478 if (data.devices_status == STATUS_CRACKED) break;
4479 if (data.devices_status == STATUS_ABORTED) break;
4480 if (data.devices_status == STATUS_QUIT) break;
4481 if (data.devices_status == STATUS_BYPASS) break;
4482 }
4483
4484 if (words_fin == 0) break;
4485
4486 device_param->words_done = words_fin;
4487 }
4488
4489 if (attack_mode == ATTACK_MODE_COMBI)
4490 {
4491 fclose (device_param->combs_fp);
4492 }
4493
4494 free (wl_data->buf);
4495 free (wl_data);
4496
4497 fclose (fd);
4498 }
4499
4500 return NULL;
4501 }
4502
4503 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos, const uint gpu_loops)
4504 {
4505 salt_t *salt_buf = &data.salts_buf[salt_pos];
4506
4507 device_param->kernel_params_buf32[24] = salt_pos;
4508 device_param->kernel_params_buf32[27] = 1;
4509 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4510 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4511 device_param->kernel_params_buf32[30] = 0;
4512 device_param->kernel_params_buf32[31] = 1;
4513
4514 char *dictfile_old = data.dictfile;
4515 char *dictfile2_old = data.dictfile2;
4516 char *mask_old = data.mask;
4517
4518 const char *weak_hash_check = "weak-hash-check";
4519
4520 data.dictfile = (char *) weak_hash_check;
4521 data.dictfile2 = (char *) weak_hash_check;
4522 data.mask = (char *) weak_hash_check;
4523
4524 /**
4525 * run the kernel
4526 */
4527
4528 if (data.attack_exec == ATTACK_EXEC_ON_GPU)
4529 {
4530 run_kernel (KERN_RUN_1, device_param, 1);
4531 }
4532 else
4533 {
4534 run_kernel (KERN_RUN_1, device_param, 1);
4535
4536 const uint iter = salt_buf->salt_iter;
4537
4538 for (uint loop_pos = 0; loop_pos < iter; loop_pos += gpu_loops)
4539 {
4540 uint loop_left = iter - loop_pos;
4541
4542 loop_left = MIN (loop_left, gpu_loops);
4543
4544 device_param->kernel_params_buf32[25] = loop_pos;
4545 device_param->kernel_params_buf32[26] = loop_left;
4546
4547 run_kernel (KERN_RUN_2, device_param, 1);
4548 }
4549
4550 run_kernel (KERN_RUN_3, device_param, 1);
4551 }
4552
4553 /**
4554 * result
4555 */
4556
4557 check_cracked (device_param, salt_pos);
4558
4559 /**
4560 * cleanup
4561 */
4562
4563 device_param->kernel_params_buf32[24] = 0;
4564 device_param->kernel_params_buf32[25] = 0;
4565 device_param->kernel_params_buf32[26] = 0;
4566 device_param->kernel_params_buf32[27] = 0;
4567 device_param->kernel_params_buf32[28] = 0;
4568 device_param->kernel_params_buf32[29] = 0;
4569 device_param->kernel_params_buf32[30] = 0;
4570 device_param->kernel_params_buf32[31] = 0;
4571
4572 data.dictfile = dictfile_old;
4573 data.dictfile2 = dictfile2_old;
4574 data.mask = mask_old;
4575 }
4576
4577 // hlfmt hashcat
4578
4579 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4580 {
4581 if (data.username == 0)
4582 {
4583 *hashbuf_pos = line_buf;
4584 *hashbuf_len = line_len;
4585 }
4586 else
4587 {
4588 char *pos = line_buf;
4589 int len = line_len;
4590
4591 for (int i = 0; i < line_len; i++, pos++, len--)
4592 {
4593 if (line_buf[i] == data.separator)
4594 {
4595 pos++;
4596
4597 len--;
4598
4599 break;
4600 }
4601 }
4602
4603 *hashbuf_pos = pos;
4604 *hashbuf_len = len;
4605 }
4606 }
4607
4608 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4609 {
4610 char *pos = NULL;
4611 int len = 0;
4612
4613 int sep_cnt = 0;
4614
4615 for (int i = 0; i < line_len; i++)
4616 {
4617 if (line_buf[i] == data.separator)
4618 {
4619 sep_cnt++;
4620
4621 continue;
4622 }
4623
4624 if (sep_cnt == 0)
4625 {
4626 if (pos == NULL) pos = line_buf + i;
4627
4628 len++;
4629 }
4630 }
4631
4632 *userbuf_pos = pos;
4633 *userbuf_len = len;
4634 }
4635
4636 // hlfmt pwdump
4637
4638 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
4639 {
4640 int sep_cnt = 0;
4641
4642 int sep2_len = 0;
4643 int sep3_len = 0;
4644
4645 for (int i = 0; i < line_len; i++)
4646 {
4647 if (line_buf[i] == ':')
4648 {
4649 sep_cnt++;
4650
4651 continue;
4652 }
4653
4654 if (sep_cnt == 2) sep2_len++;
4655 if (sep_cnt == 3) sep3_len++;
4656 }
4657
4658 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4659
4660 return 0;
4661 }
4662
4663 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4664 {
4665 char *pos = NULL;
4666 int len = 0;
4667
4668 int sep_cnt = 0;
4669
4670 for (int i = 0; i < line_len; i++)
4671 {
4672 if (line_buf[i] == ':')
4673 {
4674 sep_cnt++;
4675
4676 continue;
4677 }
4678
4679 if (data.hash_mode == 1000)
4680 {
4681 if (sep_cnt == 3)
4682 {
4683 if (pos == NULL) pos = line_buf + i;
4684
4685 len++;
4686 }
4687 }
4688 else if (data.hash_mode == 3000)
4689 {
4690 if (sep_cnt == 2)
4691 {
4692 if (pos == NULL) pos = line_buf + i;
4693
4694 len++;
4695 }
4696 }
4697 }
4698
4699 *hashbuf_pos = pos;
4700 *hashbuf_len = len;
4701 }
4702
4703 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4704 {
4705 char *pos = NULL;
4706 int len = 0;
4707
4708 int sep_cnt = 0;
4709
4710 for (int i = 0; i < line_len; i++)
4711 {
4712 if (line_buf[i] == ':')
4713 {
4714 sep_cnt++;
4715
4716 continue;
4717 }
4718
4719 if (sep_cnt == 0)
4720 {
4721 if (pos == NULL) pos = line_buf + i;
4722
4723 len++;
4724 }
4725 }
4726
4727 *userbuf_pos = pos;
4728 *userbuf_len = len;
4729 }
4730
4731 // hlfmt passwd
4732
4733 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
4734 {
4735 int sep_cnt = 0;
4736
4737 char sep5_first = 0;
4738 char sep6_first = 0;
4739
4740 for (int i = 0; i < line_len; i++)
4741 {
4742 if (line_buf[i] == ':')
4743 {
4744 sep_cnt++;
4745
4746 continue;
4747 }
4748
4749 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
4750 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
4751 }
4752
4753 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
4754
4755 return 0;
4756 }
4757
4758 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4759 {
4760 char *pos = NULL;
4761 int len = 0;
4762
4763 int sep_cnt = 0;
4764
4765 for (int i = 0; i < line_len; i++)
4766 {
4767 if (line_buf[i] == ':')
4768 {
4769 sep_cnt++;
4770
4771 continue;
4772 }
4773
4774 if (sep_cnt == 1)
4775 {
4776 if (pos == NULL) pos = line_buf + i;
4777
4778 len++;
4779 }
4780 }
4781
4782 *hashbuf_pos = pos;
4783 *hashbuf_len = len;
4784 }
4785
4786 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4787 {
4788 char *pos = NULL;
4789 int len = 0;
4790
4791 int sep_cnt = 0;
4792
4793 for (int i = 0; i < line_len; i++)
4794 {
4795 if (line_buf[i] == ':')
4796 {
4797 sep_cnt++;
4798
4799 continue;
4800 }
4801
4802 if (sep_cnt == 0)
4803 {
4804 if (pos == NULL) pos = line_buf + i;
4805
4806 len++;
4807 }
4808 }
4809
4810 *userbuf_pos = pos;
4811 *userbuf_len = len;
4812 }
4813
4814 // hlfmt shadow
4815
4816 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
4817 {
4818 int sep_cnt = 0;
4819
4820 for (int i = 0; i < line_len; i++)
4821 {
4822 if (line_buf[i] == ':') sep_cnt++;
4823 }
4824
4825 if (sep_cnt == 8) return 1;
4826
4827 return 0;
4828 }
4829
4830 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4831 {
4832 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
4833 }
4834
4835 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4836 {
4837 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
4838 }
4839
4840 // hlfmt main
4841
4842 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4843 {
4844 switch (hashfile_format)
4845 {
4846 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4847 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4848 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4849 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4850 }
4851 }
4852
4853 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4854 {
4855 switch (hashfile_format)
4856 {
4857 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
4858 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
4859 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
4860 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
4861 }
4862 }
4863
4864 static uint hlfmt_detect (FILE *fp, uint max_check)
4865 {
4866 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
4867
4868 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
4869 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
4870
4871 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
4872
4873 uint num_check = 0;
4874
4875 while (!feof (fp))
4876 {
4877 char line_buf[BUFSIZ];
4878
4879 int line_len = fgetl (fp, line_buf);
4880
4881 if (line_len == 0) continue;
4882
4883 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
4884 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
4885 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
4886
4887 if (num_check == max_check) break;
4888
4889 num_check++;
4890 }
4891
4892 uint hashlist_format = HLFMT_HASHCAT;
4893
4894 for (int i = 1; i < HLFMTS_CNT; i++)
4895 {
4896 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
4897
4898 hashlist_format = i;
4899 }
4900
4901 free (formats_cnt);
4902
4903 return hashlist_format;
4904 }
4905
4906 /**
4907 * some further helper function
4908 */
4909
4910 // wrapper around mymalloc for ADL
4911
4912 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
4913 {
4914 return mymalloc (iSize);
4915 }
4916
4917 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)
4918 {
4919 uint64_t collisions = 0;
4920
4921 const uint dgst_pos0 = data.dgst_pos0;
4922 const uint dgst_pos1 = data.dgst_pos1;
4923 const uint dgst_pos2 = data.dgst_pos2;
4924 const uint dgst_pos3 = data.dgst_pos3;
4925
4926 memset (bitmap_a, 0, bitmap_size);
4927 memset (bitmap_b, 0, bitmap_size);
4928 memset (bitmap_c, 0, bitmap_size);
4929 memset (bitmap_d, 0, bitmap_size);
4930
4931 for (uint i = 0; i < digests_cnt; i++)
4932 {
4933 uint *digest_ptr = (uint *) digests_buf_ptr;
4934
4935 digests_buf_ptr += dgst_size;
4936
4937 const uint val0 = 1 << (digest_ptr[dgst_pos0] & 0x1f);
4938 const uint val1 = 1 << (digest_ptr[dgst_pos1] & 0x1f);
4939 const uint val2 = 1 << (digest_ptr[dgst_pos2] & 0x1f);
4940 const uint val3 = 1 << (digest_ptr[dgst_pos3] & 0x1f);
4941
4942 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
4943 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
4944 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
4945 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
4946
4947 if (bitmap_a[idx0] & val0) collisions++;
4948 if (bitmap_b[idx1] & val1) collisions++;
4949 if (bitmap_c[idx2] & val2) collisions++;
4950 if (bitmap_d[idx3] & val3) collisions++;
4951
4952 bitmap_a[idx0] |= val0;
4953 bitmap_b[idx1] |= val1;
4954 bitmap_c[idx2] |= val2;
4955 bitmap_d[idx3] |= val3;
4956
4957 if (collisions >= collisions_max) return 0x7fffffff;
4958 }
4959
4960 return collisions;
4961 }
4962
4963 /**
4964 * main
4965 */
4966
4967 int main (int argc, char **argv)
4968 {
4969 /**
4970 * To help users a bit
4971 */
4972
4973 char *compute = getenv ("COMPUTE");
4974
4975 if (compute)
4976 {
4977 char display[100];
4978
4979 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
4980
4981 putenv (display);
4982 }
4983 else
4984 {
4985 if (getenv ("DISPLAY") == NULL)
4986 putenv ((char *) "DISPLAY=:0");
4987 }
4988
4989 /*
4990 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
4991 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
4992
4993 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
4994 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
4995 */
4996
4997 /**
4998 * Real init
4999 */
5000
5001 memset (&data, 0, sizeof (hc_global_data_t));
5002
5003 time_t proc_start;
5004
5005 time (&proc_start);
5006
5007 data.proc_start = proc_start;
5008
5009 int myargc = argc;
5010 char **myargv = argv;
5011
5012 hc_thread_mutex_init (mux_dispatcher);
5013 hc_thread_mutex_init (mux_counter);
5014 hc_thread_mutex_init (mux_display);
5015 hc_thread_mutex_init (mux_adl);
5016
5017 /**
5018 * commandline parameters
5019 */
5020
5021 uint usage = USAGE;
5022 uint version = VERSION;
5023 uint quiet = QUIET;
5024 uint benchmark = BENCHMARK;
5025 uint benchmark_mode = BENCHMARK_MODE;
5026 uint show = SHOW;
5027 uint left = LEFT;
5028 uint username = USERNAME;
5029 uint remove = REMOVE;
5030 uint remove_timer = REMOVE_TIMER;
5031 uint64_t skip = SKIP;
5032 uint64_t limit = LIMIT;
5033 uint keyspace = KEYSPACE;
5034 uint potfile_disable = POTFILE_DISABLE;
5035 uint debug_mode = DEBUG_MODE;
5036 char *debug_file = NULL;
5037 char *induction_dir = NULL;
5038 char *outfile_check_dir = NULL;
5039 uint force = FORCE;
5040 uint runtime = RUNTIME;
5041 uint hash_mode = HASH_MODE;
5042 uint attack_mode = ATTACK_MODE;
5043 uint markov_disable = MARKOV_DISABLE;
5044 uint markov_classic = MARKOV_CLASSIC;
5045 uint markov_threshold = MARKOV_THRESHOLD;
5046 char *markov_hcstat = NULL;
5047 char *outfile = NULL;
5048 uint outfile_format = OUTFILE_FORMAT;
5049 uint outfile_autohex = OUTFILE_AUTOHEX;
5050 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5051 uint restore = RESTORE;
5052 uint restore_timer = RESTORE_TIMER;
5053 uint restore_disable = RESTORE_DISABLE;
5054 uint status = STATUS;
5055 uint status_timer = STATUS_TIMER;
5056 uint status_automat = STATUS_AUTOMAT;
5057 uint loopback = LOOPBACK;
5058 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5059 char *session = NULL;
5060 uint hex_charset = HEX_CHARSET;
5061 uint hex_salt = HEX_SALT;
5062 uint hex_wordlist = HEX_WORDLIST;
5063 uint rp_gen = RP_GEN;
5064 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5065 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5066 uint rp_gen_seed = RP_GEN_SEED;
5067 char *rule_buf_l = (char *) RULE_BUF_L;
5068 char *rule_buf_r = (char *) RULE_BUF_R;
5069 uint increment = INCREMENT;
5070 uint increment_min = INCREMENT_MIN;
5071 uint increment_max = INCREMENT_MAX;
5072 char *cpu_affinity = NULL;
5073 char *gpu_devices = NULL;
5074 char *gpu_platform = NULL;
5075 char *truecrypt_keyfiles = NULL;
5076 uint workload_profile = WORKLOAD_PROFILE;
5077 uint gpu_accel = GPU_ACCEL;
5078 uint gpu_loops = GPU_LOOPS;
5079 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5080 uint gpu_temp_abort = GPU_TEMP_ABORT;
5081 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5082 uint powertune_enable = POWERTUNE_ENABLE;
5083 uint logfile_disable = LOGFILE_DISABLE;
5084 uint segment_size = SEGMENT_SIZE;
5085 uint scrypt_tmto = SCRYPT_TMTO;
5086 char separator = SEPARATOR;
5087 uint bitmap_min = BITMAP_MIN;
5088 uint bitmap_max = BITMAP_MAX;
5089 char *custom_charset_1 = NULL;
5090 char *custom_charset_2 = NULL;
5091 char *custom_charset_3 = NULL;
5092 char *custom_charset_4 = NULL;
5093
5094 #define IDX_HELP 'h'
5095 #define IDX_VERSION 'V'
5096 #define IDX_VERSION_LOWER 'v'
5097 #define IDX_QUIET 0xff02
5098 #define IDX_SHOW 0xff03
5099 #define IDX_LEFT 0xff04
5100 #define IDX_REMOVE 0xff05
5101 #define IDX_REMOVE_TIMER 0xff37
5102 #define IDX_SKIP 's'
5103 #define IDX_LIMIT 'l'
5104 #define IDX_KEYSPACE 0xff35
5105 #define IDX_POTFILE_DISABLE 0xff06
5106 #define IDX_DEBUG_MODE 0xff43
5107 #define IDX_DEBUG_FILE 0xff44
5108 #define IDX_INDUCTION_DIR 0xff46
5109 #define IDX_OUTFILE_CHECK_DIR 0xff47
5110 #define IDX_USERNAME 0xff07
5111 #define IDX_FORCE 0xff08
5112 #define IDX_RUNTIME 0xff09
5113 #define IDX_BENCHMARK 'b'
5114 #define IDX_BENCHMARK_MODE 0xff32
5115 #define IDX_HASH_MODE 'm'
5116 #define IDX_ATTACK_MODE 'a'
5117 #define IDX_RP_FILE 'r'
5118 #define IDX_RP_GEN 'g'
5119 #define IDX_RP_GEN_FUNC_MIN 0xff10
5120 #define IDX_RP_GEN_FUNC_MAX 0xff11
5121 #define IDX_RP_GEN_SEED 0xff34
5122 #define IDX_RULE_BUF_L 'j'
5123 #define IDX_RULE_BUF_R 'k'
5124 #define IDX_INCREMENT 'i'
5125 #define IDX_INCREMENT_MIN 0xff12
5126 #define IDX_INCREMENT_MAX 0xff13
5127 #define IDX_OUTFILE 'o'
5128 #define IDX_OUTFILE_FORMAT 0xff14
5129 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5130 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5131 #define IDX_RESTORE 0xff15
5132 #define IDX_RESTORE_DISABLE 0xff27
5133 #define IDX_STATUS 0xff17
5134 #define IDX_STATUS_TIMER 0xff18
5135 #define IDX_STATUS_AUTOMAT 0xff50
5136 #define IDX_LOOPBACK 0xff38
5137 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5138 #define IDX_SESSION 0xff19
5139 #define IDX_HEX_CHARSET 0xff20
5140 #define IDX_HEX_SALT 0xff21
5141 #define IDX_HEX_WORDLIST 0xff40
5142 #define IDX_MARKOV_DISABLE 0xff22
5143 #define IDX_MARKOV_CLASSIC 0xff23
5144 #define IDX_MARKOV_THRESHOLD 't'
5145 #define IDX_MARKOV_HCSTAT 0xff24
5146 #define IDX_CPU_AFFINITY 0xff25
5147 #define IDX_GPU_DEVICES 'd'
5148 #define IDX_GPU_PLATFORM 0xff72
5149 #define IDX_WORKLOAD_PROFILE 'w'
5150 #define IDX_GPU_ACCEL 'n'
5151 #define IDX_GPU_LOOPS 'u'
5152 #define IDX_GPU_TEMP_DISABLE 0xff29
5153 #define IDX_GPU_TEMP_ABORT 0xff30
5154 #define IDX_GPU_TEMP_RETAIN 0xff31
5155 #define IDX_POWERTUNE_ENABLE 0xff41
5156 #define IDX_LOGFILE_DISABLE 0xff51
5157 #define IDX_TRUECRYPT_KEYFILES 0xff52
5158 #define IDX_SCRYPT_TMTO 0xff61
5159 #define IDX_SEGMENT_SIZE 'c'
5160 #define IDX_SEPARATOR 'p'
5161 #define IDX_BITMAP_MIN 0xff70
5162 #define IDX_BITMAP_MAX 0xff71
5163 #define IDX_CUSTOM_CHARSET_1 '1'
5164 #define IDX_CUSTOM_CHARSET_2 '2'
5165 #define IDX_CUSTOM_CHARSET_3 '3'
5166 #define IDX_CUSTOM_CHARSET_4 '4'
5167
5168 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5169
5170 struct option long_options[] =
5171 {
5172 {"help", no_argument, 0, IDX_HELP},
5173 {"version", no_argument, 0, IDX_VERSION},
5174 {"quiet", no_argument, 0, IDX_QUIET},
5175 {"show", no_argument, 0, IDX_SHOW},
5176 {"left", no_argument, 0, IDX_LEFT},
5177 {"username", no_argument, 0, IDX_USERNAME},
5178 {"remove", no_argument, 0, IDX_REMOVE},
5179 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5180 {"skip", required_argument, 0, IDX_SKIP},
5181 {"limit", required_argument, 0, IDX_LIMIT},
5182 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5183 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5184 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5185 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5186 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5187 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5188 {"force", no_argument, 0, IDX_FORCE},
5189 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5190 {"benchmark-mode", required_argument, 0, IDX_BENCHMARK_MODE},
5191 {"restore", no_argument, 0, IDX_RESTORE},
5192 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5193 {"status", no_argument, 0, IDX_STATUS},
5194 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5195 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5196 {"loopback", no_argument, 0, IDX_LOOPBACK},
5197 {"weak-hash-threshold",
5198 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5199 {"session", required_argument, 0, IDX_SESSION},
5200 {"runtime", required_argument, 0, IDX_RUNTIME},
5201 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5202 {"generate-rules-func-min",
5203 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5204 {"generate-rules-func-max",
5205 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5206 {"generate-rules-seed",
5207 required_argument, 0, IDX_RP_GEN_SEED},
5208 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5209 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5210 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5211 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5212 {"rules-file", required_argument, 0, IDX_RP_FILE},
5213 {"outfile", required_argument, 0, IDX_OUTFILE},
5214 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5215 {"outfile-autohex-disable",
5216 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5217 {"outfile-check-timer",
5218 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5219 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5220 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5221 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5222 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5223 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5224 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5225 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5226 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5227 {"gpu-devices", required_argument, 0, IDX_GPU_DEVICES},
5228 {"gpu-platform", required_argument, 0, IDX_GPU_PLATFORM},
5229 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5230 {"gpu-accel", required_argument, 0, IDX_GPU_ACCEL},
5231 {"gpu-loops", required_argument, 0, IDX_GPU_LOOPS},
5232 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5233 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5234 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5235 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5236 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5237 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5238 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5239 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5240 // deprecated
5241 {"seperator", required_argument, 0, IDX_SEPARATOR},
5242 {"separator", required_argument, 0, IDX_SEPARATOR},
5243 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5244 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5245 {"increment", no_argument, 0, IDX_INCREMENT},
5246 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5247 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5248 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5249 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5250 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5251 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5252
5253 {0, 0, 0, 0}
5254 };
5255
5256 uint rp_files_cnt = 0;
5257
5258 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5259
5260 int option_index;
5261 int c;
5262
5263 optind = 1;
5264 optopt = 0;
5265 option_index = 0;
5266
5267 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5268 {
5269 switch (c)
5270 {
5271 case IDX_HELP: usage = 1; break;
5272 case IDX_VERSION:
5273 case IDX_VERSION_LOWER: version = 1; break;
5274 case IDX_RESTORE: restore = 1; break;
5275 case IDX_SESSION: session = optarg; break;
5276 case IDX_SHOW: show = 1; break;
5277 case IDX_LEFT: left = 1; break;
5278 case '?': return (-1);
5279 }
5280 }
5281
5282 if (optopt != 0)
5283 {
5284 log_error ("ERROR: Invalid argument specified");
5285
5286 return (-1);
5287 }
5288
5289 /**
5290 * exit functions
5291 */
5292
5293 if (version)
5294 {
5295 log_info (VERSION_TXT);
5296
5297 return (0);
5298 }
5299
5300 if (usage)
5301 {
5302 usage_big_print (PROGNAME);
5303
5304 return (0);
5305 }
5306
5307 /**
5308 * session
5309 */
5310
5311 if (session == NULL) session = (char *) PROGNAME;
5312
5313 size_t session_size = strlen (session) + 32;
5314
5315 data.session = session;
5316
5317 char *eff_restore_file = (char *) mymalloc (session_size);
5318 char *new_restore_file = (char *) mymalloc (session_size);
5319
5320 snprintf (eff_restore_file, session_size - 1, "%s.restore", session);
5321 snprintf (new_restore_file, session_size - 1, "%s.restore.new", session);
5322
5323 data.eff_restore_file = eff_restore_file;
5324 data.new_restore_file = new_restore_file;
5325
5326 if (((show == 1) || (left == 1)) && (restore == 1))
5327 {
5328 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5329 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5330
5331 return (-1);
5332 }
5333
5334 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5335 if ((show == 1) || (left == 1))
5336 {
5337 restore_disable = 1;
5338
5339 restore = 0;
5340 }
5341
5342 data.restore_disable = restore_disable;
5343
5344 restore_data_t *rd = init_restore (argc, argv);
5345
5346 data.rd = rd;
5347
5348 /**
5349 * restore file
5350 */
5351
5352 if (restore == 1)
5353 {
5354 read_restore (eff_restore_file, rd);
5355
5356 if (rd->version_bin < RESTORE_MIN)
5357 {
5358 log_error ("ERROR: Incompatible restore-file version");
5359
5360 return (-1);
5361 }
5362
5363 myargc = rd->argc;
5364 myargv = rd->argv;
5365
5366 #ifdef _POSIX
5367 rd->pid = getpid ();
5368 #elif _WIN
5369 rd->pid = GetCurrentProcessId ();
5370 #endif
5371 }
5372
5373 uint hash_mode_chgd = 0;
5374 uint runtime_chgd = 0;
5375 uint gpu_loops_chgd = 0;
5376 uint gpu_accel_chgd = 0;
5377 uint attack_mode_chgd = 0;
5378 uint outfile_format_chgd = 0;
5379 uint rp_gen_seed_chgd = 0;
5380 uint remove_timer_chgd = 0;
5381 uint increment_min_chgd = 0;
5382 uint increment_max_chgd = 0;
5383 uint gpu_temp_abort_chgd = 0;
5384 uint gpu_temp_retain_chgd = 0;
5385
5386 optind = 1;
5387 optopt = 0;
5388 option_index = 0;
5389
5390 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5391 {
5392 switch (c)
5393 {
5394 //case IDX_HELP: usage = 1; break;
5395 //case IDX_VERSION: version = 1; break;
5396 //case IDX_RESTORE: restore = 1; break;
5397 case IDX_QUIET: quiet = 1; break;
5398 //case IDX_SHOW: show = 1; break;
5399 case IDX_SHOW: break;
5400 //case IDX_LEFT: left = 1; break;
5401 case IDX_LEFT: break;
5402 case IDX_USERNAME: username = 1; break;
5403 case IDX_REMOVE: remove = 1; break;
5404 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5405 remove_timer_chgd = 1; break;
5406 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5407 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5408 case IDX_DEBUG_FILE: debug_file = optarg; break;
5409 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5410 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5411 case IDX_FORCE: force = 1; break;
5412 case IDX_SKIP: skip = atoll (optarg); break;
5413 case IDX_LIMIT: limit = atoll (optarg); break;
5414 case IDX_KEYSPACE: keyspace = 1; break;
5415 case IDX_BENCHMARK: benchmark = 1; break;
5416 case IDX_BENCHMARK_MODE: benchmark_mode = atoi (optarg); break;
5417 case IDX_RESTORE: break;
5418 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5419 case IDX_STATUS: status = 1; break;
5420 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5421 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5422 case IDX_LOOPBACK: loopback = 1; break;
5423 case IDX_WEAK_HASH_THRESHOLD:
5424 weak_hash_threshold = atoi (optarg); break;
5425 //case IDX_SESSION: session = optarg; break;
5426 case IDX_SESSION: break;
5427 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5428 hash_mode_chgd = 1; break;
5429 case IDX_RUNTIME: runtime = atoi (optarg);
5430 runtime_chgd = 1; break;
5431 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5432 attack_mode_chgd = 1; break;
5433 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5434 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5435 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5436 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5437 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5438 rp_gen_seed_chgd = 1; break;
5439 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5440 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5441 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5442 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5443 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5444 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5445 case IDX_OUTFILE: outfile = optarg; break;
5446 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5447 outfile_format_chgd = 1; break;
5448 case IDX_OUTFILE_AUTOHEX_DISABLE:
5449 outfile_autohex = 0; break;
5450 case IDX_OUTFILE_CHECK_TIMER:
5451 outfile_check_timer = atoi (optarg); break;
5452 case IDX_HEX_CHARSET: hex_charset = 1; break;
5453 case IDX_HEX_SALT: hex_salt = 1; break;
5454 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5455 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5456 case IDX_GPU_DEVICES: gpu_devices = optarg; break;
5457 case IDX_GPU_PLATFORM: gpu_platform = optarg; break;
5458 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg); break;
5459 case IDX_GPU_ACCEL: gpu_accel = atoi (optarg);
5460 gpu_accel_chgd = 1; break;
5461 case IDX_GPU_LOOPS: gpu_loops = atoi (optarg);
5462 gpu_loops_chgd = 1; break;
5463 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5464 case IDX_GPU_TEMP_ABORT: gpu_temp_abort_chgd = 1;
5465 gpu_temp_abort = atoi (optarg); break;
5466 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain_chgd = 1;
5467 gpu_temp_retain = atoi (optarg); break;
5468 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5469 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5470 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5471 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5472 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5473 case IDX_SEPARATOR: separator = optarg[0]; break;
5474 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5475 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5476 case IDX_INCREMENT: increment = 1; break;
5477 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5478 increment_min_chgd = 1; break;
5479 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5480 increment_max_chgd = 1; break;
5481 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5482 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5483 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5484 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5485
5486 default:
5487 log_error ("ERROR: Invalid argument specified");
5488 return (-1);
5489 }
5490 }
5491
5492 if (optopt != 0)
5493 {
5494 log_error ("ERROR: Invalid argument specified");
5495
5496 return (-1);
5497 }
5498
5499 /**
5500 * Inform user things getting started,
5501 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5502 * - we do not need to check algorithm_pos
5503 */
5504
5505 if (quiet == 0)
5506 {
5507 if (benchmark == 1)
5508 {
5509 log_info ("%s v%.2f starting in benchmark-mode...", PROGNAME, (float) VERSION_BIN / 100);
5510
5511 log_info ("");
5512 }
5513 else if (restore == 1)
5514 {
5515 log_info ("%s v%.2f starting in restore-mode...", PROGNAME, (float) VERSION_BIN / 100);
5516
5517 log_info ("");
5518 }
5519 else
5520 {
5521 log_info ("%s v%.2f starting...", PROGNAME, (float) VERSION_BIN / 100);
5522
5523 log_info ("");
5524 }
5525 }
5526
5527 /**
5528 * sanity check
5529 */
5530
5531 if (attack_mode > 7)
5532 {
5533 log_error ("ERROR: Invalid attack-mode specified");
5534
5535 return (-1);
5536 }
5537
5538 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5539 {
5540 log_error ("ERROR: Invalid runtime specified");
5541
5542 return (-1);
5543 }
5544
5545 if (hash_mode_chgd && hash_mode > 12800) // just added to remove compiler warnings for hash_mode_chgd
5546 {
5547 log_error ("ERROR: Invalid hash-type specified");
5548
5549 return (-1);
5550 }
5551
5552 // renamed hash modes
5553
5554 if (hash_mode_chgd)
5555 {
5556 int n = -1;
5557
5558 switch (hash_mode)
5559 {
5560 case 123: n = 124;
5561 break;
5562 }
5563
5564 if (n >= 0)
5565 {
5566 log_error ("Old -m specified, use -m %d instead", n);
5567
5568 return (-1);
5569 }
5570 }
5571
5572 if (username == 1)
5573 {
5574 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5575 {
5576 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5577
5578 return (-1);
5579 }
5580 }
5581
5582 if (outfile_format > 16)
5583 {
5584 log_error ("ERROR: Invalid outfile-format specified");
5585
5586 return (-1);
5587 }
5588
5589 if (left == 1)
5590 {
5591 if (outfile_format_chgd == 1)
5592 {
5593 if (outfile_format > 1)
5594 {
5595 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5596
5597 return (-1);
5598 }
5599 }
5600 else
5601 {
5602 outfile_format = OUTFILE_FMT_HASH;
5603 }
5604 }
5605
5606 if (show == 1)
5607 {
5608 if (outfile_format_chgd == 1)
5609 {
5610 if ((outfile_format > 7) && (outfile_format < 16))
5611 {
5612 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
5613
5614 return (-1);
5615 }
5616 }
5617 }
5618
5619 if (increment_min < INCREMENT_MIN)
5620 {
5621 log_error ("ERROR: Invalid increment-min specified");
5622
5623 return (-1);
5624 }
5625
5626 if (increment_max > INCREMENT_MAX)
5627 {
5628 log_error ("ERROR: Invalid increment-max specified");
5629
5630 return (-1);
5631 }
5632
5633 if (increment_min > increment_max)
5634 {
5635 log_error ("ERROR: Invalid increment-min specified");
5636
5637 return (-1);
5638 }
5639
5640 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
5641 {
5642 log_error ("ERROR: increment is not allowed in attack-mode 0");
5643
5644 return (-1);
5645 }
5646
5647 if ((increment == 0) && (increment_min_chgd == 1))
5648 {
5649 log_error ("ERROR: increment-min is only supported together with increment switch");
5650
5651 return (-1);
5652 }
5653
5654 if ((increment == 0) && (increment_max_chgd == 1))
5655 {
5656 log_error ("ERROR: increment-max is only supported together with increment switch");
5657
5658 return (-1);
5659 }
5660
5661 if (rp_files_cnt && rp_gen)
5662 {
5663 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
5664
5665 return (-1);
5666 }
5667
5668 if (rp_files_cnt || rp_gen)
5669 {
5670 if (attack_mode != ATTACK_MODE_STRAIGHT)
5671 {
5672 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
5673
5674 return (-1);
5675 }
5676 }
5677
5678 if (rp_gen_func_min > rp_gen_func_max)
5679 {
5680 log_error ("ERROR: Invalid rp-gen-func-min specified");
5681
5682 return (-1);
5683 }
5684
5685 if (gpu_accel_chgd == 1)
5686 {
5687 if (workload_profile != WORKLOAD_PROFILE)
5688 {
5689 log_error ("ERROR: gpu-accel parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5690
5691 return (-1);
5692 }
5693
5694 if (gpu_accel < 1)
5695 {
5696 log_error ("ERROR: Invalid gpu-accel specified");
5697
5698 return (-1);
5699 }
5700
5701 if (gpu_accel > 800)
5702 {
5703 log_error ("ERROR: Invalid gpu-accel specified");
5704
5705 return (-1);
5706 }
5707 }
5708
5709 if (gpu_loops_chgd == 1)
5710 {
5711 if (workload_profile != WORKLOAD_PROFILE)
5712 {
5713 log_error ("ERROR: gpu-loops parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5714
5715 return (-1);
5716 }
5717
5718 if (gpu_loops < 1)
5719 {
5720 log_error ("ERROR: Invalid gpu-loops specified");
5721
5722 return (-1);
5723 }
5724
5725 if (gpu_loops > 1024)
5726 {
5727 log_error ("ERROR: Invalid gpu-loops specified");
5728
5729 return (-1);
5730 }
5731 }
5732
5733 if (benchmark == 1)
5734 {
5735 if (workload_profile != WORKLOAD_PROFILE)
5736 {
5737 log_error ("ERROR: Using the workload-profile in benchmark mode is not allowed");
5738
5739 return (-1);
5740 }
5741 }
5742
5743 if ((workload_profile < 1) || (workload_profile > 3))
5744 {
5745 log_error ("ERROR: workload-profile %i not available", workload_profile);
5746
5747 return (-1);
5748 }
5749
5750 if (show == 1 || left == 1)
5751 {
5752 attack_mode = ATTACK_MODE_NONE;
5753
5754 if (remove == 1)
5755 {
5756 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
5757
5758 return (-1);
5759 }
5760
5761 if (potfile_disable == 1)
5762 {
5763 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
5764
5765 return (-1);
5766 }
5767 }
5768
5769 uint attack_kern = ATTACK_KERN_NONE;
5770
5771 switch (attack_mode)
5772 {
5773 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
5774 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
5775 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
5776 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
5777 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
5778 }
5779
5780 if (benchmark == 0)
5781 {
5782 if (keyspace == 1)
5783 {
5784 int num_additional_params = 1;
5785
5786 if (attack_kern == ATTACK_KERN_COMBI)
5787 {
5788 num_additional_params = 2;
5789 }
5790
5791 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
5792
5793 if (keyspace_wordlist_specified == 0) optind--;
5794 }
5795
5796 if (attack_kern == ATTACK_KERN_NONE)
5797 {
5798 if ((optind + 1) != myargc)
5799 {
5800 usage_mini_print (myargv[0]);
5801
5802 return (-1);
5803 }
5804 }
5805 else if (attack_kern == ATTACK_KERN_STRAIGHT)
5806 {
5807 if ((optind + 1) > myargc)
5808 {
5809 usage_mini_print (myargv[0]);
5810
5811 return (-1);
5812 }
5813 }
5814 else if (attack_kern == ATTACK_KERN_COMBI)
5815 {
5816 if ((optind + 3) != myargc)
5817 {
5818 usage_mini_print (myargv[0]);
5819
5820 return (-1);
5821 }
5822 }
5823 else if (attack_kern == ATTACK_KERN_BF)
5824 {
5825 if ((optind + 1) > myargc)
5826 {
5827 usage_mini_print (myargv[0]);
5828
5829 return (-1);
5830 }
5831 }
5832 else
5833 {
5834 usage_mini_print (myargv[0]);
5835
5836 return (-1);
5837 }
5838 }
5839 else
5840 {
5841 if (myargv[optind] != 0)
5842 {
5843 log_error ("ERROR: Invalid argument for benchmark mode specified");
5844
5845 return (-1);
5846 }
5847
5848 if (attack_mode_chgd == 1)
5849 {
5850 if (attack_mode != ATTACK_MODE_BF)
5851 {
5852 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
5853
5854 return (-1);
5855 }
5856 }
5857
5858 if (benchmark_mode == 0)
5859 {
5860 // nothing to do
5861 }
5862 else if (benchmark_mode == 1)
5863 {
5864 if (gpu_accel_chgd == 1 || gpu_loops_chgd == 1)
5865 {
5866 log_error ("ERROR: Benchmark-mode 1 does not allow gpu-accel or gpu-loops changed");
5867
5868 return (-1);
5869 }
5870 }
5871 else
5872 {
5873 log_error ("ERROR: Benchmark-mode must be 0 or 1");
5874
5875 return (-1);
5876 }
5877 }
5878
5879 if (skip != 0 && limit != 0)
5880 {
5881 limit += skip;
5882 }
5883
5884 if (keyspace == 1)
5885 {
5886 if (show == 1)
5887 {
5888 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
5889
5890 return (-1);
5891 }
5892 else if (left == 1)
5893 {
5894 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
5895
5896 return (-1);
5897 }
5898
5899 potfile_disable = 1;
5900
5901 restore_disable = 1;
5902
5903 restore = 0;
5904
5905 weak_hash_threshold = 0;
5906
5907 quiet = 1;
5908 }
5909
5910 if (remove_timer_chgd == 1)
5911 {
5912 if (remove == 0)
5913 {
5914 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
5915
5916 return (-1);
5917 }
5918
5919 if (remove_timer < 1)
5920 {
5921 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
5922
5923 return (-1);
5924 }
5925 }
5926
5927 if (loopback == 1)
5928 {
5929 if (attack_mode == ATTACK_MODE_BF)
5930 {
5931 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
5932
5933 return (-1);
5934 }
5935 else if (attack_mode == ATTACK_MODE_STRAIGHT)
5936 {
5937 if ((rp_files_cnt == 0) && (rp_gen == 0))
5938 {
5939 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
5940
5941 return (-1);
5942 }
5943 }
5944 }
5945
5946 if (debug_mode > 0)
5947 {
5948 if (attack_mode != ATTACK_MODE_STRAIGHT)
5949 {
5950 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
5951
5952 return (-1);
5953 }
5954
5955 if ((rp_files_cnt == 0) && (rp_gen == 0))
5956 {
5957 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
5958
5959 return (-1);
5960 }
5961 }
5962
5963 if (debug_mode > 4)
5964 {
5965 log_error ("ERROR: Invalid debug-mode specified");
5966
5967 return (-1);
5968 }
5969
5970 if (debug_file != NULL)
5971 {
5972 if (debug_mode < 1)
5973 {
5974 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
5975
5976 return (-1);
5977 }
5978 }
5979
5980 if (induction_dir != NULL)
5981 {
5982 if (attack_mode == ATTACK_MODE_BF)
5983 {
5984 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
5985
5986 return (-1);
5987 }
5988 }
5989
5990 /**
5991 * induction directory
5992 */
5993
5994 char *induction_directory = NULL;
5995
5996 if (attack_mode != ATTACK_MODE_BF)
5997 {
5998 if (induction_dir == NULL)
5999 {
6000 induction_directory = (char *) mymalloc (session_size);
6001
6002 snprintf (induction_directory, session_size - 1, "%s.%s", session, INDUCT_DIR);
6003
6004 // create induction folder if it does not already exist
6005
6006 if (keyspace == 0)
6007 {
6008 if (rmdir (induction_directory) == -1)
6009 {
6010 if (errno == ENOENT)
6011 {
6012 // good, we can ignore
6013 }
6014 else if (errno == ENOTEMPTY)
6015 {
6016 char *induction_directory_mv = (char *) mymalloc (session_size);
6017
6018 snprintf (induction_directory_mv, session_size - 1, "%s.induct.%d", session, (int) proc_start);
6019
6020 if (rename (induction_directory, induction_directory_mv) != 0)
6021 {
6022 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6023
6024 return (-1);
6025 }
6026 }
6027 else
6028 {
6029 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6030
6031 return (-1);
6032 }
6033 }
6034
6035 #ifdef _WIN
6036 #define mkdir(name,mode) mkdir (name)
6037 #endif
6038
6039 if (mkdir (induction_directory, 0700) == -1)
6040 {
6041 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6042
6043 return (-1);
6044 }
6045 }
6046 }
6047 else
6048 {
6049 induction_directory = induction_dir;
6050 }
6051 }
6052
6053 data.induction_directory = induction_directory;
6054
6055 /**
6056 * loopback
6057 */
6058
6059 size_t loopback_size = session_size + strlen (LOOPBACK_FILE) + 12;
6060
6061 char *loopback_file = (char *) mymalloc (loopback_size);
6062
6063 /**
6064 * outfile-check directory
6065 */
6066
6067 char *outfile_check_directory = NULL;
6068
6069 if (outfile_check_dir == NULL)
6070 {
6071 outfile_check_directory = (char *) mymalloc (session_size);
6072
6073 snprintf (outfile_check_directory, session_size - 1, "%s.%s", session, OUTFILES_DIR);
6074 }
6075 else
6076 {
6077 outfile_check_directory = outfile_check_dir;
6078 }
6079
6080 data.outfile_check_directory = outfile_check_directory;
6081
6082 if (keyspace == 0)
6083 {
6084 struct stat outfile_check_stat;
6085
6086 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6087 {
6088 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6089
6090 if (is_dir == 0)
6091 {
6092 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6093
6094 return (-1);
6095 }
6096 }
6097 else if (outfile_check_dir == NULL)
6098 {
6099 #ifdef _WIN
6100 #define mkdir(name,mode) mkdir (name)
6101 #endif
6102
6103 if (mkdir (outfile_check_directory, 0700) == -1)
6104 {
6105 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6106
6107 return (-1);
6108 }
6109 }
6110 }
6111
6112 /**
6113 * special other stuff
6114 */
6115
6116 if (hash_mode == 9710)
6117 {
6118 outfile_format = 5;
6119 outfile_format_chgd = 1;
6120 }
6121
6122 if (hash_mode == 9810)
6123 {
6124 outfile_format = 5;
6125 outfile_format_chgd = 1;
6126 }
6127
6128 if (hash_mode == 10410)
6129 {
6130 outfile_format = 5;
6131 outfile_format_chgd = 1;
6132 }
6133
6134 /**
6135 * store stuff
6136 */
6137
6138 data.hash_mode = hash_mode;
6139 data.restore = restore;
6140 data.restore_timer = restore_timer;
6141 data.restore_disable = restore_disable;
6142 data.status = status;
6143 data.status_timer = status_timer;
6144 data.status_automat = status_automat;
6145 data.loopback = loopback;
6146 data.runtime = runtime;
6147 data.remove = remove;
6148 data.remove_timer = remove_timer;
6149 data.debug_mode = debug_mode;
6150 data.debug_file = debug_file;
6151 data.username = username;
6152 data.quiet = quiet;
6153 data.outfile = outfile;
6154 data.outfile_format = outfile_format;
6155 data.outfile_autohex = outfile_autohex;
6156 data.hex_charset = hex_charset;
6157 data.hex_salt = hex_salt;
6158 data.hex_wordlist = hex_wordlist;
6159 data.separator = separator;
6160 data.rp_files = rp_files;
6161 data.rp_files_cnt = rp_files_cnt;
6162 data.rp_gen = rp_gen;
6163 data.rp_gen_seed = rp_gen_seed;
6164 data.force = force;
6165 data.benchmark = benchmark;
6166 data.skip = skip;
6167 data.limit = limit;
6168 data.powertune_enable = powertune_enable;
6169 data.logfile_disable = logfile_disable;
6170 data.truecrypt_keyfiles = truecrypt_keyfiles;
6171 data.scrypt_tmto = scrypt_tmto;
6172
6173 /**
6174 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
6175 */
6176
6177 #ifdef LINUX
6178
6179 char *resolved_path = realpath (myargv[0], NULL);
6180
6181 char *install_dir = get_install_dir (resolved_path);
6182 char *profile_dir = NULL;
6183 char *session_dir = NULL;
6184
6185 if (strcmp (install_dir, INSTALL_FOLDER) == 0)
6186 {
6187 struct passwd *pw = getpwuid (getuid ());
6188
6189 const char *homedir = pw->pw_dir;
6190
6191 profile_dir = get_profile_dir (homedir);
6192 session_dir = get_session_dir (profile_dir, session);
6193 }
6194 else
6195 {
6196 profile_dir = install_dir;
6197 session_dir = install_dir;
6198 }
6199
6200 myfree (resolved_path);
6201
6202 #else
6203
6204 char *install_dir = get_install_dir (myargv[0]);
6205 char *profile_dir = install_dir;
6206 char *session_dir = install_dir;
6207
6208 #endif
6209
6210 data.install_dir = install_dir;
6211 data.profile_dir = profile_dir;
6212 data.session_dir = session_dir;
6213
6214 /**
6215 * cpu affinity
6216 */
6217
6218 if (cpu_affinity)
6219 {
6220 set_cpu_affinity (cpu_affinity);
6221 }
6222
6223 if (rp_gen_seed_chgd == 0)
6224 {
6225 srand (proc_start);
6226 }
6227 else
6228 {
6229 srand (rp_gen_seed);
6230 }
6231
6232 /**
6233 * logfile init
6234 */
6235
6236 if (logfile_disable == 0)
6237 {
6238 size_t logfile_size = strlen (session) + 32;
6239
6240 char *logfile = (char *) mymalloc (logfile_size);
6241
6242 snprintf (logfile, logfile_size - 1, "%s.log", session);
6243
6244 data.logfile = logfile;
6245
6246 char *topid = logfile_generate_topid ();
6247
6248 data.topid = topid;
6249 }
6250
6251 // logfile_append() checks for logfile_disable internally to make it easier from here
6252
6253 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6254 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6255 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6256 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6257 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6258 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6259 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6260 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6261 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6262 #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));
6263
6264 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6265 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6266 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6267 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6268 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6269 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6270 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6271 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6272
6273 logfile_top_msg ("START");
6274
6275 logfile_top_uint (attack_mode);
6276 logfile_top_uint (attack_kern);
6277 logfile_top_uint (benchmark);
6278 logfile_top_uint (benchmark_mode);
6279 logfile_top_uint (bitmap_min);
6280 logfile_top_uint (bitmap_max);
6281 logfile_top_uint (debug_mode);
6282 logfile_top_uint (force);
6283 logfile_top_uint (gpu_accel);
6284 logfile_top_uint (gpu_loops);
6285 logfile_top_uint (gpu_temp_abort);
6286 logfile_top_uint (gpu_temp_disable);
6287 logfile_top_uint (gpu_temp_retain);
6288 logfile_top_uint (hash_mode);
6289 logfile_top_uint (hex_charset);
6290 logfile_top_uint (hex_salt);
6291 logfile_top_uint (hex_wordlist);
6292 logfile_top_uint (increment);
6293 logfile_top_uint (increment_max);
6294 logfile_top_uint (increment_min);
6295 logfile_top_uint (keyspace);
6296 logfile_top_uint (left);
6297 logfile_top_uint (logfile_disable);
6298 logfile_top_uint (loopback);
6299 logfile_top_uint (markov_classic);
6300 logfile_top_uint (markov_disable);
6301 logfile_top_uint (markov_threshold);
6302 logfile_top_uint (outfile_autohex);
6303 logfile_top_uint (outfile_check_timer);
6304 logfile_top_uint (outfile_format);
6305 logfile_top_uint (potfile_disable);
6306 logfile_top_uint (powertune_enable);
6307 logfile_top_uint (scrypt_tmto);
6308 logfile_top_uint (quiet);
6309 logfile_top_uint (remove);
6310 logfile_top_uint (remove_timer);
6311 logfile_top_uint (restore);
6312 logfile_top_uint (restore_disable);
6313 logfile_top_uint (restore_timer);
6314 logfile_top_uint (rp_gen);
6315 logfile_top_uint (rp_gen_func_max);
6316 logfile_top_uint (rp_gen_func_min);
6317 logfile_top_uint (rp_gen_seed);
6318 logfile_top_uint (runtime);
6319 logfile_top_uint (segment_size);
6320 logfile_top_uint (show);
6321 logfile_top_uint (status);
6322 logfile_top_uint (status_automat);
6323 logfile_top_uint (status_timer);
6324 logfile_top_uint (usage);
6325 logfile_top_uint (username);
6326 logfile_top_uint (version);
6327 logfile_top_uint (weak_hash_threshold);
6328 logfile_top_uint (workload_profile);
6329 logfile_top_uint64 (limit);
6330 logfile_top_uint64 (skip);
6331 logfile_top_char (separator);
6332 logfile_top_string (cpu_affinity);
6333 logfile_top_string (custom_charset_1);
6334 logfile_top_string (custom_charset_2);
6335 logfile_top_string (custom_charset_3);
6336 logfile_top_string (custom_charset_4);
6337 logfile_top_string (debug_file);
6338 logfile_top_string (gpu_devices);
6339 logfile_top_string (gpu_platform);
6340 logfile_top_string (induction_dir);
6341 logfile_top_string (markov_hcstat);
6342 logfile_top_string (outfile);
6343 logfile_top_string (outfile_check_dir);
6344 logfile_top_string (rule_buf_l);
6345 logfile_top_string (rule_buf_r);
6346 logfile_top_string (session);
6347 logfile_top_string (truecrypt_keyfiles);
6348
6349 /**
6350 * devices
6351 */
6352
6353 uint gpu_devicemask = devices_to_devicemask (gpu_devices);
6354
6355 /**
6356 * benchmark
6357 */
6358
6359 if (benchmark == 1)
6360 {
6361 /**
6362 * disable useless stuff for benchmark
6363 */
6364
6365 restore_timer = 0;
6366 status_timer = 0;
6367 restore_disable = 1;
6368 potfile_disable = 1;
6369 weak_hash_threshold = 0;
6370
6371 data.restore_timer = restore_timer;
6372 data.status_timer = status_timer;
6373 data.restore_disable = restore_disable;
6374
6375 if (benchmark_mode == 1)
6376 {
6377 markov_disable = 1;
6378 }
6379
6380 /**
6381 * force attack mode to be bruteforce
6382 */
6383
6384 attack_mode = ATTACK_MODE_BF;
6385 attack_kern = ATTACK_KERN_BF;
6386
6387 if (runtime_chgd == 0)
6388 {
6389 runtime = 4;
6390
6391 if (benchmark_mode == 1) runtime = 17;
6392
6393 data.runtime = runtime;
6394 }
6395 }
6396
6397 /**
6398 * config
6399 */
6400
6401 uint hash_type = 0;
6402 uint salt_type = 0;
6403 uint attack_exec = 0;
6404 uint opts_type = 0;
6405 uint kern_type = 0;
6406 uint dgst_size = 0;
6407 uint esalt_size = 0;
6408 uint opti_type = 0;
6409 uint dgst_pos0 = -1;
6410 uint dgst_pos1 = -1;
6411 uint dgst_pos2 = -1;
6412 uint dgst_pos3 = -1;
6413
6414 int (*parse_func) (char *, uint, hash_t *);
6415 int (*sort_by_digest) (const void *, const void *);
6416
6417 uint algorithm_pos = 0;
6418 uint algorithm_max = 1;
6419
6420 uint *algorithms = default_benchmark_algorithms;
6421
6422 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6423
6424 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6425 {
6426 /*
6427 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6428 * the following algos are skipped entirely
6429 */
6430
6431 if (algorithm_pos > 0)
6432 {
6433 local_free (rd);
6434
6435 rd = init_restore (argc, argv);
6436
6437 data.rd = rd;
6438 }
6439
6440 /**
6441 * update hash_mode in case of multihash benchmark
6442 */
6443
6444 if (benchmark == 1)
6445 {
6446 if (hash_mode_chgd == 0)
6447 {
6448 hash_mode = algorithms[algorithm_pos];
6449
6450 data.hash_mode = hash_mode;
6451 }
6452
6453 quiet = 1;
6454
6455 data.quiet = quiet;
6456 }
6457
6458 switch (hash_mode)
6459 {
6460 case 0: hash_type = HASH_TYPE_MD5;
6461 salt_type = SALT_TYPE_NONE;
6462 attack_exec = ATTACK_EXEC_ON_GPU;
6463 opts_type = OPTS_TYPE_PT_GENERATE_LE
6464 | OPTS_TYPE_PT_ADD80
6465 | OPTS_TYPE_PT_ADDBITS14;
6466 kern_type = KERN_TYPE_MD5;
6467 dgst_size = DGST_SIZE_4_4;
6468 parse_func = md5_parse_hash;
6469 sort_by_digest = sort_by_digest_4_4;
6470 opti_type = OPTI_TYPE_ZERO_BYTE
6471 | OPTI_TYPE_PRECOMPUTE_INIT
6472 | OPTI_TYPE_PRECOMPUTE_MERKLE
6473 | OPTI_TYPE_MEET_IN_MIDDLE
6474 | OPTI_TYPE_EARLY_SKIP
6475 | OPTI_TYPE_NOT_ITERATED
6476 | OPTI_TYPE_NOT_SALTED
6477 | OPTI_TYPE_RAW_HASH;
6478 dgst_pos0 = 0;
6479 dgst_pos1 = 3;
6480 dgst_pos2 = 2;
6481 dgst_pos3 = 1;
6482 break;
6483
6484 case 10: hash_type = HASH_TYPE_MD5;
6485 salt_type = SALT_TYPE_INTERN;
6486 attack_exec = ATTACK_EXEC_ON_GPU;
6487 opts_type = OPTS_TYPE_PT_GENERATE_LE
6488 | OPTS_TYPE_ST_ADD80
6489 | OPTS_TYPE_ST_ADDBITS14;
6490 kern_type = KERN_TYPE_MD5_PWSLT;
6491 dgst_size = DGST_SIZE_4_4;
6492 parse_func = md5s_parse_hash;
6493 sort_by_digest = sort_by_digest_4_4;
6494 opti_type = OPTI_TYPE_ZERO_BYTE
6495 | OPTI_TYPE_PRECOMPUTE_INIT
6496 | OPTI_TYPE_PRECOMPUTE_MERKLE
6497 | OPTI_TYPE_MEET_IN_MIDDLE
6498 | OPTI_TYPE_EARLY_SKIP
6499 | OPTI_TYPE_NOT_ITERATED
6500 | OPTI_TYPE_APPENDED_SALT
6501 | OPTI_TYPE_RAW_HASH;
6502 dgst_pos0 = 0;
6503 dgst_pos1 = 3;
6504 dgst_pos2 = 2;
6505 dgst_pos3 = 1;
6506 break;
6507
6508 case 11: hash_type = HASH_TYPE_MD5;
6509 salt_type = SALT_TYPE_INTERN;
6510 attack_exec = ATTACK_EXEC_ON_GPU;
6511 opts_type = OPTS_TYPE_PT_GENERATE_LE
6512 | OPTS_TYPE_ST_ADD80
6513 | OPTS_TYPE_ST_ADDBITS14;
6514 kern_type = KERN_TYPE_MD5_PWSLT;
6515 dgst_size = DGST_SIZE_4_4;
6516 parse_func = joomla_parse_hash;
6517 sort_by_digest = sort_by_digest_4_4;
6518 opti_type = OPTI_TYPE_ZERO_BYTE
6519 | OPTI_TYPE_PRECOMPUTE_INIT
6520 | OPTI_TYPE_PRECOMPUTE_MERKLE
6521 | OPTI_TYPE_MEET_IN_MIDDLE
6522 | OPTI_TYPE_EARLY_SKIP
6523 | OPTI_TYPE_NOT_ITERATED
6524 | OPTI_TYPE_APPENDED_SALT
6525 | OPTI_TYPE_RAW_HASH;
6526 dgst_pos0 = 0;
6527 dgst_pos1 = 3;
6528 dgst_pos2 = 2;
6529 dgst_pos3 = 1;
6530 break;
6531
6532 case 12: hash_type = HASH_TYPE_MD5;
6533 salt_type = SALT_TYPE_INTERN;
6534 attack_exec = ATTACK_EXEC_ON_GPU;
6535 opts_type = OPTS_TYPE_PT_GENERATE_LE
6536 | OPTS_TYPE_ST_ADD80
6537 | OPTS_TYPE_ST_ADDBITS14;
6538 kern_type = KERN_TYPE_MD5_PWSLT;
6539 dgst_size = DGST_SIZE_4_4;
6540 parse_func = postgresql_parse_hash;
6541 sort_by_digest = sort_by_digest_4_4;
6542 opti_type = OPTI_TYPE_ZERO_BYTE
6543 | OPTI_TYPE_PRECOMPUTE_INIT
6544 | OPTI_TYPE_PRECOMPUTE_MERKLE
6545 | OPTI_TYPE_MEET_IN_MIDDLE
6546 | OPTI_TYPE_EARLY_SKIP
6547 | OPTI_TYPE_NOT_ITERATED
6548 | OPTI_TYPE_APPENDED_SALT
6549 | OPTI_TYPE_RAW_HASH;
6550 dgst_pos0 = 0;
6551 dgst_pos1 = 3;
6552 dgst_pos2 = 2;
6553 dgst_pos3 = 1;
6554 break;
6555
6556 case 20: hash_type = HASH_TYPE_MD5;
6557 salt_type = SALT_TYPE_INTERN;
6558 attack_exec = ATTACK_EXEC_ON_GPU;
6559 opts_type = OPTS_TYPE_PT_GENERATE_LE
6560 | OPTS_TYPE_PT_ADD80
6561 | OPTS_TYPE_PT_ADDBITS14;
6562 kern_type = KERN_TYPE_MD5_SLTPW;
6563 dgst_size = DGST_SIZE_4_4;
6564 parse_func = md5s_parse_hash;
6565 sort_by_digest = sort_by_digest_4_4;
6566 opti_type = OPTI_TYPE_ZERO_BYTE
6567 | OPTI_TYPE_PRECOMPUTE_INIT
6568 | OPTI_TYPE_PRECOMPUTE_MERKLE
6569 | OPTI_TYPE_EARLY_SKIP
6570 | OPTI_TYPE_NOT_ITERATED
6571 | OPTI_TYPE_PREPENDED_SALT
6572 | OPTI_TYPE_RAW_HASH;
6573 dgst_pos0 = 0;
6574 dgst_pos1 = 3;
6575 dgst_pos2 = 2;
6576 dgst_pos3 = 1;
6577 break;
6578
6579 case 21: hash_type = HASH_TYPE_MD5;
6580 salt_type = SALT_TYPE_INTERN;
6581 attack_exec = ATTACK_EXEC_ON_GPU;
6582 opts_type = OPTS_TYPE_PT_GENERATE_LE
6583 | OPTS_TYPE_PT_ADD80
6584 | OPTS_TYPE_PT_ADDBITS14;
6585 kern_type = KERN_TYPE_MD5_SLTPW;
6586 dgst_size = DGST_SIZE_4_4;
6587 parse_func = osc_parse_hash;
6588 sort_by_digest = sort_by_digest_4_4;
6589 opti_type = OPTI_TYPE_ZERO_BYTE
6590 | OPTI_TYPE_PRECOMPUTE_INIT
6591 | OPTI_TYPE_PRECOMPUTE_MERKLE
6592 | OPTI_TYPE_EARLY_SKIP
6593 | OPTI_TYPE_NOT_ITERATED
6594 | OPTI_TYPE_PREPENDED_SALT
6595 | OPTI_TYPE_RAW_HASH;
6596 dgst_pos0 = 0;
6597 dgst_pos1 = 3;
6598 dgst_pos2 = 2;
6599 dgst_pos3 = 1;
6600 break;
6601
6602 case 22: hash_type = HASH_TYPE_MD5;
6603 salt_type = SALT_TYPE_EMBEDDED;
6604 attack_exec = ATTACK_EXEC_ON_GPU;
6605 opts_type = OPTS_TYPE_PT_GENERATE_LE
6606 | OPTS_TYPE_PT_ADD80
6607 | OPTS_TYPE_PT_ADDBITS14;
6608 kern_type = KERN_TYPE_MD5_SLTPW;
6609 dgst_size = DGST_SIZE_4_4;
6610 parse_func = netscreen_parse_hash;
6611 sort_by_digest = sort_by_digest_4_4;
6612 opti_type = OPTI_TYPE_ZERO_BYTE
6613 | OPTI_TYPE_PRECOMPUTE_INIT
6614 | OPTI_TYPE_PRECOMPUTE_MERKLE
6615 | OPTI_TYPE_EARLY_SKIP
6616 | OPTI_TYPE_NOT_ITERATED
6617 | OPTI_TYPE_PREPENDED_SALT
6618 | OPTI_TYPE_RAW_HASH;
6619 dgst_pos0 = 0;
6620 dgst_pos1 = 3;
6621 dgst_pos2 = 2;
6622 dgst_pos3 = 1;
6623 break;
6624
6625 case 23: hash_type = HASH_TYPE_MD5;
6626 salt_type = SALT_TYPE_EMBEDDED;
6627 attack_exec = ATTACK_EXEC_ON_GPU;
6628 opts_type = OPTS_TYPE_PT_GENERATE_LE
6629 | OPTS_TYPE_PT_ADD80
6630 | OPTS_TYPE_PT_ADDBITS14;
6631 kern_type = KERN_TYPE_MD5_SLTPW;
6632 dgst_size = DGST_SIZE_4_4;
6633 parse_func = skype_parse_hash;
6634 sort_by_digest = sort_by_digest_4_4;
6635 opti_type = OPTI_TYPE_ZERO_BYTE
6636 | OPTI_TYPE_PRECOMPUTE_INIT
6637 | OPTI_TYPE_PRECOMPUTE_MERKLE
6638 | OPTI_TYPE_EARLY_SKIP
6639 | OPTI_TYPE_NOT_ITERATED
6640 | OPTI_TYPE_PREPENDED_SALT
6641 | OPTI_TYPE_RAW_HASH;
6642 dgst_pos0 = 0;
6643 dgst_pos1 = 3;
6644 dgst_pos2 = 2;
6645 dgst_pos3 = 1;
6646 break;
6647
6648 case 30: hash_type = HASH_TYPE_MD5;
6649 salt_type = SALT_TYPE_INTERN;
6650 attack_exec = ATTACK_EXEC_ON_GPU;
6651 opts_type = OPTS_TYPE_PT_GENERATE_LE
6652 | OPTS_TYPE_PT_UNICODE
6653 | OPTS_TYPE_ST_ADD80
6654 | OPTS_TYPE_ST_ADDBITS14;
6655 kern_type = KERN_TYPE_MD5_PWUSLT;
6656 dgst_size = DGST_SIZE_4_4;
6657 parse_func = md5s_parse_hash;
6658 sort_by_digest = sort_by_digest_4_4;
6659 opti_type = OPTI_TYPE_ZERO_BYTE
6660 | OPTI_TYPE_PRECOMPUTE_INIT
6661 | OPTI_TYPE_PRECOMPUTE_MERKLE
6662 | OPTI_TYPE_MEET_IN_MIDDLE
6663 | OPTI_TYPE_EARLY_SKIP
6664 | OPTI_TYPE_NOT_ITERATED
6665 | OPTI_TYPE_APPENDED_SALT
6666 | OPTI_TYPE_RAW_HASH;
6667 dgst_pos0 = 0;
6668 dgst_pos1 = 3;
6669 dgst_pos2 = 2;
6670 dgst_pos3 = 1;
6671 break;
6672
6673 case 40: hash_type = HASH_TYPE_MD5;
6674 salt_type = SALT_TYPE_INTERN;
6675 attack_exec = ATTACK_EXEC_ON_GPU;
6676 opts_type = OPTS_TYPE_PT_GENERATE_LE
6677 | OPTS_TYPE_PT_ADD80
6678 | OPTS_TYPE_PT_ADDBITS14
6679 | OPTS_TYPE_PT_UNICODE;
6680 kern_type = KERN_TYPE_MD5_SLTPWU;
6681 dgst_size = DGST_SIZE_4_4;
6682 parse_func = md5s_parse_hash;
6683 sort_by_digest = sort_by_digest_4_4;
6684 opti_type = OPTI_TYPE_ZERO_BYTE
6685 | OPTI_TYPE_PRECOMPUTE_INIT
6686 | OPTI_TYPE_PRECOMPUTE_MERKLE
6687 | OPTI_TYPE_EARLY_SKIP
6688 | OPTI_TYPE_NOT_ITERATED
6689 | OPTI_TYPE_PREPENDED_SALT
6690 | OPTI_TYPE_RAW_HASH;
6691 dgst_pos0 = 0;
6692 dgst_pos1 = 3;
6693 dgst_pos2 = 2;
6694 dgst_pos3 = 1;
6695 break;
6696
6697 case 50: hash_type = HASH_TYPE_MD5;
6698 salt_type = SALT_TYPE_INTERN;
6699 attack_exec = ATTACK_EXEC_ON_GPU;
6700 opts_type = OPTS_TYPE_PT_GENERATE_LE
6701 | OPTS_TYPE_ST_ADD80
6702 | OPTS_TYPE_ST_ADDBITS14;
6703 kern_type = KERN_TYPE_HMACMD5_PW;
6704 dgst_size = DGST_SIZE_4_4;
6705 parse_func = hmacmd5_parse_hash;
6706 sort_by_digest = sort_by_digest_4_4;
6707 opti_type = OPTI_TYPE_ZERO_BYTE
6708 | OPTI_TYPE_NOT_ITERATED;
6709 dgst_pos0 = 0;
6710 dgst_pos1 = 3;
6711 dgst_pos2 = 2;
6712 dgst_pos3 = 1;
6713 break;
6714
6715 case 60: hash_type = HASH_TYPE_MD5;
6716 salt_type = SALT_TYPE_INTERN;
6717 attack_exec = ATTACK_EXEC_ON_GPU;
6718 opts_type = OPTS_TYPE_PT_GENERATE_LE
6719 | OPTS_TYPE_PT_ADD80
6720 | OPTS_TYPE_PT_ADDBITS14;
6721 kern_type = KERN_TYPE_HMACMD5_SLT;
6722 dgst_size = DGST_SIZE_4_4;
6723 parse_func = hmacmd5_parse_hash;
6724 sort_by_digest = sort_by_digest_4_4;
6725 opti_type = OPTI_TYPE_ZERO_BYTE
6726 | OPTI_TYPE_NOT_ITERATED;
6727 dgst_pos0 = 0;
6728 dgst_pos1 = 3;
6729 dgst_pos2 = 2;
6730 dgst_pos3 = 1;
6731 break;
6732
6733 case 100: hash_type = HASH_TYPE_SHA1;
6734 salt_type = SALT_TYPE_NONE;
6735 attack_exec = ATTACK_EXEC_ON_GPU;
6736 opts_type = OPTS_TYPE_PT_GENERATE_BE
6737 | OPTS_TYPE_PT_ADD80
6738 | OPTS_TYPE_PT_ADDBITS15;
6739 kern_type = KERN_TYPE_SHA1;
6740 dgst_size = DGST_SIZE_4_5;
6741 parse_func = sha1_parse_hash;
6742 sort_by_digest = sort_by_digest_4_5;
6743 opti_type = OPTI_TYPE_ZERO_BYTE
6744 | OPTI_TYPE_PRECOMPUTE_INIT
6745 | OPTI_TYPE_PRECOMPUTE_MERKLE
6746 | OPTI_TYPE_EARLY_SKIP
6747 | OPTI_TYPE_NOT_ITERATED
6748 | OPTI_TYPE_NOT_SALTED
6749 | OPTI_TYPE_RAW_HASH;
6750 dgst_pos0 = 3;
6751 dgst_pos1 = 4;
6752 dgst_pos2 = 2;
6753 dgst_pos3 = 1;
6754 break;
6755
6756 case 101: hash_type = HASH_TYPE_SHA1;
6757 salt_type = SALT_TYPE_NONE;
6758 attack_exec = ATTACK_EXEC_ON_GPU;
6759 opts_type = OPTS_TYPE_PT_GENERATE_BE
6760 | OPTS_TYPE_PT_ADD80
6761 | OPTS_TYPE_PT_ADDBITS15;
6762 kern_type = KERN_TYPE_SHA1;
6763 dgst_size = DGST_SIZE_4_5;
6764 parse_func = sha1b64_parse_hash;
6765 sort_by_digest = sort_by_digest_4_5;
6766 opti_type = OPTI_TYPE_ZERO_BYTE
6767 | OPTI_TYPE_PRECOMPUTE_INIT
6768 | OPTI_TYPE_PRECOMPUTE_MERKLE
6769 | OPTI_TYPE_EARLY_SKIP
6770 | OPTI_TYPE_NOT_ITERATED
6771 | OPTI_TYPE_NOT_SALTED
6772 | OPTI_TYPE_RAW_HASH;
6773 dgst_pos0 = 3;
6774 dgst_pos1 = 4;
6775 dgst_pos2 = 2;
6776 dgst_pos3 = 1;
6777 break;
6778
6779 case 110: hash_type = HASH_TYPE_SHA1;
6780 salt_type = SALT_TYPE_INTERN;
6781 attack_exec = ATTACK_EXEC_ON_GPU;
6782 opts_type = OPTS_TYPE_PT_GENERATE_BE
6783 | OPTS_TYPE_ST_ADD80
6784 | OPTS_TYPE_ST_ADDBITS15;
6785 kern_type = KERN_TYPE_SHA1_PWSLT;
6786 dgst_size = DGST_SIZE_4_5;
6787 parse_func = sha1s_parse_hash;
6788 sort_by_digest = sort_by_digest_4_5;
6789 opti_type = OPTI_TYPE_ZERO_BYTE
6790 | OPTI_TYPE_PRECOMPUTE_INIT
6791 | OPTI_TYPE_PRECOMPUTE_MERKLE
6792 | OPTI_TYPE_EARLY_SKIP
6793 | OPTI_TYPE_NOT_ITERATED
6794 | OPTI_TYPE_APPENDED_SALT
6795 | OPTI_TYPE_RAW_HASH;
6796 dgst_pos0 = 3;
6797 dgst_pos1 = 4;
6798 dgst_pos2 = 2;
6799 dgst_pos3 = 1;
6800 break;
6801
6802 case 111: hash_type = HASH_TYPE_SHA1;
6803 salt_type = SALT_TYPE_EMBEDDED;
6804 attack_exec = ATTACK_EXEC_ON_GPU;
6805 opts_type = OPTS_TYPE_PT_GENERATE_BE
6806 | OPTS_TYPE_ST_ADD80
6807 | OPTS_TYPE_ST_ADDBITS15;
6808 kern_type = KERN_TYPE_SHA1_PWSLT;
6809 dgst_size = DGST_SIZE_4_5;
6810 parse_func = sha1b64s_parse_hash;
6811 sort_by_digest = sort_by_digest_4_5;
6812 opti_type = OPTI_TYPE_ZERO_BYTE
6813 | OPTI_TYPE_PRECOMPUTE_INIT
6814 | OPTI_TYPE_PRECOMPUTE_MERKLE
6815 | OPTI_TYPE_EARLY_SKIP
6816 | OPTI_TYPE_NOT_ITERATED
6817 | OPTI_TYPE_APPENDED_SALT
6818 | OPTI_TYPE_RAW_HASH;
6819 dgst_pos0 = 3;
6820 dgst_pos1 = 4;
6821 dgst_pos2 = 2;
6822 dgst_pos3 = 1;
6823 break;
6824
6825 case 112: hash_type = HASH_TYPE_SHA1;
6826 salt_type = SALT_TYPE_INTERN;
6827 attack_exec = ATTACK_EXEC_ON_GPU;
6828 opts_type = OPTS_TYPE_PT_GENERATE_BE
6829 | OPTS_TYPE_ST_ADD80
6830 | OPTS_TYPE_ST_ADDBITS15
6831 | OPTS_TYPE_ST_HEX;
6832 kern_type = KERN_TYPE_SHA1_PWSLT;
6833 dgst_size = DGST_SIZE_4_5;
6834 parse_func = oracles_parse_hash;
6835 sort_by_digest = sort_by_digest_4_5;
6836 opti_type = OPTI_TYPE_ZERO_BYTE
6837 | OPTI_TYPE_PRECOMPUTE_INIT
6838 | OPTI_TYPE_PRECOMPUTE_MERKLE
6839 | OPTI_TYPE_EARLY_SKIP
6840 | OPTI_TYPE_NOT_ITERATED
6841 | OPTI_TYPE_APPENDED_SALT
6842 | OPTI_TYPE_RAW_HASH;
6843 dgst_pos0 = 3;
6844 dgst_pos1 = 4;
6845 dgst_pos2 = 2;
6846 dgst_pos3 = 1;
6847 break;
6848
6849 case 120: hash_type = HASH_TYPE_SHA1;
6850 salt_type = SALT_TYPE_INTERN;
6851 attack_exec = ATTACK_EXEC_ON_GPU;
6852 opts_type = OPTS_TYPE_PT_GENERATE_BE
6853 | OPTS_TYPE_PT_ADD80
6854 | OPTS_TYPE_PT_ADDBITS15;
6855 kern_type = KERN_TYPE_SHA1_SLTPW;
6856 dgst_size = DGST_SIZE_4_5;
6857 parse_func = sha1s_parse_hash;
6858 sort_by_digest = sort_by_digest_4_5;
6859 opti_type = OPTI_TYPE_ZERO_BYTE
6860 | OPTI_TYPE_PRECOMPUTE_INIT
6861 | OPTI_TYPE_PRECOMPUTE_MERKLE
6862 | OPTI_TYPE_EARLY_SKIP
6863 | OPTI_TYPE_NOT_ITERATED
6864 | OPTI_TYPE_PREPENDED_SALT
6865 | OPTI_TYPE_RAW_HASH;
6866 dgst_pos0 = 3;
6867 dgst_pos1 = 4;
6868 dgst_pos2 = 2;
6869 dgst_pos3 = 1;
6870 break;
6871
6872 case 121: hash_type = HASH_TYPE_SHA1;
6873 salt_type = SALT_TYPE_INTERN;
6874 attack_exec = ATTACK_EXEC_ON_GPU;
6875 opts_type = OPTS_TYPE_PT_GENERATE_BE
6876 | OPTS_TYPE_PT_ADD80
6877 | OPTS_TYPE_PT_ADDBITS15
6878 | OPTS_TYPE_ST_LOWER;
6879 kern_type = KERN_TYPE_SHA1_SLTPW;
6880 dgst_size = DGST_SIZE_4_5;
6881 parse_func = smf_parse_hash;
6882 sort_by_digest = sort_by_digest_4_5;
6883 opti_type = OPTI_TYPE_ZERO_BYTE
6884 | OPTI_TYPE_PRECOMPUTE_INIT
6885 | OPTI_TYPE_PRECOMPUTE_MERKLE
6886 | OPTI_TYPE_EARLY_SKIP
6887 | OPTI_TYPE_NOT_ITERATED
6888 | OPTI_TYPE_PREPENDED_SALT
6889 | OPTI_TYPE_RAW_HASH;
6890 dgst_pos0 = 3;
6891 dgst_pos1 = 4;
6892 dgst_pos2 = 2;
6893 dgst_pos3 = 1;
6894 break;
6895
6896 case 122: hash_type = HASH_TYPE_SHA1;
6897 salt_type = SALT_TYPE_EMBEDDED;
6898 attack_exec = ATTACK_EXEC_ON_GPU;
6899 opts_type = OPTS_TYPE_PT_GENERATE_BE
6900 | OPTS_TYPE_PT_ADD80
6901 | OPTS_TYPE_PT_ADDBITS15
6902 | OPTS_TYPE_ST_HEX;
6903 kern_type = KERN_TYPE_SHA1_SLTPW;
6904 dgst_size = DGST_SIZE_4_5;
6905 parse_func = osx1_parse_hash;
6906 sort_by_digest = sort_by_digest_4_5;
6907 opti_type = OPTI_TYPE_ZERO_BYTE
6908 | OPTI_TYPE_PRECOMPUTE_INIT
6909 | OPTI_TYPE_PRECOMPUTE_MERKLE
6910 | OPTI_TYPE_EARLY_SKIP
6911 | OPTI_TYPE_NOT_ITERATED
6912 | OPTI_TYPE_PREPENDED_SALT
6913 | OPTI_TYPE_RAW_HASH;
6914 dgst_pos0 = 3;
6915 dgst_pos1 = 4;
6916 dgst_pos2 = 2;
6917 dgst_pos3 = 1;
6918 break;
6919
6920 case 124: hash_type = HASH_TYPE_SHA1;
6921 salt_type = SALT_TYPE_EMBEDDED;
6922 attack_exec = ATTACK_EXEC_ON_GPU;
6923 opts_type = OPTS_TYPE_PT_GENERATE_BE
6924 | OPTS_TYPE_PT_ADD80
6925 | OPTS_TYPE_PT_ADDBITS15;
6926 kern_type = KERN_TYPE_SHA1_SLTPW;
6927 dgst_size = DGST_SIZE_4_5;
6928 parse_func = djangosha1_parse_hash;
6929 sort_by_digest = sort_by_digest_4_5;
6930 opti_type = OPTI_TYPE_ZERO_BYTE
6931 | OPTI_TYPE_PRECOMPUTE_INIT
6932 | OPTI_TYPE_PRECOMPUTE_MERKLE
6933 | OPTI_TYPE_EARLY_SKIP
6934 | OPTI_TYPE_NOT_ITERATED
6935 | OPTI_TYPE_PREPENDED_SALT
6936 | OPTI_TYPE_RAW_HASH;
6937 dgst_pos0 = 3;
6938 dgst_pos1 = 4;
6939 dgst_pos2 = 2;
6940 dgst_pos3 = 1;
6941 break;
6942
6943 case 130: hash_type = HASH_TYPE_SHA1;
6944 salt_type = SALT_TYPE_INTERN;
6945 attack_exec = ATTACK_EXEC_ON_GPU;
6946 opts_type = OPTS_TYPE_PT_GENERATE_BE
6947 | OPTS_TYPE_PT_UNICODE
6948 | OPTS_TYPE_ST_ADD80
6949 | OPTS_TYPE_ST_ADDBITS15;
6950 kern_type = KERN_TYPE_SHA1_PWUSLT;
6951 dgst_size = DGST_SIZE_4_5;
6952 parse_func = sha1s_parse_hash;
6953 sort_by_digest = sort_by_digest_4_5;
6954 opti_type = OPTI_TYPE_ZERO_BYTE
6955 | OPTI_TYPE_PRECOMPUTE_INIT
6956 | OPTI_TYPE_PRECOMPUTE_MERKLE
6957 | OPTI_TYPE_EARLY_SKIP
6958 | OPTI_TYPE_NOT_ITERATED
6959 | OPTI_TYPE_APPENDED_SALT
6960 | OPTI_TYPE_RAW_HASH;
6961 dgst_pos0 = 3;
6962 dgst_pos1 = 4;
6963 dgst_pos2 = 2;
6964 dgst_pos3 = 1;
6965 break;
6966
6967 case 131: hash_type = HASH_TYPE_SHA1;
6968 salt_type = SALT_TYPE_EMBEDDED;
6969 attack_exec = ATTACK_EXEC_ON_GPU;
6970 opts_type = OPTS_TYPE_PT_GENERATE_BE
6971 | OPTS_TYPE_PT_UNICODE
6972 | OPTS_TYPE_PT_UPPER
6973 | OPTS_TYPE_ST_ADD80
6974 | OPTS_TYPE_ST_ADDBITS15
6975 | OPTS_TYPE_ST_HEX;
6976 kern_type = KERN_TYPE_SHA1_PWUSLT;
6977 dgst_size = DGST_SIZE_4_5;
6978 parse_func = mssql2000_parse_hash;
6979 sort_by_digest = sort_by_digest_4_5;
6980 opti_type = OPTI_TYPE_ZERO_BYTE
6981 | OPTI_TYPE_PRECOMPUTE_INIT
6982 | OPTI_TYPE_PRECOMPUTE_MERKLE
6983 | OPTI_TYPE_EARLY_SKIP
6984 | OPTI_TYPE_NOT_ITERATED
6985 | OPTI_TYPE_APPENDED_SALT
6986 | OPTI_TYPE_RAW_HASH;
6987 dgst_pos0 = 3;
6988 dgst_pos1 = 4;
6989 dgst_pos2 = 2;
6990 dgst_pos3 = 1;
6991 break;
6992
6993 case 132: hash_type = HASH_TYPE_SHA1;
6994 salt_type = SALT_TYPE_EMBEDDED;
6995 attack_exec = ATTACK_EXEC_ON_GPU;
6996 opts_type = OPTS_TYPE_PT_GENERATE_BE
6997 | OPTS_TYPE_PT_UNICODE
6998 | OPTS_TYPE_ST_ADD80
6999 | OPTS_TYPE_ST_ADDBITS15
7000 | OPTS_TYPE_ST_HEX;
7001 kern_type = KERN_TYPE_SHA1_PWUSLT;
7002 dgst_size = DGST_SIZE_4_5;
7003 parse_func = mssql2005_parse_hash;
7004 sort_by_digest = sort_by_digest_4_5;
7005 opti_type = OPTI_TYPE_ZERO_BYTE
7006 | OPTI_TYPE_PRECOMPUTE_INIT
7007 | OPTI_TYPE_PRECOMPUTE_MERKLE
7008 | OPTI_TYPE_EARLY_SKIP
7009 | OPTI_TYPE_NOT_ITERATED
7010 | OPTI_TYPE_APPENDED_SALT
7011 | OPTI_TYPE_RAW_HASH;
7012 dgst_pos0 = 3;
7013 dgst_pos1 = 4;
7014 dgst_pos2 = 2;
7015 dgst_pos3 = 1;
7016 break;
7017
7018 case 133: hash_type = HASH_TYPE_SHA1;
7019 salt_type = SALT_TYPE_EMBEDDED;
7020 attack_exec = ATTACK_EXEC_ON_GPU;
7021 opts_type = OPTS_TYPE_PT_GENERATE_BE
7022 | OPTS_TYPE_PT_UNICODE
7023 | OPTS_TYPE_ST_ADD80
7024 | OPTS_TYPE_ST_ADDBITS15;
7025 kern_type = KERN_TYPE_SHA1_PWUSLT;
7026 dgst_size = DGST_SIZE_4_5;
7027 parse_func = peoplesoft_parse_hash;
7028 sort_by_digest = sort_by_digest_4_5;
7029 opti_type = OPTI_TYPE_ZERO_BYTE
7030 | OPTI_TYPE_PRECOMPUTE_INIT
7031 | OPTI_TYPE_PRECOMPUTE_MERKLE
7032 | OPTI_TYPE_EARLY_SKIP
7033 | OPTI_TYPE_NOT_ITERATED
7034 | OPTI_TYPE_APPENDED_SALT
7035 | OPTI_TYPE_RAW_HASH;
7036 dgst_pos0 = 3;
7037 dgst_pos1 = 4;
7038 dgst_pos2 = 2;
7039 dgst_pos3 = 1;
7040 break;
7041
7042 case 140: hash_type = HASH_TYPE_SHA1;
7043 salt_type = SALT_TYPE_INTERN;
7044 attack_exec = ATTACK_EXEC_ON_GPU;
7045 opts_type = OPTS_TYPE_PT_GENERATE_BE
7046 | OPTS_TYPE_PT_ADD80
7047 | OPTS_TYPE_PT_ADDBITS15
7048 | OPTS_TYPE_PT_UNICODE;
7049 kern_type = KERN_TYPE_SHA1_SLTPWU;
7050 dgst_size = DGST_SIZE_4_5;
7051 parse_func = sha1s_parse_hash;
7052 sort_by_digest = sort_by_digest_4_5;
7053 opti_type = OPTI_TYPE_ZERO_BYTE
7054 | OPTI_TYPE_PRECOMPUTE_INIT
7055 | OPTI_TYPE_PRECOMPUTE_MERKLE
7056 | OPTI_TYPE_EARLY_SKIP
7057 | OPTI_TYPE_NOT_ITERATED
7058 | OPTI_TYPE_PREPENDED_SALT
7059 | OPTI_TYPE_RAW_HASH;
7060 dgst_pos0 = 3;
7061 dgst_pos1 = 4;
7062 dgst_pos2 = 2;
7063 dgst_pos3 = 1;
7064 break;
7065
7066 case 141: hash_type = HASH_TYPE_SHA1;
7067 salt_type = SALT_TYPE_EMBEDDED;
7068 attack_exec = ATTACK_EXEC_ON_GPU;
7069 opts_type = OPTS_TYPE_PT_GENERATE_BE
7070 | OPTS_TYPE_PT_ADD80
7071 | OPTS_TYPE_PT_ADDBITS15
7072 | OPTS_TYPE_PT_UNICODE
7073 | OPTS_TYPE_ST_BASE64;
7074 kern_type = KERN_TYPE_SHA1_SLTPWU;
7075 dgst_size = DGST_SIZE_4_5;
7076 parse_func = episerver_parse_hash;
7077 sort_by_digest = sort_by_digest_4_5;
7078 opti_type = OPTI_TYPE_ZERO_BYTE
7079 | OPTI_TYPE_PRECOMPUTE_INIT
7080 | OPTI_TYPE_PRECOMPUTE_MERKLE
7081 | OPTI_TYPE_EARLY_SKIP
7082 | OPTI_TYPE_NOT_ITERATED
7083 | OPTI_TYPE_PREPENDED_SALT
7084 | OPTI_TYPE_RAW_HASH;
7085 dgst_pos0 = 3;
7086 dgst_pos1 = 4;
7087 dgst_pos2 = 2;
7088 dgst_pos3 = 1;
7089 break;
7090
7091 case 150: hash_type = HASH_TYPE_SHA1;
7092 salt_type = SALT_TYPE_INTERN;
7093 attack_exec = ATTACK_EXEC_ON_GPU;
7094 opts_type = OPTS_TYPE_PT_GENERATE_BE
7095 | OPTS_TYPE_ST_ADD80
7096 | OPTS_TYPE_ST_ADDBITS15;
7097 kern_type = KERN_TYPE_HMACSHA1_PW;
7098 dgst_size = DGST_SIZE_4_5;
7099 parse_func = hmacsha1_parse_hash;
7100 sort_by_digest = sort_by_digest_4_5;
7101 opti_type = OPTI_TYPE_ZERO_BYTE
7102 | OPTI_TYPE_NOT_ITERATED;
7103 dgst_pos0 = 3;
7104 dgst_pos1 = 4;
7105 dgst_pos2 = 2;
7106 dgst_pos3 = 1;
7107 break;
7108
7109 case 160: hash_type = HASH_TYPE_SHA1;
7110 salt_type = SALT_TYPE_INTERN;
7111 attack_exec = ATTACK_EXEC_ON_GPU;
7112 opts_type = OPTS_TYPE_PT_GENERATE_BE
7113 | OPTS_TYPE_PT_ADD80
7114 | OPTS_TYPE_PT_ADDBITS15;
7115 kern_type = KERN_TYPE_HMACSHA1_SLT;
7116 dgst_size = DGST_SIZE_4_5;
7117 parse_func = hmacsha1_parse_hash;
7118 sort_by_digest = sort_by_digest_4_5;
7119 opti_type = OPTI_TYPE_ZERO_BYTE
7120 | OPTI_TYPE_NOT_ITERATED;
7121 dgst_pos0 = 3;
7122 dgst_pos1 = 4;
7123 dgst_pos2 = 2;
7124 dgst_pos3 = 1;
7125 break;
7126
7127 case 190: hash_type = HASH_TYPE_SHA1;
7128 salt_type = SALT_TYPE_NONE;
7129 attack_exec = ATTACK_EXEC_ON_GPU;
7130 opts_type = OPTS_TYPE_PT_GENERATE_BE
7131 | OPTS_TYPE_PT_ADD80
7132 | OPTS_TYPE_PT_ADDBITS15;
7133 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7134 dgst_size = DGST_SIZE_4_5;
7135 parse_func = sha1linkedin_parse_hash;
7136 sort_by_digest = sort_by_digest_4_5;
7137 opti_type = OPTI_TYPE_ZERO_BYTE
7138 | OPTI_TYPE_PRECOMPUTE_INIT
7139 | OPTI_TYPE_EARLY_SKIP
7140 | OPTI_TYPE_NOT_ITERATED
7141 | OPTI_TYPE_NOT_SALTED;
7142 dgst_pos0 = 0;
7143 dgst_pos1 = 4;
7144 dgst_pos2 = 3;
7145 dgst_pos3 = 2;
7146 break;
7147
7148 case 200: hash_type = HASH_TYPE_MYSQL;
7149 salt_type = SALT_TYPE_NONE;
7150 attack_exec = ATTACK_EXEC_ON_GPU;
7151 opts_type = 0;
7152 kern_type = KERN_TYPE_MYSQL;
7153 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7154 parse_func = mysql323_parse_hash;
7155 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7156 opti_type = OPTI_TYPE_ZERO_BYTE;
7157 dgst_pos0 = 0;
7158 dgst_pos1 = 1;
7159 dgst_pos2 = 2;
7160 dgst_pos3 = 3;
7161 break;
7162
7163 case 300: hash_type = HASH_TYPE_SHA1;
7164 salt_type = SALT_TYPE_NONE;
7165 attack_exec = ATTACK_EXEC_ON_GPU;
7166 opts_type = OPTS_TYPE_PT_GENERATE_BE
7167 | OPTS_TYPE_PT_ADD80
7168 | OPTS_TYPE_PT_ADDBITS15;
7169 kern_type = KERN_TYPE_MYSQL41;
7170 dgst_size = DGST_SIZE_4_5;
7171 parse_func = sha1_parse_hash;
7172 sort_by_digest = sort_by_digest_4_5;
7173 opti_type = OPTI_TYPE_ZERO_BYTE
7174 | OPTI_TYPE_PRECOMPUTE_INIT
7175 | OPTI_TYPE_PRECOMPUTE_MERKLE
7176 | OPTI_TYPE_EARLY_SKIP
7177 | OPTI_TYPE_NOT_ITERATED
7178 | OPTI_TYPE_NOT_SALTED;
7179 dgst_pos0 = 3;
7180 dgst_pos1 = 4;
7181 dgst_pos2 = 2;
7182 dgst_pos3 = 1;
7183 break;
7184
7185 case 400: hash_type = HASH_TYPE_MD5;
7186 salt_type = SALT_TYPE_EMBEDDED;
7187 attack_exec = ATTACK_EXEC_ON_CPU;
7188 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7189 kern_type = KERN_TYPE_PHPASS;
7190 dgst_size = DGST_SIZE_4_4;
7191 parse_func = phpass_parse_hash;
7192 sort_by_digest = sort_by_digest_4_4;
7193 opti_type = OPTI_TYPE_ZERO_BYTE;
7194 dgst_pos0 = 0;
7195 dgst_pos1 = 1;
7196 dgst_pos2 = 2;
7197 dgst_pos3 = 3;
7198 break;
7199
7200 case 500: hash_type = HASH_TYPE_MD5;
7201 salt_type = SALT_TYPE_EMBEDDED;
7202 attack_exec = ATTACK_EXEC_ON_CPU;
7203 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7204 kern_type = KERN_TYPE_MD5CRYPT;
7205 dgst_size = DGST_SIZE_4_4;
7206 parse_func = md5crypt_parse_hash;
7207 sort_by_digest = sort_by_digest_4_4;
7208 opti_type = OPTI_TYPE_ZERO_BYTE;
7209 dgst_pos0 = 0;
7210 dgst_pos1 = 1;
7211 dgst_pos2 = 2;
7212 dgst_pos3 = 3;
7213 break;
7214
7215 case 501: hash_type = HASH_TYPE_MD5;
7216 salt_type = SALT_TYPE_EMBEDDED;
7217 attack_exec = ATTACK_EXEC_ON_CPU;
7218 opts_type = OPTS_TYPE_PT_GENERATE_LE
7219 | OPTS_TYPE_HASH_COPY;
7220 kern_type = KERN_TYPE_MD5CRYPT;
7221 dgst_size = DGST_SIZE_4_4;
7222 parse_func = juniper_parse_hash;
7223 sort_by_digest = sort_by_digest_4_4;
7224 opti_type = OPTI_TYPE_ZERO_BYTE;
7225 dgst_pos0 = 0;
7226 dgst_pos1 = 1;
7227 dgst_pos2 = 2;
7228 dgst_pos3 = 3;
7229 break;
7230
7231 case 900: hash_type = HASH_TYPE_MD4;
7232 salt_type = SALT_TYPE_NONE;
7233 attack_exec = ATTACK_EXEC_ON_GPU;
7234 opts_type = OPTS_TYPE_PT_GENERATE_LE
7235 | OPTS_TYPE_PT_ADD80
7236 | OPTS_TYPE_PT_ADDBITS14;
7237 kern_type = KERN_TYPE_MD4;
7238 dgst_size = DGST_SIZE_4_4;
7239 parse_func = md4_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_MEET_IN_MIDDLE
7245 | OPTI_TYPE_EARLY_SKIP
7246 | OPTI_TYPE_NOT_ITERATED
7247 | OPTI_TYPE_NOT_SALTED
7248 | OPTI_TYPE_RAW_HASH;
7249 dgst_pos0 = 0;
7250 dgst_pos1 = 3;
7251 dgst_pos2 = 2;
7252 dgst_pos3 = 1;
7253 break;
7254
7255 case 1000: hash_type = HASH_TYPE_MD4;
7256 salt_type = SALT_TYPE_NONE;
7257 attack_exec = ATTACK_EXEC_ON_GPU;
7258 opts_type = OPTS_TYPE_PT_GENERATE_LE
7259 | OPTS_TYPE_PT_ADD80
7260 | OPTS_TYPE_PT_ADDBITS14
7261 | OPTS_TYPE_PT_UNICODE;
7262 kern_type = KERN_TYPE_MD4_PWU;
7263 dgst_size = DGST_SIZE_4_4;
7264 parse_func = md4_parse_hash;
7265 sort_by_digest = sort_by_digest_4_4;
7266 opti_type = OPTI_TYPE_ZERO_BYTE
7267 | OPTI_TYPE_PRECOMPUTE_INIT
7268 | OPTI_TYPE_PRECOMPUTE_MERKLE
7269 | OPTI_TYPE_MEET_IN_MIDDLE
7270 | OPTI_TYPE_EARLY_SKIP
7271 | OPTI_TYPE_NOT_ITERATED
7272 | OPTI_TYPE_NOT_SALTED
7273 | OPTI_TYPE_RAW_HASH;
7274 dgst_pos0 = 0;
7275 dgst_pos1 = 3;
7276 dgst_pos2 = 2;
7277 dgst_pos3 = 1;
7278 break;
7279
7280 case 1100: hash_type = HASH_TYPE_MD4;
7281 salt_type = SALT_TYPE_INTERN;
7282 attack_exec = ATTACK_EXEC_ON_GPU;
7283 opts_type = OPTS_TYPE_PT_GENERATE_LE
7284 | OPTS_TYPE_PT_ADD80
7285 | OPTS_TYPE_PT_ADDBITS14
7286 | OPTS_TYPE_PT_UNICODE
7287 | OPTS_TYPE_ST_ADD80
7288 | OPTS_TYPE_ST_UNICODE
7289 | OPTS_TYPE_ST_LOWER;
7290 kern_type = KERN_TYPE_MD44_PWUSLT;
7291 dgst_size = DGST_SIZE_4_4;
7292 parse_func = dcc_parse_hash;
7293 sort_by_digest = sort_by_digest_4_4;
7294 opti_type = OPTI_TYPE_ZERO_BYTE
7295 | OPTI_TYPE_PRECOMPUTE_INIT
7296 | OPTI_TYPE_PRECOMPUTE_MERKLE
7297 | OPTI_TYPE_EARLY_SKIP
7298 | OPTI_TYPE_NOT_ITERATED;
7299 dgst_pos0 = 0;
7300 dgst_pos1 = 3;
7301 dgst_pos2 = 2;
7302 dgst_pos3 = 1;
7303 break;
7304
7305 case 1400: hash_type = HASH_TYPE_SHA256;
7306 salt_type = SALT_TYPE_NONE;
7307 attack_exec = ATTACK_EXEC_ON_GPU;
7308 opts_type = OPTS_TYPE_PT_GENERATE_BE
7309 | OPTS_TYPE_PT_ADD80
7310 | OPTS_TYPE_PT_ADDBITS15;
7311 kern_type = KERN_TYPE_SHA256;
7312 dgst_size = DGST_SIZE_4_8;
7313 parse_func = sha256_parse_hash;
7314 sort_by_digest = sort_by_digest_4_8;
7315 opti_type = OPTI_TYPE_ZERO_BYTE
7316 | OPTI_TYPE_PRECOMPUTE_INIT
7317 | OPTI_TYPE_PRECOMPUTE_MERKLE
7318 | OPTI_TYPE_EARLY_SKIP
7319 | OPTI_TYPE_NOT_ITERATED
7320 | OPTI_TYPE_NOT_SALTED
7321 | OPTI_TYPE_RAW_HASH;
7322 dgst_pos0 = 3;
7323 dgst_pos1 = 7;
7324 dgst_pos2 = 2;
7325 dgst_pos3 = 6;
7326 break;
7327
7328 case 1410: hash_type = HASH_TYPE_SHA256;
7329 salt_type = SALT_TYPE_INTERN;
7330 attack_exec = ATTACK_EXEC_ON_GPU;
7331 opts_type = OPTS_TYPE_PT_GENERATE_BE
7332 | OPTS_TYPE_ST_ADD80
7333 | OPTS_TYPE_ST_ADDBITS15;
7334 kern_type = KERN_TYPE_SHA256_PWSLT;
7335 dgst_size = DGST_SIZE_4_8;
7336 parse_func = sha256s_parse_hash;
7337 sort_by_digest = sort_by_digest_4_8;
7338 opti_type = OPTI_TYPE_ZERO_BYTE
7339 | OPTI_TYPE_PRECOMPUTE_INIT
7340 | OPTI_TYPE_PRECOMPUTE_MERKLE
7341 | OPTI_TYPE_EARLY_SKIP
7342 | OPTI_TYPE_NOT_ITERATED
7343 | OPTI_TYPE_APPENDED_SALT
7344 | OPTI_TYPE_RAW_HASH;
7345 dgst_pos0 = 3;
7346 dgst_pos1 = 7;
7347 dgst_pos2 = 2;
7348 dgst_pos3 = 6;
7349 break;
7350
7351 case 1420: hash_type = HASH_TYPE_SHA256;
7352 salt_type = SALT_TYPE_INTERN;
7353 attack_exec = ATTACK_EXEC_ON_GPU;
7354 opts_type = OPTS_TYPE_PT_GENERATE_BE
7355 | OPTS_TYPE_PT_ADD80
7356 | OPTS_TYPE_PT_ADDBITS15;
7357 kern_type = KERN_TYPE_SHA256_SLTPW;
7358 dgst_size = DGST_SIZE_4_8;
7359 parse_func = sha256s_parse_hash;
7360 sort_by_digest = sort_by_digest_4_8;
7361 opti_type = OPTI_TYPE_ZERO_BYTE
7362 | OPTI_TYPE_PRECOMPUTE_INIT
7363 | OPTI_TYPE_PRECOMPUTE_MERKLE
7364 | OPTI_TYPE_EARLY_SKIP
7365 | OPTI_TYPE_NOT_ITERATED
7366 | OPTI_TYPE_PREPENDED_SALT
7367 | OPTI_TYPE_RAW_HASH;
7368 dgst_pos0 = 3;
7369 dgst_pos1 = 7;
7370 dgst_pos2 = 2;
7371 dgst_pos3 = 6;
7372 break;
7373
7374 case 1421: hash_type = HASH_TYPE_SHA256;
7375 salt_type = SALT_TYPE_EMBEDDED;
7376 attack_exec = ATTACK_EXEC_ON_GPU;
7377 opts_type = OPTS_TYPE_PT_GENERATE_BE
7378 | OPTS_TYPE_PT_ADD80
7379 | OPTS_TYPE_PT_ADDBITS15;
7380 kern_type = KERN_TYPE_SHA256_SLTPW;
7381 dgst_size = DGST_SIZE_4_8;
7382 parse_func = hmailserver_parse_hash;
7383 sort_by_digest = sort_by_digest_4_8;
7384 opti_type = OPTI_TYPE_ZERO_BYTE
7385 | OPTI_TYPE_PRECOMPUTE_INIT
7386 | OPTI_TYPE_PRECOMPUTE_MERKLE
7387 | OPTI_TYPE_EARLY_SKIP
7388 | OPTI_TYPE_NOT_ITERATED
7389 | OPTI_TYPE_PREPENDED_SALT
7390 | OPTI_TYPE_RAW_HASH;
7391 dgst_pos0 = 3;
7392 dgst_pos1 = 7;
7393 dgst_pos2 = 2;
7394 dgst_pos3 = 6;
7395 break;
7396
7397 case 1430: hash_type = HASH_TYPE_SHA256;
7398 salt_type = SALT_TYPE_INTERN;
7399 attack_exec = ATTACK_EXEC_ON_GPU;
7400 opts_type = OPTS_TYPE_PT_GENERATE_BE
7401 | OPTS_TYPE_PT_UNICODE
7402 | OPTS_TYPE_ST_ADD80
7403 | OPTS_TYPE_ST_ADDBITS15;
7404 kern_type = KERN_TYPE_SHA256_PWUSLT;
7405 dgst_size = DGST_SIZE_4_8;
7406 parse_func = sha256s_parse_hash;
7407 sort_by_digest = sort_by_digest_4_8;
7408 opti_type = OPTI_TYPE_ZERO_BYTE
7409 | OPTI_TYPE_PRECOMPUTE_INIT
7410 | OPTI_TYPE_PRECOMPUTE_MERKLE
7411 | OPTI_TYPE_EARLY_SKIP
7412 | OPTI_TYPE_NOT_ITERATED
7413 | OPTI_TYPE_APPENDED_SALT
7414 | OPTI_TYPE_RAW_HASH;
7415 dgst_pos0 = 3;
7416 dgst_pos1 = 7;
7417 dgst_pos2 = 2;
7418 dgst_pos3 = 6;
7419 break;
7420
7421 case 1440: hash_type = HASH_TYPE_SHA256;
7422 salt_type = SALT_TYPE_INTERN;
7423 attack_exec = ATTACK_EXEC_ON_GPU;
7424 opts_type = OPTS_TYPE_PT_GENERATE_BE
7425 | OPTS_TYPE_PT_ADD80
7426 | OPTS_TYPE_PT_ADDBITS15
7427 | OPTS_TYPE_PT_UNICODE;
7428 kern_type = KERN_TYPE_SHA256_SLTPWU;
7429 dgst_size = DGST_SIZE_4_8;
7430 parse_func = sha256s_parse_hash;
7431 sort_by_digest = sort_by_digest_4_8;
7432 opti_type = OPTI_TYPE_ZERO_BYTE
7433 | OPTI_TYPE_PRECOMPUTE_INIT
7434 | OPTI_TYPE_PRECOMPUTE_MERKLE
7435 | OPTI_TYPE_EARLY_SKIP
7436 | OPTI_TYPE_NOT_ITERATED
7437 | OPTI_TYPE_PREPENDED_SALT
7438 | OPTI_TYPE_RAW_HASH;
7439 dgst_pos0 = 3;
7440 dgst_pos1 = 7;
7441 dgst_pos2 = 2;
7442 dgst_pos3 = 6;
7443 break;
7444
7445 case 1441: hash_type = HASH_TYPE_SHA256;
7446 salt_type = SALT_TYPE_EMBEDDED;
7447 attack_exec = ATTACK_EXEC_ON_GPU;
7448 opts_type = OPTS_TYPE_PT_GENERATE_BE
7449 | OPTS_TYPE_PT_ADD80
7450 | OPTS_TYPE_PT_ADDBITS15
7451 | OPTS_TYPE_PT_UNICODE
7452 | OPTS_TYPE_ST_BASE64;
7453 kern_type = KERN_TYPE_SHA256_SLTPWU;
7454 dgst_size = DGST_SIZE_4_8;
7455 parse_func = episerver4_parse_hash;
7456 sort_by_digest = sort_by_digest_4_8;
7457 opti_type = OPTI_TYPE_ZERO_BYTE
7458 | OPTI_TYPE_PRECOMPUTE_INIT
7459 | OPTI_TYPE_PRECOMPUTE_MERKLE
7460 | OPTI_TYPE_EARLY_SKIP
7461 | OPTI_TYPE_NOT_ITERATED
7462 | OPTI_TYPE_PREPENDED_SALT
7463 | OPTI_TYPE_RAW_HASH;
7464 dgst_pos0 = 3;
7465 dgst_pos1 = 7;
7466 dgst_pos2 = 2;
7467 dgst_pos3 = 6;
7468 break;
7469
7470 case 1450: hash_type = HASH_TYPE_SHA256;
7471 salt_type = SALT_TYPE_INTERN;
7472 attack_exec = ATTACK_EXEC_ON_GPU;
7473 opts_type = OPTS_TYPE_PT_GENERATE_BE
7474 | OPTS_TYPE_ST_ADD80;
7475 kern_type = KERN_TYPE_HMACSHA256_PW;
7476 dgst_size = DGST_SIZE_4_8;
7477 parse_func = hmacsha256_parse_hash;
7478 sort_by_digest = sort_by_digest_4_8;
7479 opti_type = OPTI_TYPE_ZERO_BYTE
7480 | OPTI_TYPE_NOT_ITERATED;
7481 dgst_pos0 = 3;
7482 dgst_pos1 = 7;
7483 dgst_pos2 = 2;
7484 dgst_pos3 = 6;
7485 break;
7486
7487 case 1460: hash_type = HASH_TYPE_SHA256;
7488 salt_type = SALT_TYPE_INTERN;
7489 attack_exec = ATTACK_EXEC_ON_GPU;
7490 opts_type = OPTS_TYPE_PT_GENERATE_BE
7491 | OPTS_TYPE_PT_ADD80
7492 | OPTS_TYPE_PT_ADDBITS15;
7493 kern_type = KERN_TYPE_HMACSHA256_SLT;
7494 dgst_size = DGST_SIZE_4_8;
7495 parse_func = hmacsha256_parse_hash;
7496 sort_by_digest = sort_by_digest_4_8;
7497 opti_type = OPTI_TYPE_ZERO_BYTE
7498 | OPTI_TYPE_NOT_ITERATED;
7499 dgst_pos0 = 3;
7500 dgst_pos1 = 7;
7501 dgst_pos2 = 2;
7502 dgst_pos3 = 6;
7503 break;
7504
7505 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7506 salt_type = SALT_TYPE_EMBEDDED;
7507 attack_exec = ATTACK_EXEC_ON_GPU;
7508 opts_type = OPTS_TYPE_PT_GENERATE_LE
7509 | OPTS_TYPE_PT_BITSLICE;
7510 kern_type = KERN_TYPE_DESCRYPT;
7511 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7512 parse_func = descrypt_parse_hash;
7513 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7514 opti_type = OPTI_TYPE_ZERO_BYTE
7515 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7516 dgst_pos0 = 0;
7517 dgst_pos1 = 1;
7518 dgst_pos2 = 2;
7519 dgst_pos3 = 3;
7520 break;
7521
7522 case 1600: hash_type = HASH_TYPE_MD5;
7523 salt_type = SALT_TYPE_EMBEDDED;
7524 attack_exec = ATTACK_EXEC_ON_CPU;
7525 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7526 kern_type = KERN_TYPE_APR1CRYPT;
7527 dgst_size = DGST_SIZE_4_4;
7528 parse_func = md5apr1_parse_hash;
7529 sort_by_digest = sort_by_digest_4_4;
7530 opti_type = OPTI_TYPE_ZERO_BYTE;
7531 dgst_pos0 = 0;
7532 dgst_pos1 = 1;
7533 dgst_pos2 = 2;
7534 dgst_pos3 = 3;
7535 break;
7536
7537 case 1700: hash_type = HASH_TYPE_SHA512;
7538 salt_type = SALT_TYPE_NONE;
7539 attack_exec = ATTACK_EXEC_ON_GPU;
7540 opts_type = OPTS_TYPE_PT_GENERATE_BE
7541 | OPTS_TYPE_PT_ADD80
7542 | OPTS_TYPE_PT_ADDBITS15;
7543 kern_type = KERN_TYPE_SHA512;
7544 dgst_size = DGST_SIZE_8_8;
7545 parse_func = sha512_parse_hash;
7546 sort_by_digest = sort_by_digest_8_8;
7547 opti_type = OPTI_TYPE_ZERO_BYTE
7548 | OPTI_TYPE_PRECOMPUTE_INIT
7549 | OPTI_TYPE_PRECOMPUTE_MERKLE
7550 | OPTI_TYPE_EARLY_SKIP
7551 | OPTI_TYPE_NOT_ITERATED
7552 | OPTI_TYPE_NOT_SALTED
7553 | OPTI_TYPE_RAW_HASH;
7554 dgst_pos0 = 14;
7555 dgst_pos1 = 15;
7556 dgst_pos2 = 6;
7557 dgst_pos3 = 7;
7558 break;
7559
7560 case 1710: hash_type = HASH_TYPE_SHA512;
7561 salt_type = SALT_TYPE_INTERN;
7562 attack_exec = ATTACK_EXEC_ON_GPU;
7563 opts_type = OPTS_TYPE_PT_GENERATE_BE
7564 | OPTS_TYPE_ST_ADD80
7565 | OPTS_TYPE_ST_ADDBITS15;
7566 kern_type = KERN_TYPE_SHA512_PWSLT;
7567 dgst_size = DGST_SIZE_8_8;
7568 parse_func = sha512s_parse_hash;
7569 sort_by_digest = sort_by_digest_8_8;
7570 opti_type = OPTI_TYPE_ZERO_BYTE
7571 | OPTI_TYPE_PRECOMPUTE_INIT
7572 | OPTI_TYPE_PRECOMPUTE_MERKLE
7573 | OPTI_TYPE_EARLY_SKIP
7574 | OPTI_TYPE_NOT_ITERATED
7575 | OPTI_TYPE_APPENDED_SALT
7576 | OPTI_TYPE_RAW_HASH;
7577 dgst_pos0 = 14;
7578 dgst_pos1 = 15;
7579 dgst_pos2 = 6;
7580 dgst_pos3 = 7;
7581 break;
7582
7583 case 1711: hash_type = HASH_TYPE_SHA512;
7584 salt_type = SALT_TYPE_EMBEDDED;
7585 attack_exec = ATTACK_EXEC_ON_GPU;
7586 opts_type = OPTS_TYPE_PT_GENERATE_BE
7587 | OPTS_TYPE_ST_ADD80
7588 | OPTS_TYPE_ST_ADDBITS15;
7589 kern_type = KERN_TYPE_SHA512_PWSLT;
7590 dgst_size = DGST_SIZE_8_8;
7591 parse_func = sha512b64s_parse_hash;
7592 sort_by_digest = sort_by_digest_8_8;
7593 opti_type = OPTI_TYPE_ZERO_BYTE
7594 | OPTI_TYPE_PRECOMPUTE_INIT
7595 | OPTI_TYPE_PRECOMPUTE_MERKLE
7596 | OPTI_TYPE_EARLY_SKIP
7597 | OPTI_TYPE_NOT_ITERATED
7598 | OPTI_TYPE_APPENDED_SALT
7599 | OPTI_TYPE_RAW_HASH;
7600 dgst_pos0 = 14;
7601 dgst_pos1 = 15;
7602 dgst_pos2 = 6;
7603 dgst_pos3 = 7;
7604 break;
7605
7606 case 1720: hash_type = HASH_TYPE_SHA512;
7607 salt_type = SALT_TYPE_INTERN;
7608 attack_exec = ATTACK_EXEC_ON_GPU;
7609 opts_type = OPTS_TYPE_PT_GENERATE_BE
7610 | OPTS_TYPE_PT_ADD80
7611 | OPTS_TYPE_PT_ADDBITS15;
7612 kern_type = KERN_TYPE_SHA512_SLTPW;
7613 dgst_size = DGST_SIZE_8_8;
7614 parse_func = sha512s_parse_hash;
7615 sort_by_digest = sort_by_digest_8_8;
7616 opti_type = OPTI_TYPE_ZERO_BYTE
7617 | OPTI_TYPE_PRECOMPUTE_INIT
7618 | OPTI_TYPE_PRECOMPUTE_MERKLE
7619 | OPTI_TYPE_EARLY_SKIP
7620 | OPTI_TYPE_NOT_ITERATED
7621 | OPTI_TYPE_PREPENDED_SALT
7622 | OPTI_TYPE_RAW_HASH;
7623 dgst_pos0 = 14;
7624 dgst_pos1 = 15;
7625 dgst_pos2 = 6;
7626 dgst_pos3 = 7;
7627 break;
7628
7629 case 1722: hash_type = HASH_TYPE_SHA512;
7630 salt_type = SALT_TYPE_EMBEDDED;
7631 attack_exec = ATTACK_EXEC_ON_GPU;
7632 opts_type = OPTS_TYPE_PT_GENERATE_BE
7633 | OPTS_TYPE_PT_ADD80
7634 | OPTS_TYPE_PT_ADDBITS15
7635 | OPTS_TYPE_ST_HEX;
7636 kern_type = KERN_TYPE_SHA512_SLTPW;
7637 dgst_size = DGST_SIZE_8_8;
7638 parse_func = osx512_parse_hash;
7639 sort_by_digest = sort_by_digest_8_8;
7640 opti_type = OPTI_TYPE_ZERO_BYTE
7641 | OPTI_TYPE_PRECOMPUTE_INIT
7642 | OPTI_TYPE_PRECOMPUTE_MERKLE
7643 | OPTI_TYPE_EARLY_SKIP
7644 | OPTI_TYPE_NOT_ITERATED
7645 | OPTI_TYPE_PREPENDED_SALT
7646 | OPTI_TYPE_RAW_HASH;
7647 dgst_pos0 = 14;
7648 dgst_pos1 = 15;
7649 dgst_pos2 = 6;
7650 dgst_pos3 = 7;
7651 break;
7652
7653 case 1730: hash_type = HASH_TYPE_SHA512;
7654 salt_type = SALT_TYPE_INTERN;
7655 attack_exec = ATTACK_EXEC_ON_GPU;
7656 opts_type = OPTS_TYPE_PT_GENERATE_BE
7657 | OPTS_TYPE_PT_UNICODE
7658 | OPTS_TYPE_ST_ADD80
7659 | OPTS_TYPE_ST_ADDBITS15;
7660 kern_type = KERN_TYPE_SHA512_PWSLTU;
7661 dgst_size = DGST_SIZE_8_8;
7662 parse_func = sha512s_parse_hash;
7663 sort_by_digest = sort_by_digest_8_8;
7664 opti_type = OPTI_TYPE_ZERO_BYTE
7665 | OPTI_TYPE_PRECOMPUTE_INIT
7666 | OPTI_TYPE_PRECOMPUTE_MERKLE
7667 | OPTI_TYPE_EARLY_SKIP
7668 | OPTI_TYPE_NOT_ITERATED
7669 | OPTI_TYPE_APPENDED_SALT
7670 | OPTI_TYPE_RAW_HASH;
7671 dgst_pos0 = 14;
7672 dgst_pos1 = 15;
7673 dgst_pos2 = 6;
7674 dgst_pos3 = 7;
7675 break;
7676
7677 case 1731: hash_type = HASH_TYPE_SHA512;
7678 salt_type = SALT_TYPE_EMBEDDED;
7679 attack_exec = ATTACK_EXEC_ON_GPU;
7680 opts_type = OPTS_TYPE_PT_GENERATE_BE
7681 | OPTS_TYPE_PT_UNICODE
7682 | OPTS_TYPE_ST_ADD80
7683 | OPTS_TYPE_ST_ADDBITS15
7684 | OPTS_TYPE_ST_HEX;
7685 kern_type = KERN_TYPE_SHA512_PWSLTU;
7686 dgst_size = DGST_SIZE_8_8;
7687 parse_func = mssql2012_parse_hash;
7688 sort_by_digest = sort_by_digest_8_8;
7689 opti_type = OPTI_TYPE_ZERO_BYTE
7690 | OPTI_TYPE_PRECOMPUTE_INIT
7691 | OPTI_TYPE_PRECOMPUTE_MERKLE
7692 | OPTI_TYPE_EARLY_SKIP
7693 | OPTI_TYPE_NOT_ITERATED
7694 | OPTI_TYPE_APPENDED_SALT
7695 | OPTI_TYPE_RAW_HASH;
7696 dgst_pos0 = 14;
7697 dgst_pos1 = 15;
7698 dgst_pos2 = 6;
7699 dgst_pos3 = 7;
7700 break;
7701
7702 case 1740: hash_type = HASH_TYPE_SHA512;
7703 salt_type = SALT_TYPE_INTERN;
7704 attack_exec = ATTACK_EXEC_ON_GPU;
7705 opts_type = OPTS_TYPE_PT_GENERATE_BE
7706 | OPTS_TYPE_PT_ADD80
7707 | OPTS_TYPE_PT_ADDBITS15
7708 | OPTS_TYPE_PT_UNICODE;
7709 kern_type = KERN_TYPE_SHA512_SLTPWU;
7710 dgst_size = DGST_SIZE_8_8;
7711 parse_func = sha512s_parse_hash;
7712 sort_by_digest = sort_by_digest_8_8;
7713 opti_type = OPTI_TYPE_ZERO_BYTE
7714 | OPTI_TYPE_PRECOMPUTE_INIT
7715 | OPTI_TYPE_PRECOMPUTE_MERKLE
7716 | OPTI_TYPE_EARLY_SKIP
7717 | OPTI_TYPE_NOT_ITERATED
7718 | OPTI_TYPE_PREPENDED_SALT
7719 | OPTI_TYPE_RAW_HASH;
7720 dgst_pos0 = 14;
7721 dgst_pos1 = 15;
7722 dgst_pos2 = 6;
7723 dgst_pos3 = 7;
7724 break;
7725
7726 case 1750: hash_type = HASH_TYPE_SHA512;
7727 salt_type = SALT_TYPE_INTERN;
7728 attack_exec = ATTACK_EXEC_ON_GPU;
7729 opts_type = OPTS_TYPE_PT_GENERATE_BE
7730 | OPTS_TYPE_ST_ADD80;
7731 kern_type = KERN_TYPE_HMACSHA512_PW;
7732 dgst_size = DGST_SIZE_8_8;
7733 parse_func = hmacsha512_parse_hash;
7734 sort_by_digest = sort_by_digest_8_8;
7735 opti_type = OPTI_TYPE_ZERO_BYTE
7736 | OPTI_TYPE_NOT_ITERATED;
7737 dgst_pos0 = 14;
7738 dgst_pos1 = 15;
7739 dgst_pos2 = 6;
7740 dgst_pos3 = 7;
7741 break;
7742
7743 case 1760: hash_type = HASH_TYPE_SHA512;
7744 salt_type = SALT_TYPE_INTERN;
7745 attack_exec = ATTACK_EXEC_ON_GPU;
7746 opts_type = OPTS_TYPE_PT_GENERATE_BE
7747 | OPTS_TYPE_PT_ADD80
7748 | OPTS_TYPE_PT_ADDBITS15;
7749 kern_type = KERN_TYPE_HMACSHA512_SLT;
7750 dgst_size = DGST_SIZE_8_8;
7751 parse_func = hmacsha512_parse_hash;
7752 sort_by_digest = sort_by_digest_8_8;
7753 opti_type = OPTI_TYPE_ZERO_BYTE
7754 | OPTI_TYPE_NOT_ITERATED;
7755 dgst_pos0 = 14;
7756 dgst_pos1 = 15;
7757 dgst_pos2 = 6;
7758 dgst_pos3 = 7;
7759 break;
7760
7761 case 1800: hash_type = HASH_TYPE_SHA512;
7762 salt_type = SALT_TYPE_EMBEDDED;
7763 attack_exec = ATTACK_EXEC_ON_CPU;
7764 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7765 kern_type = KERN_TYPE_SHA512CRYPT;
7766 dgst_size = DGST_SIZE_8_8;
7767 parse_func = sha512crypt_parse_hash;
7768 sort_by_digest = sort_by_digest_8_8;
7769 opti_type = OPTI_TYPE_ZERO_BYTE;
7770 dgst_pos0 = 0;
7771 dgst_pos1 = 1;
7772 dgst_pos2 = 2;
7773 dgst_pos3 = 3;
7774 break;
7775
7776 case 2100: hash_type = HASH_TYPE_DCC2;
7777 salt_type = SALT_TYPE_EMBEDDED;
7778 attack_exec = ATTACK_EXEC_ON_CPU;
7779 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
7780 | OPTS_TYPE_ST_LOWER
7781 | OPTS_TYPE_ST_UNICODE;
7782 kern_type = KERN_TYPE_DCC2;
7783 dgst_size = DGST_SIZE_4_4;
7784 parse_func = dcc2_parse_hash;
7785 sort_by_digest = sort_by_digest_4_4;
7786 opti_type = OPTI_TYPE_ZERO_BYTE;
7787 dgst_pos0 = 0;
7788 dgst_pos1 = 1;
7789 dgst_pos2 = 2;
7790 dgst_pos3 = 3;
7791 break;
7792
7793 case 2400: hash_type = HASH_TYPE_MD5;
7794 salt_type = SALT_TYPE_NONE;
7795 attack_exec = ATTACK_EXEC_ON_GPU;
7796 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7797 kern_type = KERN_TYPE_MD5PIX;
7798 dgst_size = DGST_SIZE_4_4;
7799 parse_func = md5pix_parse_hash;
7800 sort_by_digest = sort_by_digest_4_4;
7801 opti_type = OPTI_TYPE_ZERO_BYTE
7802 | OPTI_TYPE_PRECOMPUTE_INIT
7803 | OPTI_TYPE_PRECOMPUTE_MERKLE
7804 | OPTI_TYPE_EARLY_SKIP
7805 | OPTI_TYPE_NOT_ITERATED
7806 | OPTI_TYPE_NOT_SALTED;
7807 dgst_pos0 = 0;
7808 dgst_pos1 = 3;
7809 dgst_pos2 = 2;
7810 dgst_pos3 = 1;
7811 break;
7812
7813 case 2410: hash_type = HASH_TYPE_MD5;
7814 salt_type = SALT_TYPE_INTERN;
7815 attack_exec = ATTACK_EXEC_ON_GPU;
7816 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7817 kern_type = KERN_TYPE_MD5ASA;
7818 dgst_size = DGST_SIZE_4_4;
7819 parse_func = md5asa_parse_hash;
7820 sort_by_digest = sort_by_digest_4_4;
7821 opti_type = OPTI_TYPE_ZERO_BYTE
7822 | OPTI_TYPE_PRECOMPUTE_INIT
7823 | OPTI_TYPE_PRECOMPUTE_MERKLE
7824 | OPTI_TYPE_EARLY_SKIP
7825 | OPTI_TYPE_NOT_ITERATED;
7826 dgst_pos0 = 0;
7827 dgst_pos1 = 3;
7828 dgst_pos2 = 2;
7829 dgst_pos3 = 1;
7830 break;
7831
7832 case 2500: hash_type = HASH_TYPE_WPA;
7833 salt_type = SALT_TYPE_EMBEDDED;
7834 attack_exec = ATTACK_EXEC_ON_CPU;
7835 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7836 kern_type = KERN_TYPE_WPA;
7837 dgst_size = DGST_SIZE_4_4;
7838 parse_func = wpa_parse_hash;
7839 sort_by_digest = sort_by_digest_4_4;
7840 opti_type = OPTI_TYPE_ZERO_BYTE;
7841 dgst_pos0 = 0;
7842 dgst_pos1 = 1;
7843 dgst_pos2 = 2;
7844 dgst_pos3 = 3;
7845 break;
7846
7847 case 2600: hash_type = HASH_TYPE_MD5;
7848 salt_type = SALT_TYPE_VIRTUAL;
7849 attack_exec = ATTACK_EXEC_ON_GPU;
7850 opts_type = OPTS_TYPE_PT_GENERATE_LE
7851 | OPTS_TYPE_PT_ADD80
7852 | OPTS_TYPE_PT_ADDBITS14
7853 | OPTS_TYPE_ST_ADD80;
7854 kern_type = KERN_TYPE_MD55_PWSLT1;
7855 dgst_size = DGST_SIZE_4_4;
7856 parse_func = md5md5_parse_hash;
7857 sort_by_digest = sort_by_digest_4_4;
7858 opti_type = OPTI_TYPE_ZERO_BYTE
7859 | OPTI_TYPE_PRECOMPUTE_INIT
7860 | OPTI_TYPE_PRECOMPUTE_MERKLE
7861 | OPTI_TYPE_EARLY_SKIP;
7862 dgst_pos0 = 0;
7863 dgst_pos1 = 3;
7864 dgst_pos2 = 2;
7865 dgst_pos3 = 1;
7866 break;
7867
7868 case 2611: hash_type = HASH_TYPE_MD5;
7869 salt_type = SALT_TYPE_INTERN;
7870 attack_exec = ATTACK_EXEC_ON_GPU;
7871 opts_type = OPTS_TYPE_PT_GENERATE_LE
7872 | OPTS_TYPE_PT_ADD80
7873 | OPTS_TYPE_PT_ADDBITS14
7874 | OPTS_TYPE_ST_ADD80;
7875 kern_type = KERN_TYPE_MD55_PWSLT1;
7876 dgst_size = DGST_SIZE_4_4;
7877 parse_func = vb3_parse_hash;
7878 sort_by_digest = sort_by_digest_4_4;
7879 opti_type = OPTI_TYPE_ZERO_BYTE
7880 | OPTI_TYPE_PRECOMPUTE_INIT
7881 | OPTI_TYPE_PRECOMPUTE_MERKLE
7882 | OPTI_TYPE_EARLY_SKIP;
7883 dgst_pos0 = 0;
7884 dgst_pos1 = 3;
7885 dgst_pos2 = 2;
7886 dgst_pos3 = 1;
7887 break;
7888
7889 case 2612: hash_type = HASH_TYPE_MD5;
7890 salt_type = SALT_TYPE_EMBEDDED;
7891 attack_exec = ATTACK_EXEC_ON_GPU;
7892 opts_type = OPTS_TYPE_PT_GENERATE_LE
7893 | OPTS_TYPE_PT_ADD80
7894 | OPTS_TYPE_PT_ADDBITS14
7895 | OPTS_TYPE_ST_ADD80
7896 | OPTS_TYPE_ST_HEX;
7897 kern_type = KERN_TYPE_MD55_PWSLT1;
7898 dgst_size = DGST_SIZE_4_4;
7899 parse_func = phps_parse_hash;
7900 sort_by_digest = sort_by_digest_4_4;
7901 opti_type = OPTI_TYPE_ZERO_BYTE
7902 | OPTI_TYPE_PRECOMPUTE_INIT
7903 | OPTI_TYPE_PRECOMPUTE_MERKLE
7904 | OPTI_TYPE_EARLY_SKIP;
7905 dgst_pos0 = 0;
7906 dgst_pos1 = 3;
7907 dgst_pos2 = 2;
7908 dgst_pos3 = 1;
7909 break;
7910
7911 case 2711: hash_type = HASH_TYPE_MD5;
7912 salt_type = SALT_TYPE_INTERN;
7913 attack_exec = ATTACK_EXEC_ON_GPU;
7914 opts_type = OPTS_TYPE_PT_GENERATE_LE
7915 | OPTS_TYPE_PT_ADD80
7916 | OPTS_TYPE_PT_ADDBITS14
7917 | OPTS_TYPE_ST_ADD80;
7918 kern_type = KERN_TYPE_MD55_PWSLT2;
7919 dgst_size = DGST_SIZE_4_4;
7920 parse_func = vb30_parse_hash;
7921 sort_by_digest = sort_by_digest_4_4;
7922 opti_type = OPTI_TYPE_ZERO_BYTE
7923 | OPTI_TYPE_PRECOMPUTE_INIT
7924 | OPTI_TYPE_EARLY_SKIP;
7925 dgst_pos0 = 0;
7926 dgst_pos1 = 3;
7927 dgst_pos2 = 2;
7928 dgst_pos3 = 1;
7929 break;
7930
7931 case 2811: hash_type = HASH_TYPE_MD5;
7932 salt_type = SALT_TYPE_INTERN;
7933 attack_exec = ATTACK_EXEC_ON_GPU;
7934 opts_type = OPTS_TYPE_PT_GENERATE_LE
7935 | OPTS_TYPE_PT_ADD80
7936 | OPTS_TYPE_PT_ADDBITS14;
7937 kern_type = KERN_TYPE_MD55_SLTPW;
7938 dgst_size = DGST_SIZE_4_4;
7939 parse_func = ipb2_parse_hash;
7940 sort_by_digest = sort_by_digest_4_4;
7941 opti_type = OPTI_TYPE_ZERO_BYTE
7942 | OPTI_TYPE_PRECOMPUTE_INIT
7943 | OPTI_TYPE_EARLY_SKIP;
7944 dgst_pos0 = 0;
7945 dgst_pos1 = 3;
7946 dgst_pos2 = 2;
7947 dgst_pos3 = 1;
7948 break;
7949
7950 case 3000: hash_type = HASH_TYPE_LM;
7951 salt_type = SALT_TYPE_NONE;
7952 attack_exec = ATTACK_EXEC_ON_GPU;
7953 opts_type = OPTS_TYPE_PT_GENERATE_LE
7954 | OPTS_TYPE_PT_UPPER
7955 | OPTS_TYPE_PT_BITSLICE;
7956 kern_type = KERN_TYPE_LM;
7957 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7958 parse_func = lm_parse_hash;
7959 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7960 opti_type = OPTI_TYPE_ZERO_BYTE
7961 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7962 dgst_pos0 = 0;
7963 dgst_pos1 = 1;
7964 dgst_pos2 = 2;
7965 dgst_pos3 = 3;
7966 break;
7967
7968 case 3100: hash_type = HASH_TYPE_ORACLEH;
7969 salt_type = SALT_TYPE_INTERN;
7970 attack_exec = ATTACK_EXEC_ON_GPU;
7971 opts_type = OPTS_TYPE_PT_GENERATE_LE
7972 | OPTS_TYPE_PT_UPPER
7973 | OPTS_TYPE_ST_UPPER;
7974 kern_type = KERN_TYPE_ORACLEH;
7975 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7976 parse_func = oracleh_parse_hash;
7977 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7978 opti_type = OPTI_TYPE_ZERO_BYTE;
7979 dgst_pos0 = 0;
7980 dgst_pos1 = 1;
7981 dgst_pos2 = 2;
7982 dgst_pos3 = 3;
7983 break;
7984
7985 case 3200: hash_type = HASH_TYPE_BCRYPT;
7986 salt_type = SALT_TYPE_EMBEDDED;
7987 attack_exec = ATTACK_EXEC_ON_CPU;
7988 opts_type = OPTS_TYPE_PT_GENERATE_LE
7989 | OPTS_TYPE_ST_GENERATE_LE;
7990 kern_type = KERN_TYPE_BCRYPT;
7991 dgst_size = DGST_SIZE_4_6;
7992 parse_func = bcrypt_parse_hash;
7993 sort_by_digest = sort_by_digest_4_6;
7994 opti_type = OPTI_TYPE_ZERO_BYTE;
7995 dgst_pos0 = 0;
7996 dgst_pos1 = 1;
7997 dgst_pos2 = 2;
7998 dgst_pos3 = 3;
7999 break;
8000
8001 case 3710: hash_type = HASH_TYPE_MD5;
8002 salt_type = SALT_TYPE_INTERN;
8003 attack_exec = ATTACK_EXEC_ON_GPU;
8004 opts_type = OPTS_TYPE_PT_GENERATE_LE
8005 | OPTS_TYPE_PT_ADD80
8006 | OPTS_TYPE_PT_ADDBITS14;
8007 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8008 dgst_size = DGST_SIZE_4_4;
8009 parse_func = md5s_parse_hash;
8010 sort_by_digest = sort_by_digest_4_4;
8011 opti_type = OPTI_TYPE_ZERO_BYTE
8012 | OPTI_TYPE_PRECOMPUTE_INIT
8013 | OPTI_TYPE_PRECOMPUTE_MERKLE
8014 | OPTI_TYPE_EARLY_SKIP;
8015 dgst_pos0 = 0;
8016 dgst_pos1 = 3;
8017 dgst_pos2 = 2;
8018 dgst_pos3 = 1;
8019 break;
8020
8021 case 3711: hash_type = HASH_TYPE_MD5;
8022 salt_type = SALT_TYPE_EMBEDDED;
8023 attack_exec = ATTACK_EXEC_ON_GPU;
8024 opts_type = OPTS_TYPE_PT_GENERATE_LE
8025 | OPTS_TYPE_PT_ADD80
8026 | OPTS_TYPE_PT_ADDBITS14;
8027 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8028 dgst_size = DGST_SIZE_4_4;
8029 parse_func = mediawiki_b_parse_hash;
8030 sort_by_digest = sort_by_digest_4_4;
8031 opti_type = OPTI_TYPE_ZERO_BYTE
8032 | OPTI_TYPE_PRECOMPUTE_INIT
8033 | OPTI_TYPE_PRECOMPUTE_MERKLE
8034 | OPTI_TYPE_EARLY_SKIP;
8035 dgst_pos0 = 0;
8036 dgst_pos1 = 3;
8037 dgst_pos2 = 2;
8038 dgst_pos3 = 1;
8039 break;
8040
8041 case 3800: hash_type = HASH_TYPE_MD5;
8042 salt_type = SALT_TYPE_INTERN;
8043 attack_exec = ATTACK_EXEC_ON_GPU;
8044 opts_type = OPTS_TYPE_PT_GENERATE_LE
8045 | OPTS_TYPE_ST_ADDBITS14;
8046 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8047 dgst_size = DGST_SIZE_4_4;
8048 parse_func = md5s_parse_hash;
8049 sort_by_digest = sort_by_digest_4_4;
8050 opti_type = OPTI_TYPE_ZERO_BYTE
8051 | OPTI_TYPE_PRECOMPUTE_INIT
8052 | OPTI_TYPE_PRECOMPUTE_MERKLE
8053 | OPTI_TYPE_EARLY_SKIP
8054 | OPTI_TYPE_NOT_ITERATED
8055 | OPTI_TYPE_RAW_HASH;
8056 dgst_pos0 = 0;
8057 dgst_pos1 = 3;
8058 dgst_pos2 = 2;
8059 dgst_pos3 = 1;
8060 break;
8061
8062 case 4300: hash_type = HASH_TYPE_MD5;
8063 salt_type = SALT_TYPE_VIRTUAL;
8064 attack_exec = ATTACK_EXEC_ON_GPU;
8065 opts_type = OPTS_TYPE_PT_GENERATE_LE
8066 | OPTS_TYPE_PT_ADD80
8067 | OPTS_TYPE_PT_ADDBITS14
8068 | OPTS_TYPE_ST_ADD80;
8069 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8070 dgst_size = DGST_SIZE_4_4;
8071 parse_func = md5md5_parse_hash;
8072 sort_by_digest = sort_by_digest_4_4;
8073 opti_type = OPTI_TYPE_ZERO_BYTE
8074 | OPTI_TYPE_PRECOMPUTE_INIT
8075 | OPTI_TYPE_PRECOMPUTE_MERKLE
8076 | OPTI_TYPE_EARLY_SKIP;
8077 dgst_pos0 = 0;
8078 dgst_pos1 = 3;
8079 dgst_pos2 = 2;
8080 dgst_pos3 = 1;
8081 break;
8082
8083
8084 case 4400: hash_type = HASH_TYPE_MD5;
8085 salt_type = SALT_TYPE_NONE;
8086 attack_exec = ATTACK_EXEC_ON_GPU;
8087 opts_type = OPTS_TYPE_PT_GENERATE_BE
8088 | OPTS_TYPE_PT_ADD80
8089 | OPTS_TYPE_PT_ADDBITS15;
8090 kern_type = KERN_TYPE_MD5_SHA1;
8091 dgst_size = DGST_SIZE_4_4;
8092 parse_func = md5_parse_hash;
8093 sort_by_digest = sort_by_digest_4_4;
8094 opti_type = OPTI_TYPE_ZERO_BYTE
8095 | OPTI_TYPE_PRECOMPUTE_INIT
8096 | OPTI_TYPE_PRECOMPUTE_MERKLE
8097 | OPTI_TYPE_EARLY_SKIP
8098 | OPTI_TYPE_NOT_ITERATED
8099 | OPTI_TYPE_NOT_SALTED
8100 | OPTI_TYPE_RAW_HASH;
8101 dgst_pos0 = 0;
8102 dgst_pos1 = 3;
8103 dgst_pos2 = 2;
8104 dgst_pos3 = 1;
8105 break;
8106
8107 case 4500: hash_type = HASH_TYPE_SHA1;
8108 salt_type = SALT_TYPE_NONE;
8109 attack_exec = ATTACK_EXEC_ON_GPU;
8110 opts_type = OPTS_TYPE_PT_GENERATE_BE
8111 | OPTS_TYPE_PT_ADD80
8112 | OPTS_TYPE_PT_ADDBITS15;
8113 kern_type = KERN_TYPE_SHA11;
8114 dgst_size = DGST_SIZE_4_5;
8115 parse_func = sha1_parse_hash;
8116 sort_by_digest = sort_by_digest_4_5;
8117 opti_type = OPTI_TYPE_ZERO_BYTE
8118 | OPTI_TYPE_PRECOMPUTE_INIT
8119 | OPTI_TYPE_PRECOMPUTE_MERKLE
8120 | OPTI_TYPE_EARLY_SKIP
8121 | OPTI_TYPE_NOT_SALTED;
8122 dgst_pos0 = 3;
8123 dgst_pos1 = 4;
8124 dgst_pos2 = 2;
8125 dgst_pos3 = 1;
8126 break;
8127
8128 case 4700: hash_type = HASH_TYPE_SHA1;
8129 salt_type = SALT_TYPE_NONE;
8130 attack_exec = ATTACK_EXEC_ON_GPU;
8131 opts_type = OPTS_TYPE_PT_GENERATE_LE
8132 | OPTS_TYPE_PT_ADD80
8133 | OPTS_TYPE_PT_ADDBITS14;
8134 kern_type = KERN_TYPE_SHA1_MD5;
8135 dgst_size = DGST_SIZE_4_5;
8136 parse_func = sha1_parse_hash;
8137 sort_by_digest = sort_by_digest_4_5;
8138 opti_type = OPTI_TYPE_ZERO_BYTE
8139 | OPTI_TYPE_PRECOMPUTE_INIT
8140 | OPTI_TYPE_PRECOMPUTE_MERKLE
8141 | OPTI_TYPE_EARLY_SKIP
8142 | OPTI_TYPE_NOT_ITERATED
8143 | OPTI_TYPE_NOT_SALTED
8144 | OPTI_TYPE_RAW_HASH;
8145 dgst_pos0 = 3;
8146 dgst_pos1 = 4;
8147 dgst_pos2 = 2;
8148 dgst_pos3 = 1;
8149 break;
8150
8151 case 4800: hash_type = HASH_TYPE_MD5;
8152 salt_type = SALT_TYPE_EMBEDDED;
8153 attack_exec = ATTACK_EXEC_ON_GPU;
8154 opts_type = OPTS_TYPE_PT_GENERATE_LE
8155 | OPTS_TYPE_PT_ADDBITS14;
8156 kern_type = KERN_TYPE_MD5_CHAP;
8157 dgst_size = DGST_SIZE_4_4;
8158 parse_func = chap_parse_hash;
8159 sort_by_digest = sort_by_digest_4_4;
8160 opti_type = OPTI_TYPE_ZERO_BYTE
8161 | OPTI_TYPE_PRECOMPUTE_INIT
8162 | OPTI_TYPE_PRECOMPUTE_MERKLE
8163 | OPTI_TYPE_MEET_IN_MIDDLE
8164 | OPTI_TYPE_EARLY_SKIP
8165 | OPTI_TYPE_NOT_ITERATED
8166 | OPTI_TYPE_RAW_HASH;
8167 dgst_pos0 = 0;
8168 dgst_pos1 = 3;
8169 dgst_pos2 = 2;
8170 dgst_pos3 = 1;
8171 break;
8172
8173 case 4900: hash_type = HASH_TYPE_SHA1;
8174 salt_type = SALT_TYPE_INTERN;
8175 attack_exec = ATTACK_EXEC_ON_GPU;
8176 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8177 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8178 dgst_size = DGST_SIZE_4_5;
8179 parse_func = sha1s_parse_hash;
8180 sort_by_digest = sort_by_digest_4_5;
8181 opti_type = OPTI_TYPE_ZERO_BYTE
8182 | OPTI_TYPE_PRECOMPUTE_INIT
8183 | OPTI_TYPE_PRECOMPUTE_MERKLE
8184 | OPTI_TYPE_EARLY_SKIP;
8185 dgst_pos0 = 3;
8186 dgst_pos1 = 4;
8187 dgst_pos2 = 2;
8188 dgst_pos3 = 1;
8189 break;
8190
8191 case 5000: hash_type = HASH_TYPE_KECCAK;
8192 salt_type = SALT_TYPE_EMBEDDED;
8193 attack_exec = ATTACK_EXEC_ON_GPU;
8194 opts_type = OPTS_TYPE_PT_GENERATE_LE
8195 | OPTS_TYPE_PT_ADD01;
8196 kern_type = KERN_TYPE_KECCAK;
8197 dgst_size = DGST_SIZE_8_25;
8198 parse_func = keccak_parse_hash;
8199 sort_by_digest = sort_by_digest_8_25;
8200 opti_type = OPTI_TYPE_ZERO_BYTE
8201 | OPTI_TYPE_RAW_HASH;
8202 dgst_pos0 = 2;
8203 dgst_pos1 = 3;
8204 dgst_pos2 = 4;
8205 dgst_pos3 = 5;
8206 break;
8207
8208 case 5100: hash_type = HASH_TYPE_MD5H;
8209 salt_type = SALT_TYPE_NONE;
8210 attack_exec = ATTACK_EXEC_ON_GPU;
8211 opts_type = OPTS_TYPE_PT_GENERATE_LE
8212 | OPTS_TYPE_PT_ADD80
8213 | OPTS_TYPE_PT_ADDBITS14;
8214 kern_type = KERN_TYPE_MD5H;
8215 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8216 parse_func = md5half_parse_hash;
8217 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8218 opti_type = OPTI_TYPE_ZERO_BYTE
8219 | OPTI_TYPE_RAW_HASH;
8220 dgst_pos0 = 0;
8221 dgst_pos1 = 1;
8222 dgst_pos2 = 2;
8223 dgst_pos3 = 3;
8224 break;
8225
8226 case 5200: hash_type = HASH_TYPE_SHA256;
8227 salt_type = SALT_TYPE_EMBEDDED;
8228 attack_exec = ATTACK_EXEC_ON_CPU;
8229 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8230 kern_type = KERN_TYPE_PSAFE3;
8231 dgst_size = DGST_SIZE_4_8;
8232 parse_func = psafe3_parse_hash;
8233 sort_by_digest = sort_by_digest_4_8;
8234 opti_type = OPTI_TYPE_ZERO_BYTE;
8235 dgst_pos0 = 0;
8236 dgst_pos1 = 1;
8237 dgst_pos2 = 2;
8238 dgst_pos3 = 3;
8239 break;
8240
8241 case 5300: hash_type = HASH_TYPE_MD5;
8242 salt_type = SALT_TYPE_EMBEDDED;
8243 attack_exec = ATTACK_EXEC_ON_GPU;
8244 opts_type = OPTS_TYPE_PT_GENERATE_LE
8245 | OPTS_TYPE_ST_ADD80;
8246 kern_type = KERN_TYPE_IKEPSK_MD5;
8247 dgst_size = DGST_SIZE_4_4;
8248 parse_func = ikepsk_md5_parse_hash;
8249 sort_by_digest = sort_by_digest_4_4;
8250 opti_type = OPTI_TYPE_ZERO_BYTE;
8251 dgst_pos0 = 0;
8252 dgst_pos1 = 3;
8253 dgst_pos2 = 2;
8254 dgst_pos3 = 1;
8255 break;
8256
8257 case 5400: hash_type = HASH_TYPE_SHA1;
8258 salt_type = SALT_TYPE_EMBEDDED;
8259 attack_exec = ATTACK_EXEC_ON_GPU;
8260 opts_type = OPTS_TYPE_PT_GENERATE_BE
8261 | OPTS_TYPE_ST_ADD80;
8262 kern_type = KERN_TYPE_IKEPSK_SHA1;
8263 dgst_size = DGST_SIZE_4_5;
8264 parse_func = ikepsk_sha1_parse_hash;
8265 sort_by_digest = sort_by_digest_4_5;
8266 opti_type = OPTI_TYPE_ZERO_BYTE;
8267 dgst_pos0 = 3;
8268 dgst_pos1 = 4;
8269 dgst_pos2 = 2;
8270 dgst_pos3 = 1;
8271 break;
8272
8273 case 5500: hash_type = HASH_TYPE_NETNTLM;
8274 salt_type = SALT_TYPE_EMBEDDED;
8275 attack_exec = ATTACK_EXEC_ON_GPU;
8276 opts_type = OPTS_TYPE_PT_GENERATE_LE
8277 | OPTS_TYPE_PT_ADD80
8278 | OPTS_TYPE_PT_ADDBITS14
8279 | OPTS_TYPE_PT_UNICODE
8280 | OPTS_TYPE_ST_HEX;
8281 kern_type = KERN_TYPE_NETNTLMv1;
8282 dgst_size = DGST_SIZE_4_4;
8283 parse_func = netntlmv1_parse_hash;
8284 sort_by_digest = sort_by_digest_4_4;
8285 opti_type = OPTI_TYPE_ZERO_BYTE
8286 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8287 dgst_pos0 = 0;
8288 dgst_pos1 = 1;
8289 dgst_pos2 = 2;
8290 dgst_pos3 = 3;
8291 break;
8292
8293 case 5600: hash_type = HASH_TYPE_MD5;
8294 salt_type = SALT_TYPE_EMBEDDED;
8295 attack_exec = ATTACK_EXEC_ON_GPU;
8296 opts_type = OPTS_TYPE_PT_GENERATE_LE
8297 | OPTS_TYPE_PT_ADD80
8298 | OPTS_TYPE_PT_ADDBITS14
8299 | OPTS_TYPE_PT_UNICODE;
8300 kern_type = KERN_TYPE_NETNTLMv2;
8301 dgst_size = DGST_SIZE_4_4;
8302 parse_func = netntlmv2_parse_hash;
8303 sort_by_digest = sort_by_digest_4_4;
8304 opti_type = OPTI_TYPE_ZERO_BYTE;
8305 dgst_pos0 = 0;
8306 dgst_pos1 = 3;
8307 dgst_pos2 = 2;
8308 dgst_pos3 = 1;
8309 break;
8310
8311 case 5700: hash_type = HASH_TYPE_SHA256;
8312 salt_type = SALT_TYPE_NONE;
8313 attack_exec = ATTACK_EXEC_ON_GPU;
8314 opts_type = OPTS_TYPE_PT_GENERATE_BE
8315 | OPTS_TYPE_PT_ADD80
8316 | OPTS_TYPE_PT_ADDBITS15;
8317 kern_type = KERN_TYPE_SHA256;
8318 dgst_size = DGST_SIZE_4_8;
8319 parse_func = cisco4_parse_hash;
8320 sort_by_digest = sort_by_digest_4_8;
8321 opti_type = OPTI_TYPE_ZERO_BYTE
8322 | OPTI_TYPE_PRECOMPUTE_INIT
8323 | OPTI_TYPE_PRECOMPUTE_MERKLE
8324 | OPTI_TYPE_EARLY_SKIP
8325 | OPTI_TYPE_NOT_ITERATED
8326 | OPTI_TYPE_NOT_SALTED
8327 | OPTI_TYPE_RAW_HASH;
8328 dgst_pos0 = 3;
8329 dgst_pos1 = 7;
8330 dgst_pos2 = 2;
8331 dgst_pos3 = 6;
8332 break;
8333
8334 case 5800: hash_type = HASH_TYPE_SHA1;
8335 salt_type = SALT_TYPE_INTERN;
8336 attack_exec = ATTACK_EXEC_ON_CPU;
8337 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8338 | OPTS_TYPE_ST_ADD80;
8339 kern_type = KERN_TYPE_ANDROIDPIN;
8340 dgst_size = DGST_SIZE_4_5;
8341 parse_func = androidpin_parse_hash;
8342 sort_by_digest = sort_by_digest_4_5;
8343 opti_type = OPTI_TYPE_ZERO_BYTE;
8344 dgst_pos0 = 0;
8345 dgst_pos1 = 1;
8346 dgst_pos2 = 2;
8347 dgst_pos3 = 3;
8348 break;
8349
8350 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8351 salt_type = SALT_TYPE_NONE;
8352 attack_exec = ATTACK_EXEC_ON_GPU;
8353 opts_type = OPTS_TYPE_PT_GENERATE_LE
8354 | OPTS_TYPE_PT_ADD80;
8355 kern_type = KERN_TYPE_RIPEMD160;
8356 dgst_size = DGST_SIZE_4_5;
8357 parse_func = ripemd160_parse_hash;
8358 sort_by_digest = sort_by_digest_4_5;
8359 opti_type = OPTI_TYPE_ZERO_BYTE;
8360 dgst_pos0 = 0;
8361 dgst_pos1 = 1;
8362 dgst_pos2 = 2;
8363 dgst_pos3 = 3;
8364 break;
8365
8366 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8367 salt_type = SALT_TYPE_NONE;
8368 attack_exec = ATTACK_EXEC_ON_GPU;
8369 opts_type = OPTS_TYPE_PT_GENERATE_BE
8370 | OPTS_TYPE_PT_ADD80;
8371 kern_type = KERN_TYPE_WHIRLPOOL;
8372 dgst_size = DGST_SIZE_4_16;
8373 parse_func = whirlpool_parse_hash;
8374 sort_by_digest = sort_by_digest_4_16;
8375 opti_type = OPTI_TYPE_ZERO_BYTE;
8376 dgst_pos0 = 0;
8377 dgst_pos1 = 1;
8378 dgst_pos2 = 2;
8379 dgst_pos3 = 3;
8380 break;
8381
8382 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8383 salt_type = SALT_TYPE_EMBEDDED;
8384 attack_exec = ATTACK_EXEC_ON_CPU;
8385 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8386 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8387 dgst_size = DGST_SIZE_4_5;
8388 parse_func = truecrypt_parse_hash_2k;
8389 sort_by_digest = sort_by_digest_4_5;
8390 opti_type = OPTI_TYPE_ZERO_BYTE;
8391 dgst_pos0 = 0;
8392 dgst_pos1 = 1;
8393 dgst_pos2 = 2;
8394 dgst_pos3 = 3;
8395 break;
8396
8397 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8398 salt_type = SALT_TYPE_EMBEDDED;
8399 attack_exec = ATTACK_EXEC_ON_CPU;
8400 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8401 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8402 dgst_size = DGST_SIZE_4_5;
8403 parse_func = truecrypt_parse_hash_2k;
8404 sort_by_digest = sort_by_digest_4_5;
8405 opti_type = OPTI_TYPE_ZERO_BYTE;
8406 dgst_pos0 = 0;
8407 dgst_pos1 = 1;
8408 dgst_pos2 = 2;
8409 dgst_pos3 = 3;
8410 break;
8411
8412 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8413 salt_type = SALT_TYPE_EMBEDDED;
8414 attack_exec = ATTACK_EXEC_ON_CPU;
8415 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8416 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8417 dgst_size = DGST_SIZE_4_5;
8418 parse_func = truecrypt_parse_hash_2k;
8419 sort_by_digest = sort_by_digest_4_5;
8420 opti_type = OPTI_TYPE_ZERO_BYTE;
8421 dgst_pos0 = 0;
8422 dgst_pos1 = 1;
8423 dgst_pos2 = 2;
8424 dgst_pos3 = 3;
8425 break;
8426
8427 case 6221: hash_type = HASH_TYPE_SHA512;
8428 salt_type = SALT_TYPE_EMBEDDED;
8429 attack_exec = ATTACK_EXEC_ON_CPU;
8430 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8431 kern_type = KERN_TYPE_TCSHA512_XTS512;
8432 dgst_size = DGST_SIZE_8_8;
8433 parse_func = truecrypt_parse_hash_1k;
8434 sort_by_digest = sort_by_digest_8_8;
8435 opti_type = OPTI_TYPE_ZERO_BYTE;
8436 dgst_pos0 = 0;
8437 dgst_pos1 = 1;
8438 dgst_pos2 = 2;
8439 dgst_pos3 = 3;
8440 break;
8441
8442 case 6222: hash_type = HASH_TYPE_SHA512;
8443 salt_type = SALT_TYPE_EMBEDDED;
8444 attack_exec = ATTACK_EXEC_ON_CPU;
8445 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8446 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8447 dgst_size = DGST_SIZE_8_8;
8448 parse_func = truecrypt_parse_hash_1k;
8449 sort_by_digest = sort_by_digest_8_8;
8450 opti_type = OPTI_TYPE_ZERO_BYTE;
8451 dgst_pos0 = 0;
8452 dgst_pos1 = 1;
8453 dgst_pos2 = 2;
8454 dgst_pos3 = 3;
8455 break;
8456
8457 case 6223: hash_type = HASH_TYPE_SHA512;
8458 salt_type = SALT_TYPE_EMBEDDED;
8459 attack_exec = ATTACK_EXEC_ON_CPU;
8460 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8461 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8462 dgst_size = DGST_SIZE_8_8;
8463 parse_func = truecrypt_parse_hash_1k;
8464 sort_by_digest = sort_by_digest_8_8;
8465 opti_type = OPTI_TYPE_ZERO_BYTE;
8466 dgst_pos0 = 0;
8467 dgst_pos1 = 1;
8468 dgst_pos2 = 2;
8469 dgst_pos3 = 3;
8470 break;
8471
8472 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8473 salt_type = SALT_TYPE_EMBEDDED;
8474 attack_exec = ATTACK_EXEC_ON_CPU;
8475 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8476 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8477 dgst_size = DGST_SIZE_4_8;
8478 parse_func = truecrypt_parse_hash_1k;
8479 sort_by_digest = sort_by_digest_4_8;
8480 opti_type = OPTI_TYPE_ZERO_BYTE;
8481 dgst_pos0 = 0;
8482 dgst_pos1 = 1;
8483 dgst_pos2 = 2;
8484 dgst_pos3 = 3;
8485 break;
8486
8487 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8488 salt_type = SALT_TYPE_EMBEDDED;
8489 attack_exec = ATTACK_EXEC_ON_CPU;
8490 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8491 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8492 dgst_size = DGST_SIZE_4_8;
8493 parse_func = truecrypt_parse_hash_1k;
8494 sort_by_digest = sort_by_digest_4_8;
8495 opti_type = OPTI_TYPE_ZERO_BYTE;
8496 dgst_pos0 = 0;
8497 dgst_pos1 = 1;
8498 dgst_pos2 = 2;
8499 dgst_pos3 = 3;
8500 break;
8501
8502 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8503 salt_type = SALT_TYPE_EMBEDDED;
8504 attack_exec = ATTACK_EXEC_ON_CPU;
8505 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8506 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8507 dgst_size = DGST_SIZE_4_8;
8508 parse_func = truecrypt_parse_hash_1k;
8509 sort_by_digest = sort_by_digest_4_8;
8510 opti_type = OPTI_TYPE_ZERO_BYTE;
8511 dgst_pos0 = 0;
8512 dgst_pos1 = 1;
8513 dgst_pos2 = 2;
8514 dgst_pos3 = 3;
8515 break;
8516
8517 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8518 salt_type = SALT_TYPE_EMBEDDED;
8519 attack_exec = ATTACK_EXEC_ON_CPU;
8520 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8521 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8522 dgst_size = DGST_SIZE_4_5;
8523 parse_func = truecrypt_parse_hash_1k;
8524 sort_by_digest = sort_by_digest_4_5;
8525 opti_type = OPTI_TYPE_ZERO_BYTE;
8526 dgst_pos0 = 0;
8527 dgst_pos1 = 1;
8528 dgst_pos2 = 2;
8529 dgst_pos3 = 3;
8530 break;
8531
8532 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8533 salt_type = SALT_TYPE_EMBEDDED;
8534 attack_exec = ATTACK_EXEC_ON_CPU;
8535 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8536 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8537 dgst_size = DGST_SIZE_4_5;
8538 parse_func = truecrypt_parse_hash_1k;
8539 sort_by_digest = sort_by_digest_4_5;
8540 opti_type = OPTI_TYPE_ZERO_BYTE;
8541 dgst_pos0 = 0;
8542 dgst_pos1 = 1;
8543 dgst_pos2 = 2;
8544 dgst_pos3 = 3;
8545 break;
8546
8547 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8548 salt_type = SALT_TYPE_EMBEDDED;
8549 attack_exec = ATTACK_EXEC_ON_CPU;
8550 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8551 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8552 dgst_size = DGST_SIZE_4_5;
8553 parse_func = truecrypt_parse_hash_1k;
8554 sort_by_digest = sort_by_digest_4_5;
8555 opti_type = OPTI_TYPE_ZERO_BYTE;
8556 dgst_pos0 = 0;
8557 dgst_pos1 = 1;
8558 dgst_pos2 = 2;
8559 dgst_pos3 = 3;
8560 break;
8561
8562 case 6300: hash_type = HASH_TYPE_MD5;
8563 salt_type = SALT_TYPE_EMBEDDED;
8564 attack_exec = ATTACK_EXEC_ON_CPU;
8565 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8566 kern_type = KERN_TYPE_MD5AIX;
8567 dgst_size = DGST_SIZE_4_4;
8568 parse_func = md5aix_parse_hash;
8569 sort_by_digest = sort_by_digest_4_4;
8570 opti_type = OPTI_TYPE_ZERO_BYTE;
8571 dgst_pos0 = 0;
8572 dgst_pos1 = 1;
8573 dgst_pos2 = 2;
8574 dgst_pos3 = 3;
8575 break;
8576
8577 case 6400: hash_type = HASH_TYPE_SHA256;
8578 salt_type = SALT_TYPE_EMBEDDED;
8579 attack_exec = ATTACK_EXEC_ON_CPU;
8580 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8581 kern_type = KERN_TYPE_SHA256AIX;
8582 dgst_size = DGST_SIZE_4_8;
8583 parse_func = sha256aix_parse_hash;
8584 sort_by_digest = sort_by_digest_4_8;
8585 opti_type = OPTI_TYPE_ZERO_BYTE;
8586 dgst_pos0 = 0;
8587 dgst_pos1 = 1;
8588 dgst_pos2 = 2;
8589 dgst_pos3 = 3;
8590 break;
8591
8592 case 6500: hash_type = HASH_TYPE_SHA512;
8593 salt_type = SALT_TYPE_EMBEDDED;
8594 attack_exec = ATTACK_EXEC_ON_CPU;
8595 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8596 kern_type = KERN_TYPE_SHA512AIX;
8597 dgst_size = DGST_SIZE_8_8;
8598 parse_func = sha512aix_parse_hash;
8599 sort_by_digest = sort_by_digest_8_8;
8600 opti_type = OPTI_TYPE_ZERO_BYTE;
8601 dgst_pos0 = 0;
8602 dgst_pos1 = 1;
8603 dgst_pos2 = 2;
8604 dgst_pos3 = 3;
8605 break;
8606
8607 case 6600: hash_type = HASH_TYPE_AES;
8608 salt_type = SALT_TYPE_EMBEDDED;
8609 attack_exec = ATTACK_EXEC_ON_CPU;
8610 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8611 kern_type = KERN_TYPE_AGILEKEY;
8612 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8613 parse_func = agilekey_parse_hash;
8614 sort_by_digest = sort_by_digest_4_5;
8615 opti_type = OPTI_TYPE_ZERO_BYTE;
8616 dgst_pos0 = 0;
8617 dgst_pos1 = 1;
8618 dgst_pos2 = 2;
8619 dgst_pos3 = 3;
8620 break;
8621
8622 case 6700: hash_type = HASH_TYPE_SHA1;
8623 salt_type = SALT_TYPE_EMBEDDED;
8624 attack_exec = ATTACK_EXEC_ON_CPU;
8625 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8626 kern_type = KERN_TYPE_SHA1AIX;
8627 dgst_size = DGST_SIZE_4_5;
8628 parse_func = sha1aix_parse_hash;
8629 sort_by_digest = sort_by_digest_4_5;
8630 opti_type = OPTI_TYPE_ZERO_BYTE;
8631 dgst_pos0 = 0;
8632 dgst_pos1 = 1;
8633 dgst_pos2 = 2;
8634 dgst_pos3 = 3;
8635 break;
8636
8637 case 6800: hash_type = HASH_TYPE_AES;
8638 salt_type = SALT_TYPE_EMBEDDED;
8639 attack_exec = ATTACK_EXEC_ON_CPU;
8640 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8641 kern_type = KERN_TYPE_LASTPASS;
8642 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
8643 parse_func = lastpass_parse_hash;
8644 sort_by_digest = sort_by_digest_4_8;
8645 opti_type = OPTI_TYPE_ZERO_BYTE;
8646 dgst_pos0 = 0;
8647 dgst_pos1 = 1;
8648 dgst_pos2 = 2;
8649 dgst_pos3 = 3;
8650 break;
8651
8652 case 6900: hash_type = HASH_TYPE_GOST;
8653 salt_type = SALT_TYPE_NONE;
8654 attack_exec = ATTACK_EXEC_ON_GPU;
8655 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8656 kern_type = KERN_TYPE_GOST;
8657 dgst_size = DGST_SIZE_4_8;
8658 parse_func = gost_parse_hash;
8659 sort_by_digest = sort_by_digest_4_8;
8660 opti_type = OPTI_TYPE_ZERO_BYTE;
8661 dgst_pos0 = 0;
8662 dgst_pos1 = 1;
8663 dgst_pos2 = 2;
8664 dgst_pos3 = 3;
8665 break;
8666
8667 case 7100: hash_type = HASH_TYPE_SHA512;
8668 salt_type = SALT_TYPE_EMBEDDED;
8669 attack_exec = ATTACK_EXEC_ON_CPU;
8670 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8671 kern_type = KERN_TYPE_PBKDF2_SHA512;
8672 dgst_size = DGST_SIZE_8_16;
8673 parse_func = sha512osx_parse_hash;
8674 sort_by_digest = sort_by_digest_8_16;
8675 opti_type = OPTI_TYPE_ZERO_BYTE;
8676 dgst_pos0 = 0;
8677 dgst_pos1 = 1;
8678 dgst_pos2 = 2;
8679 dgst_pos3 = 3;
8680 break;
8681
8682 case 7200: hash_type = HASH_TYPE_SHA512;
8683 salt_type = SALT_TYPE_EMBEDDED;
8684 attack_exec = ATTACK_EXEC_ON_CPU;
8685 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8686 kern_type = KERN_TYPE_PBKDF2_SHA512;
8687 dgst_size = DGST_SIZE_8_16;
8688 parse_func = sha512grub_parse_hash;
8689 sort_by_digest = sort_by_digest_8_16;
8690 opti_type = OPTI_TYPE_ZERO_BYTE;
8691 dgst_pos0 = 0;
8692 dgst_pos1 = 1;
8693 dgst_pos2 = 2;
8694 dgst_pos3 = 3;
8695 break;
8696
8697 case 7300: hash_type = HASH_TYPE_SHA1;
8698 salt_type = SALT_TYPE_EMBEDDED;
8699 attack_exec = ATTACK_EXEC_ON_GPU;
8700 opts_type = OPTS_TYPE_PT_GENERATE_BE
8701 | OPTS_TYPE_ST_ADD80
8702 | OPTS_TYPE_ST_ADDBITS15;
8703 kern_type = KERN_TYPE_RAKP;
8704 dgst_size = DGST_SIZE_4_5;
8705 parse_func = rakp_parse_hash;
8706 sort_by_digest = sort_by_digest_4_5;
8707 opti_type = OPTI_TYPE_ZERO_BYTE
8708 | OPTI_TYPE_NOT_ITERATED;
8709 dgst_pos0 = 3;
8710 dgst_pos1 = 4;
8711 dgst_pos2 = 2;
8712 dgst_pos3 = 1;
8713 break;
8714
8715 case 7400: hash_type = HASH_TYPE_SHA256;
8716 salt_type = SALT_TYPE_EMBEDDED;
8717 attack_exec = ATTACK_EXEC_ON_CPU;
8718 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8719 kern_type = KERN_TYPE_SHA256CRYPT;
8720 dgst_size = DGST_SIZE_4_8;
8721 parse_func = sha256crypt_parse_hash;
8722 sort_by_digest = sort_by_digest_4_8;
8723 opti_type = OPTI_TYPE_ZERO_BYTE;
8724 dgst_pos0 = 0;
8725 dgst_pos1 = 1;
8726 dgst_pos2 = 2;
8727 dgst_pos3 = 3;
8728 break;
8729
8730 case 7500: hash_type = HASH_TYPE_KRB5PA;
8731 salt_type = SALT_TYPE_EMBEDDED;
8732 attack_exec = ATTACK_EXEC_ON_GPU;
8733 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8734 kern_type = KERN_TYPE_KRB5PA;
8735 dgst_size = DGST_SIZE_4_4;
8736 parse_func = krb5pa_parse_hash;
8737 sort_by_digest = sort_by_digest_4_4;
8738 opti_type = OPTI_TYPE_ZERO_BYTE
8739 | OPTI_TYPE_NOT_ITERATED;
8740 dgst_pos0 = 3;
8741 dgst_pos1 = 7;
8742 dgst_pos2 = 2;
8743 dgst_pos3 = 6;
8744 break;
8745
8746 case 7600: hash_type = HASH_TYPE_SHA1;
8747 salt_type = SALT_TYPE_INTERN;
8748 attack_exec = ATTACK_EXEC_ON_GPU;
8749 opts_type = OPTS_TYPE_PT_GENERATE_BE
8750 | OPTS_TYPE_PT_ADD80
8751 | OPTS_TYPE_PT_ADDBITS15;
8752 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
8753 dgst_size = DGST_SIZE_4_5;
8754 parse_func = redmine_parse_hash;
8755 sort_by_digest = sort_by_digest_4_5;
8756 opti_type = OPTI_TYPE_ZERO_BYTE
8757 | OPTI_TYPE_PRECOMPUTE_INIT
8758 | OPTI_TYPE_EARLY_SKIP
8759 | OPTI_TYPE_NOT_ITERATED
8760 | OPTI_TYPE_PREPENDED_SALT;
8761 dgst_pos0 = 3;
8762 dgst_pos1 = 4;
8763 dgst_pos2 = 2;
8764 dgst_pos3 = 1;
8765 break;
8766
8767 case 7700: hash_type = HASH_TYPE_SAPB;
8768 salt_type = SALT_TYPE_EMBEDDED;
8769 attack_exec = ATTACK_EXEC_ON_GPU;
8770 opts_type = OPTS_TYPE_PT_GENERATE_LE
8771 | OPTS_TYPE_PT_UPPER
8772 | OPTS_TYPE_ST_UPPER;
8773 kern_type = KERN_TYPE_SAPB;
8774 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8775 parse_func = sapb_parse_hash;
8776 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8777 opti_type = OPTI_TYPE_ZERO_BYTE
8778 | OPTI_TYPE_PRECOMPUTE_INIT
8779 | OPTI_TYPE_NOT_ITERATED;
8780 dgst_pos0 = 0;
8781 dgst_pos1 = 1;
8782 dgst_pos2 = 2;
8783 dgst_pos3 = 3;
8784 break;
8785
8786 case 7800: hash_type = HASH_TYPE_SAPG;
8787 salt_type = SALT_TYPE_EMBEDDED;
8788 attack_exec = ATTACK_EXEC_ON_GPU;
8789 opts_type = OPTS_TYPE_PT_GENERATE_BE
8790 | OPTS_TYPE_ST_ADD80
8791 | OPTS_TYPE_ST_UPPER;
8792 kern_type = KERN_TYPE_SAPG;
8793 dgst_size = DGST_SIZE_4_5;
8794 parse_func = sapg_parse_hash;
8795 sort_by_digest = sort_by_digest_4_5;
8796 opti_type = OPTI_TYPE_ZERO_BYTE
8797 | OPTI_TYPE_PRECOMPUTE_INIT
8798 | OPTI_TYPE_NOT_ITERATED;
8799 dgst_pos0 = 3;
8800 dgst_pos1 = 4;
8801 dgst_pos2 = 2;
8802 dgst_pos3 = 1;
8803 break;
8804
8805 case 7900: hash_type = HASH_TYPE_SHA512;
8806 salt_type = SALT_TYPE_EMBEDDED;
8807 attack_exec = ATTACK_EXEC_ON_CPU;
8808 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8809 kern_type = KERN_TYPE_DRUPAL7;
8810 dgst_size = DGST_SIZE_8_8;
8811 parse_func = drupal7_parse_hash;
8812 sort_by_digest = sort_by_digest_8_8;
8813 opti_type = OPTI_TYPE_ZERO_BYTE;
8814 dgst_pos0 = 0;
8815 dgst_pos1 = 1;
8816 dgst_pos2 = 2;
8817 dgst_pos3 = 3;
8818 break;
8819
8820 case 8000: hash_type = HASH_TYPE_SHA256;
8821 salt_type = SALT_TYPE_EMBEDDED;
8822 attack_exec = ATTACK_EXEC_ON_GPU;
8823 opts_type = OPTS_TYPE_PT_GENERATE_BE
8824 | OPTS_TYPE_PT_UNICODE
8825 | OPTS_TYPE_ST_ADD80
8826 | OPTS_TYPE_ST_HEX;
8827 kern_type = KERN_TYPE_SYBASEASE;
8828 dgst_size = DGST_SIZE_4_8;
8829 parse_func = sybasease_parse_hash;
8830 sort_by_digest = sort_by_digest_4_8;
8831 opti_type = OPTI_TYPE_ZERO_BYTE
8832 | OPTI_TYPE_PRECOMPUTE_INIT
8833 | OPTI_TYPE_EARLY_SKIP
8834 | OPTI_TYPE_NOT_ITERATED
8835 | OPTI_TYPE_RAW_HASH;
8836 dgst_pos0 = 3;
8837 dgst_pos1 = 7;
8838 dgst_pos2 = 2;
8839 dgst_pos3 = 6;
8840 break;
8841
8842 case 8100: hash_type = HASH_TYPE_SHA1;
8843 salt_type = SALT_TYPE_EMBEDDED;
8844 attack_exec = ATTACK_EXEC_ON_GPU;
8845 opts_type = OPTS_TYPE_PT_GENERATE_BE;
8846 kern_type = KERN_TYPE_NETSCALER;
8847 dgst_size = DGST_SIZE_4_5;
8848 parse_func = netscaler_parse_hash;
8849 sort_by_digest = sort_by_digest_4_5;
8850 opti_type = OPTI_TYPE_ZERO_BYTE
8851 | OPTI_TYPE_PRECOMPUTE_INIT
8852 | OPTI_TYPE_PRECOMPUTE_MERKLE
8853 | OPTI_TYPE_EARLY_SKIP
8854 | OPTI_TYPE_NOT_ITERATED
8855 | OPTI_TYPE_PREPENDED_SALT
8856 | OPTI_TYPE_RAW_HASH;
8857 dgst_pos0 = 3;
8858 dgst_pos1 = 4;
8859 dgst_pos2 = 2;
8860 dgst_pos3 = 1;
8861 break;
8862
8863 case 8200: hash_type = HASH_TYPE_SHA256;
8864 salt_type = SALT_TYPE_EMBEDDED;
8865 attack_exec = ATTACK_EXEC_ON_CPU;
8866 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8867 kern_type = KERN_TYPE_CLOUDKEY;
8868 dgst_size = DGST_SIZE_4_8;
8869 parse_func = cloudkey_parse_hash;
8870 sort_by_digest = sort_by_digest_4_8;
8871 opti_type = OPTI_TYPE_ZERO_BYTE;
8872 dgst_pos0 = 0;
8873 dgst_pos1 = 1;
8874 dgst_pos2 = 2;
8875 dgst_pos3 = 3;
8876 break;
8877
8878 case 8300: hash_type = HASH_TYPE_SHA1;
8879 salt_type = SALT_TYPE_EMBEDDED;
8880 attack_exec = ATTACK_EXEC_ON_GPU;
8881 opts_type = OPTS_TYPE_PT_GENERATE_LE
8882 | OPTS_TYPE_ST_HEX
8883 | OPTS_TYPE_ST_ADD80;
8884 kern_type = KERN_TYPE_NSEC3;
8885 dgst_size = DGST_SIZE_4_5;
8886 parse_func = nsec3_parse_hash;
8887 sort_by_digest = sort_by_digest_4_5;
8888 opti_type = OPTI_TYPE_ZERO_BYTE;
8889 dgst_pos0 = 3;
8890 dgst_pos1 = 4;
8891 dgst_pos2 = 2;
8892 dgst_pos3 = 1;
8893 break;
8894
8895 case 8400: hash_type = HASH_TYPE_SHA1;
8896 salt_type = SALT_TYPE_INTERN;
8897 attack_exec = ATTACK_EXEC_ON_GPU;
8898 opts_type = OPTS_TYPE_PT_GENERATE_BE
8899 | OPTS_TYPE_PT_ADD80
8900 | OPTS_TYPE_PT_ADDBITS15;
8901 kern_type = KERN_TYPE_WBB3;
8902 dgst_size = DGST_SIZE_4_5;
8903 parse_func = wbb3_parse_hash;
8904 sort_by_digest = sort_by_digest_4_5;
8905 opti_type = OPTI_TYPE_ZERO_BYTE
8906 | OPTI_TYPE_PRECOMPUTE_INIT
8907 | OPTI_TYPE_NOT_ITERATED;
8908 dgst_pos0 = 3;
8909 dgst_pos1 = 4;
8910 dgst_pos2 = 2;
8911 dgst_pos3 = 1;
8912 break;
8913
8914 case 8500: hash_type = HASH_TYPE_DESRACF;
8915 salt_type = SALT_TYPE_EMBEDDED;
8916 attack_exec = ATTACK_EXEC_ON_GPU;
8917 opts_type = OPTS_TYPE_PT_GENERATE_LE
8918 | OPTS_TYPE_ST_UPPER;
8919 kern_type = KERN_TYPE_RACF;
8920 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8921 parse_func = racf_parse_hash;
8922 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8923 opti_type = OPTI_TYPE_ZERO_BYTE
8924 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8925 dgst_pos0 = 0;
8926 dgst_pos1 = 1;
8927 dgst_pos2 = 2;
8928 dgst_pos3 = 3;
8929 break;
8930
8931 case 8600: hash_type = HASH_TYPE_LOTUS5;
8932 salt_type = SALT_TYPE_NONE;
8933 attack_exec = ATTACK_EXEC_ON_GPU;
8934 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8935 kern_type = KERN_TYPE_LOTUS5;
8936 dgst_size = DGST_SIZE_4_4;
8937 parse_func = lotus5_parse_hash;
8938 sort_by_digest = sort_by_digest_4_4;
8939 opti_type = OPTI_TYPE_EARLY_SKIP
8940 | OPTI_TYPE_NOT_ITERATED
8941 | OPTI_TYPE_NOT_SALTED
8942 | OPTI_TYPE_RAW_HASH;
8943 dgst_pos0 = 0;
8944 dgst_pos1 = 1;
8945 dgst_pos2 = 2;
8946 dgst_pos3 = 3;
8947 break;
8948
8949 case 8700: hash_type = HASH_TYPE_LOTUS6;
8950 salt_type = SALT_TYPE_EMBEDDED;
8951 attack_exec = ATTACK_EXEC_ON_GPU;
8952 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8953 kern_type = KERN_TYPE_LOTUS6;
8954 dgst_size = DGST_SIZE_4_4;
8955 parse_func = lotus6_parse_hash;
8956 sort_by_digest = sort_by_digest_4_4;
8957 opti_type = OPTI_TYPE_EARLY_SKIP
8958 | OPTI_TYPE_NOT_ITERATED
8959 | OPTI_TYPE_RAW_HASH;
8960 dgst_pos0 = 0;
8961 dgst_pos1 = 1;
8962 dgst_pos2 = 2;
8963 dgst_pos3 = 3;
8964 break;
8965
8966 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
8967 salt_type = SALT_TYPE_EMBEDDED;
8968 attack_exec = ATTACK_EXEC_ON_CPU;
8969 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8970 kern_type = KERN_TYPE_ANDROIDFDE;
8971 dgst_size = DGST_SIZE_4_4;
8972 parse_func = androidfde_parse_hash;
8973 sort_by_digest = sort_by_digest_4_4;
8974 opti_type = OPTI_TYPE_ZERO_BYTE;
8975 dgst_pos0 = 0;
8976 dgst_pos1 = 1;
8977 dgst_pos2 = 2;
8978 dgst_pos3 = 3;
8979 break;
8980
8981 case 8900: hash_type = HASH_TYPE_SCRYPT;
8982 salt_type = SALT_TYPE_EMBEDDED;
8983 attack_exec = ATTACK_EXEC_ON_CPU;
8984 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8985 kern_type = KERN_TYPE_SCRYPT;
8986 dgst_size = DGST_SIZE_4_8;
8987 parse_func = scrypt_parse_hash;
8988 sort_by_digest = sort_by_digest_4_8;
8989 opti_type = OPTI_TYPE_ZERO_BYTE;
8990 dgst_pos0 = 0;
8991 dgst_pos1 = 1;
8992 dgst_pos2 = 2;
8993 dgst_pos3 = 3;
8994 break;
8995
8996 case 9000: hash_type = HASH_TYPE_SHA1;
8997 salt_type = SALT_TYPE_EMBEDDED;
8998 attack_exec = ATTACK_EXEC_ON_CPU;
8999 opts_type = OPTS_TYPE_PT_GENERATE_LE
9000 | OPTS_TYPE_ST_GENERATE_LE;
9001 kern_type = KERN_TYPE_PSAFE2;
9002 dgst_size = DGST_SIZE_4_5;
9003 parse_func = psafe2_parse_hash;
9004 sort_by_digest = sort_by_digest_4_5;
9005 opti_type = OPTI_TYPE_ZERO_BYTE;
9006 dgst_pos0 = 0;
9007 dgst_pos1 = 1;
9008 dgst_pos2 = 2;
9009 dgst_pos3 = 3;
9010 break;
9011
9012 case 9100: hash_type = HASH_TYPE_LOTUS8;
9013 salt_type = SALT_TYPE_EMBEDDED;
9014 attack_exec = ATTACK_EXEC_ON_CPU;
9015 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9016 kern_type = KERN_TYPE_LOTUS8;
9017 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9018 parse_func = lotus8_parse_hash;
9019 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9020 opti_type = OPTI_TYPE_ZERO_BYTE;
9021 dgst_pos0 = 0;
9022 dgst_pos1 = 1;
9023 dgst_pos2 = 2;
9024 dgst_pos3 = 3;
9025 break;
9026
9027 case 9200: hash_type = HASH_TYPE_SHA256;
9028 salt_type = SALT_TYPE_EMBEDDED;
9029 attack_exec = ATTACK_EXEC_ON_CPU;
9030 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9031 kern_type = KERN_TYPE_PBKDF2_SHA256;
9032 dgst_size = DGST_SIZE_4_32;
9033 parse_func = cisco8_parse_hash;
9034 sort_by_digest = sort_by_digest_4_32;
9035 opti_type = OPTI_TYPE_ZERO_BYTE;
9036 dgst_pos0 = 0;
9037 dgst_pos1 = 1;
9038 dgst_pos2 = 2;
9039 dgst_pos3 = 3;
9040 break;
9041
9042 case 9300: hash_type = HASH_TYPE_SCRYPT;
9043 salt_type = SALT_TYPE_EMBEDDED;
9044 attack_exec = ATTACK_EXEC_ON_CPU;
9045 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9046 kern_type = KERN_TYPE_SCRYPT;
9047 dgst_size = DGST_SIZE_4_8;
9048 parse_func = cisco9_parse_hash;
9049 sort_by_digest = sort_by_digest_4_8;
9050 opti_type = OPTI_TYPE_ZERO_BYTE;
9051 dgst_pos0 = 0;
9052 dgst_pos1 = 1;
9053 dgst_pos2 = 2;
9054 dgst_pos3 = 3;
9055 break;
9056
9057 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9058 salt_type = SALT_TYPE_EMBEDDED;
9059 attack_exec = ATTACK_EXEC_ON_CPU;
9060 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9061 kern_type = KERN_TYPE_OFFICE2007;
9062 dgst_size = DGST_SIZE_4_4;
9063 parse_func = office2007_parse_hash;
9064 sort_by_digest = sort_by_digest_4_4;
9065 opti_type = OPTI_TYPE_ZERO_BYTE;
9066 dgst_pos0 = 0;
9067 dgst_pos1 = 1;
9068 dgst_pos2 = 2;
9069 dgst_pos3 = 3;
9070 break;
9071
9072 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9073 salt_type = SALT_TYPE_EMBEDDED;
9074 attack_exec = ATTACK_EXEC_ON_CPU;
9075 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9076 kern_type = KERN_TYPE_OFFICE2010;
9077 dgst_size = DGST_SIZE_4_4;
9078 parse_func = office2010_parse_hash;
9079 sort_by_digest = sort_by_digest_4_4;
9080 opti_type = OPTI_TYPE_ZERO_BYTE;
9081 dgst_pos0 = 0;
9082 dgst_pos1 = 1;
9083 dgst_pos2 = 2;
9084 dgst_pos3 = 3;
9085 break;
9086
9087 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9088 salt_type = SALT_TYPE_EMBEDDED;
9089 attack_exec = ATTACK_EXEC_ON_CPU;
9090 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9091 kern_type = KERN_TYPE_OFFICE2013;
9092 dgst_size = DGST_SIZE_4_4;
9093 parse_func = office2013_parse_hash;
9094 sort_by_digest = sort_by_digest_4_4;
9095 opti_type = OPTI_TYPE_ZERO_BYTE;
9096 dgst_pos0 = 0;
9097 dgst_pos1 = 1;
9098 dgst_pos2 = 2;
9099 dgst_pos3 = 3;
9100 break;
9101
9102 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9103 salt_type = SALT_TYPE_EMBEDDED;
9104 attack_exec = ATTACK_EXEC_ON_GPU;
9105 opts_type = OPTS_TYPE_PT_GENERATE_LE
9106 | OPTS_TYPE_PT_ADD80
9107 | OPTS_TYPE_PT_UNICODE;
9108 kern_type = KERN_TYPE_OLDOFFICE01;
9109 dgst_size = DGST_SIZE_4_4;
9110 parse_func = oldoffice01_parse_hash;
9111 sort_by_digest = sort_by_digest_4_4;
9112 opti_type = OPTI_TYPE_ZERO_BYTE
9113 | OPTI_TYPE_PRECOMPUTE_INIT
9114 | OPTI_TYPE_NOT_ITERATED;
9115 dgst_pos0 = 0;
9116 dgst_pos1 = 1;
9117 dgst_pos2 = 2;
9118 dgst_pos3 = 3;
9119 break;
9120
9121 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9122 salt_type = SALT_TYPE_EMBEDDED;
9123 attack_exec = ATTACK_EXEC_ON_GPU;
9124 opts_type = OPTS_TYPE_PT_GENERATE_LE
9125 | OPTS_TYPE_PT_ADD80;
9126 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9127 dgst_size = DGST_SIZE_4_4;
9128 parse_func = oldoffice01cm1_parse_hash;
9129 sort_by_digest = sort_by_digest_4_4;
9130 opti_type = OPTI_TYPE_ZERO_BYTE
9131 | OPTI_TYPE_PRECOMPUTE_INIT
9132 | OPTI_TYPE_NOT_ITERATED;
9133 dgst_pos0 = 0;
9134 dgst_pos1 = 1;
9135 dgst_pos2 = 2;
9136 dgst_pos3 = 3;
9137 break;
9138
9139 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9140 salt_type = SALT_TYPE_EMBEDDED;
9141 attack_exec = ATTACK_EXEC_ON_GPU;
9142 opts_type = OPTS_TYPE_PT_GENERATE_LE
9143 | OPTS_TYPE_PT_ADD80
9144 | OPTS_TYPE_PT_UNICODE
9145 | OPTS_TYPE_PT_NEVERCRACK;
9146 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9147 dgst_size = DGST_SIZE_4_4;
9148 parse_func = oldoffice01cm2_parse_hash;
9149 sort_by_digest = sort_by_digest_4_4;
9150 opti_type = OPTI_TYPE_ZERO_BYTE
9151 | OPTI_TYPE_PRECOMPUTE_INIT
9152 | OPTI_TYPE_NOT_ITERATED;
9153 dgst_pos0 = 0;
9154 dgst_pos1 = 1;
9155 dgst_pos2 = 2;
9156 dgst_pos3 = 3;
9157 break;
9158
9159 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9160 salt_type = SALT_TYPE_EMBEDDED;
9161 attack_exec = ATTACK_EXEC_ON_GPU;
9162 opts_type = OPTS_TYPE_PT_GENERATE_BE
9163 | OPTS_TYPE_PT_ADD80
9164 | OPTS_TYPE_PT_UNICODE;
9165 kern_type = KERN_TYPE_OLDOFFICE34;
9166 dgst_size = DGST_SIZE_4_4;
9167 parse_func = oldoffice34_parse_hash;
9168 sort_by_digest = sort_by_digest_4_4;
9169 opti_type = OPTI_TYPE_ZERO_BYTE
9170 | OPTI_TYPE_PRECOMPUTE_INIT
9171 | OPTI_TYPE_NOT_ITERATED;
9172 dgst_pos0 = 0;
9173 dgst_pos1 = 1;
9174 dgst_pos2 = 2;
9175 dgst_pos3 = 3;
9176 break;
9177
9178 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9179 salt_type = SALT_TYPE_EMBEDDED;
9180 attack_exec = ATTACK_EXEC_ON_GPU;
9181 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9182 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9183 dgst_size = DGST_SIZE_4_4;
9184 parse_func = oldoffice34cm1_parse_hash;
9185 sort_by_digest = sort_by_digest_4_4;
9186 opti_type = OPTI_TYPE_ZERO_BYTE
9187 | OPTI_TYPE_PRECOMPUTE_INIT
9188 | OPTI_TYPE_NOT_ITERATED;
9189 dgst_pos0 = 0;
9190 dgst_pos1 = 1;
9191 dgst_pos2 = 2;
9192 dgst_pos3 = 3;
9193 break;
9194
9195 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9196 salt_type = SALT_TYPE_EMBEDDED;
9197 attack_exec = ATTACK_EXEC_ON_GPU;
9198 opts_type = OPTS_TYPE_PT_GENERATE_BE
9199 | OPTS_TYPE_PT_ADD80
9200 | OPTS_TYPE_PT_UNICODE
9201 | OPTS_TYPE_PT_NEVERCRACK;
9202 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9203 dgst_size = DGST_SIZE_4_4;
9204 parse_func = oldoffice34cm2_parse_hash;
9205 sort_by_digest = sort_by_digest_4_4;
9206 opti_type = OPTI_TYPE_ZERO_BYTE
9207 | OPTI_TYPE_PRECOMPUTE_INIT
9208 | OPTI_TYPE_NOT_ITERATED;
9209 dgst_pos0 = 0;
9210 dgst_pos1 = 1;
9211 dgst_pos2 = 2;
9212 dgst_pos3 = 3;
9213 break;
9214
9215 case 9900: hash_type = HASH_TYPE_MD5;
9216 salt_type = SALT_TYPE_NONE;
9217 attack_exec = ATTACK_EXEC_ON_GPU;
9218 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9219 kern_type = KERN_TYPE_RADMIN2;
9220 dgst_size = DGST_SIZE_4_4;
9221 parse_func = radmin2_parse_hash;
9222 sort_by_digest = sort_by_digest_4_4;
9223 opti_type = OPTI_TYPE_ZERO_BYTE
9224 | OPTI_TYPE_PRECOMPUTE_INIT
9225 | OPTI_TYPE_EARLY_SKIP
9226 | OPTI_TYPE_NOT_ITERATED
9227 | OPTI_TYPE_NOT_SALTED;
9228 dgst_pos0 = 0;
9229 dgst_pos1 = 3;
9230 dgst_pos2 = 2;
9231 dgst_pos3 = 1;
9232 break;
9233
9234 case 10000: hash_type = HASH_TYPE_SHA256;
9235 salt_type = SALT_TYPE_EMBEDDED;
9236 attack_exec = ATTACK_EXEC_ON_CPU;
9237 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9238 kern_type = KERN_TYPE_PBKDF2_SHA256;
9239 dgst_size = DGST_SIZE_4_32;
9240 parse_func = djangopbkdf2_parse_hash;
9241 sort_by_digest = sort_by_digest_4_32;
9242 opti_type = OPTI_TYPE_ZERO_BYTE;
9243 dgst_pos0 = 0;
9244 dgst_pos1 = 1;
9245 dgst_pos2 = 2;
9246 dgst_pos3 = 3;
9247 break;
9248
9249 case 10100: hash_type = HASH_TYPE_SIPHASH;
9250 salt_type = SALT_TYPE_EMBEDDED;
9251 attack_exec = ATTACK_EXEC_ON_GPU;
9252 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9253 kern_type = KERN_TYPE_SIPHASH;
9254 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9255 parse_func = siphash_parse_hash;
9256 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9257 opti_type = OPTI_TYPE_ZERO_BYTE
9258 | OPTI_TYPE_NOT_ITERATED
9259 | OPTI_TYPE_RAW_HASH;
9260 dgst_pos0 = 0;
9261 dgst_pos1 = 1;
9262 dgst_pos2 = 2;
9263 dgst_pos3 = 3;
9264 break;
9265
9266 case 10200: hash_type = HASH_TYPE_MD5;
9267 salt_type = SALT_TYPE_EMBEDDED;
9268 attack_exec = ATTACK_EXEC_ON_GPU;
9269 opts_type = OPTS_TYPE_PT_GENERATE_LE
9270 | OPTS_TYPE_ST_ADD80
9271 | OPTS_TYPE_ST_ADDBITS14;
9272 kern_type = KERN_TYPE_HMACMD5_PW;
9273 dgst_size = DGST_SIZE_4_4;
9274 parse_func = crammd5_parse_hash;
9275 sort_by_digest = sort_by_digest_4_4;
9276 opti_type = OPTI_TYPE_ZERO_BYTE
9277 | OPTI_TYPE_NOT_ITERATED;
9278 dgst_pos0 = 0;
9279 dgst_pos1 = 3;
9280 dgst_pos2 = 2;
9281 dgst_pos3 = 1;
9282 break;
9283
9284 case 10300: hash_type = HASH_TYPE_SHA1;
9285 salt_type = SALT_TYPE_EMBEDDED;
9286 attack_exec = ATTACK_EXEC_ON_CPU;
9287 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9288 kern_type = KERN_TYPE_SAPH_SHA1;
9289 dgst_size = DGST_SIZE_4_5;
9290 parse_func = saph_sha1_parse_hash;
9291 sort_by_digest = sort_by_digest_4_5;
9292 opti_type = OPTI_TYPE_ZERO_BYTE;
9293 dgst_pos0 = 0;
9294 dgst_pos1 = 1;
9295 dgst_pos2 = 2;
9296 dgst_pos3 = 3;
9297 break;
9298
9299 case 10400: hash_type = HASH_TYPE_PDFU16;
9300 salt_type = SALT_TYPE_EMBEDDED;
9301 attack_exec = ATTACK_EXEC_ON_GPU;
9302 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9303 kern_type = KERN_TYPE_PDF11;
9304 dgst_size = DGST_SIZE_4_4;
9305 parse_func = pdf11_parse_hash;
9306 sort_by_digest = sort_by_digest_4_4;
9307 opti_type = OPTI_TYPE_ZERO_BYTE
9308 | OPTI_TYPE_NOT_ITERATED;
9309 dgst_pos0 = 0;
9310 dgst_pos1 = 1;
9311 dgst_pos2 = 2;
9312 dgst_pos3 = 3;
9313 break;
9314
9315 case 10410: hash_type = HASH_TYPE_PDFU16;
9316 salt_type = SALT_TYPE_EMBEDDED;
9317 attack_exec = ATTACK_EXEC_ON_GPU;
9318 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9319 kern_type = KERN_TYPE_PDF11CM1;
9320 dgst_size = DGST_SIZE_4_4;
9321 parse_func = pdf11cm1_parse_hash;
9322 sort_by_digest = sort_by_digest_4_4;
9323 opti_type = OPTI_TYPE_ZERO_BYTE
9324 | OPTI_TYPE_NOT_ITERATED;
9325 dgst_pos0 = 0;
9326 dgst_pos1 = 1;
9327 dgst_pos2 = 2;
9328 dgst_pos3 = 3;
9329 break;
9330
9331 case 10420: hash_type = HASH_TYPE_PDFU16;
9332 salt_type = SALT_TYPE_EMBEDDED;
9333 attack_exec = ATTACK_EXEC_ON_GPU;
9334 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9335 kern_type = KERN_TYPE_PDF11CM2;
9336 dgst_size = DGST_SIZE_4_4;
9337 parse_func = pdf11cm2_parse_hash;
9338 sort_by_digest = sort_by_digest_4_4;
9339 opti_type = OPTI_TYPE_ZERO_BYTE
9340 | OPTI_TYPE_NOT_ITERATED;
9341 dgst_pos0 = 0;
9342 dgst_pos1 = 1;
9343 dgst_pos2 = 2;
9344 dgst_pos3 = 3;
9345 break;
9346
9347 case 10500: hash_type = HASH_TYPE_PDFU16;
9348 salt_type = SALT_TYPE_EMBEDDED;
9349 attack_exec = ATTACK_EXEC_ON_CPU;
9350 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9351 kern_type = KERN_TYPE_PDF14;
9352 dgst_size = DGST_SIZE_4_4;
9353 parse_func = pdf14_parse_hash;
9354 sort_by_digest = sort_by_digest_4_4;
9355 opti_type = OPTI_TYPE_ZERO_BYTE
9356 | OPTI_TYPE_NOT_ITERATED;
9357 dgst_pos0 = 0;
9358 dgst_pos1 = 1;
9359 dgst_pos2 = 2;
9360 dgst_pos3 = 3;
9361 break;
9362
9363 case 10600: hash_type = HASH_TYPE_SHA256;
9364 salt_type = SALT_TYPE_EMBEDDED;
9365 attack_exec = ATTACK_EXEC_ON_GPU;
9366 opts_type = OPTS_TYPE_PT_GENERATE_BE
9367 | OPTS_TYPE_ST_ADD80
9368 | OPTS_TYPE_ST_ADDBITS15
9369 | OPTS_TYPE_HASH_COPY;
9370 kern_type = KERN_TYPE_SHA256_PWSLT;
9371 dgst_size = DGST_SIZE_4_8;
9372 parse_func = pdf17l3_parse_hash;
9373 sort_by_digest = sort_by_digest_4_8;
9374 opti_type = OPTI_TYPE_ZERO_BYTE
9375 | OPTI_TYPE_PRECOMPUTE_INIT
9376 | OPTI_TYPE_PRECOMPUTE_MERKLE
9377 | OPTI_TYPE_EARLY_SKIP
9378 | OPTI_TYPE_NOT_ITERATED
9379 | OPTI_TYPE_APPENDED_SALT
9380 | OPTI_TYPE_RAW_HASH;
9381 dgst_pos0 = 3;
9382 dgst_pos1 = 7;
9383 dgst_pos2 = 2;
9384 dgst_pos3 = 6;
9385 break;
9386
9387 case 10700: hash_type = HASH_TYPE_PDFU32;
9388 salt_type = SALT_TYPE_EMBEDDED;
9389 attack_exec = ATTACK_EXEC_ON_CPU;
9390 opts_type = OPTS_TYPE_PT_GENERATE_LE
9391 | OPTS_TYPE_HASH_COPY;
9392 kern_type = KERN_TYPE_PDF17L8;
9393 dgst_size = DGST_SIZE_4_8;
9394 parse_func = pdf17l8_parse_hash;
9395 sort_by_digest = sort_by_digest_4_8;
9396 opti_type = OPTI_TYPE_ZERO_BYTE
9397 | OPTI_TYPE_NOT_ITERATED;
9398 dgst_pos0 = 0;
9399 dgst_pos1 = 1;
9400 dgst_pos2 = 2;
9401 dgst_pos3 = 3;
9402 break;
9403
9404 case 10800: hash_type = HASH_TYPE_SHA384;
9405 salt_type = SALT_TYPE_NONE;
9406 attack_exec = ATTACK_EXEC_ON_GPU;
9407 opts_type = OPTS_TYPE_PT_GENERATE_BE
9408 | OPTS_TYPE_PT_ADD80
9409 | OPTS_TYPE_PT_ADDBITS15;
9410 kern_type = KERN_TYPE_SHA384;
9411 dgst_size = DGST_SIZE_8_8;
9412 parse_func = sha384_parse_hash;
9413 sort_by_digest = sort_by_digest_8_8;
9414 opti_type = OPTI_TYPE_ZERO_BYTE
9415 | OPTI_TYPE_PRECOMPUTE_INIT
9416 | OPTI_TYPE_PRECOMPUTE_MERKLE
9417 | OPTI_TYPE_EARLY_SKIP
9418 | OPTI_TYPE_NOT_ITERATED
9419 | OPTI_TYPE_NOT_SALTED
9420 | OPTI_TYPE_RAW_HASH;
9421 dgst_pos0 = 6;
9422 dgst_pos1 = 7;
9423 dgst_pos2 = 4;
9424 dgst_pos3 = 5;
9425 break;
9426
9427 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9428 salt_type = SALT_TYPE_EMBEDDED;
9429 attack_exec = ATTACK_EXEC_ON_CPU;
9430 opts_type = OPTS_TYPE_PT_GENERATE_LE
9431 | OPTS_TYPE_ST_BASE64
9432 | OPTS_TYPE_HASH_COPY;
9433 kern_type = KERN_TYPE_PBKDF2_SHA256;
9434 dgst_size = DGST_SIZE_4_32;
9435 parse_func = pbkdf2_sha256_parse_hash;
9436 sort_by_digest = sort_by_digest_4_32;
9437 opti_type = OPTI_TYPE_ZERO_BYTE;
9438 dgst_pos0 = 0;
9439 dgst_pos1 = 1;
9440 dgst_pos2 = 2;
9441 dgst_pos3 = 3;
9442 break;
9443
9444 case 11000: hash_type = HASH_TYPE_MD5;
9445 salt_type = SALT_TYPE_INTERN;
9446 attack_exec = ATTACK_EXEC_ON_GPU;
9447 opts_type = OPTS_TYPE_PT_GENERATE_LE
9448 | OPTS_TYPE_PT_ADD80;
9449 kern_type = KERN_TYPE_PRESTASHOP;
9450 dgst_size = DGST_SIZE_4_4;
9451 parse_func = prestashop_parse_hash;
9452 sort_by_digest = sort_by_digest_4_4;
9453 opti_type = OPTI_TYPE_ZERO_BYTE
9454 | OPTI_TYPE_PRECOMPUTE_INIT
9455 | OPTI_TYPE_NOT_ITERATED
9456 | OPTI_TYPE_PREPENDED_SALT;
9457 dgst_pos0 = 0;
9458 dgst_pos1 = 3;
9459 dgst_pos2 = 2;
9460 dgst_pos3 = 1;
9461 break;
9462
9463 case 11100: hash_type = HASH_TYPE_MD5;
9464 salt_type = SALT_TYPE_EMBEDDED;
9465 attack_exec = ATTACK_EXEC_ON_GPU;
9466 opts_type = OPTS_TYPE_PT_GENERATE_LE
9467 | OPTS_TYPE_ST_ADD80;
9468 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9469 dgst_size = DGST_SIZE_4_4;
9470 parse_func = postgresql_auth_parse_hash;
9471 sort_by_digest = sort_by_digest_4_4;
9472 opti_type = OPTI_TYPE_ZERO_BYTE
9473 | OPTI_TYPE_PRECOMPUTE_INIT
9474 | OPTI_TYPE_PRECOMPUTE_MERKLE
9475 | OPTI_TYPE_EARLY_SKIP;
9476 dgst_pos0 = 0;
9477 dgst_pos1 = 3;
9478 dgst_pos2 = 2;
9479 dgst_pos3 = 1;
9480 break;
9481
9482 case 11200: hash_type = HASH_TYPE_SHA1;
9483 salt_type = SALT_TYPE_EMBEDDED;
9484 attack_exec = ATTACK_EXEC_ON_GPU;
9485 opts_type = OPTS_TYPE_PT_GENERATE_BE
9486 | OPTS_TYPE_PT_ADD80
9487 | OPTS_TYPE_ST_HEX;
9488 kern_type = KERN_TYPE_MYSQL_AUTH;
9489 dgst_size = DGST_SIZE_4_5;
9490 parse_func = mysql_auth_parse_hash;
9491 sort_by_digest = sort_by_digest_4_5;
9492 opti_type = OPTI_TYPE_ZERO_BYTE
9493 | OPTI_TYPE_EARLY_SKIP;
9494 dgst_pos0 = 3;
9495 dgst_pos1 = 4;
9496 dgst_pos2 = 2;
9497 dgst_pos3 = 1;
9498 break;
9499
9500 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9501 salt_type = SALT_TYPE_EMBEDDED;
9502 attack_exec = ATTACK_EXEC_ON_CPU;
9503 opts_type = OPTS_TYPE_PT_GENERATE_LE
9504 | OPTS_TYPE_ST_HEX
9505 | OPTS_TYPE_ST_ADD80;
9506 kern_type = KERN_TYPE_BITCOIN_WALLET;
9507 dgst_size = DGST_SIZE_4_4;
9508 parse_func = bitcoin_wallet_parse_hash;
9509 sort_by_digest = sort_by_digest_4_4;
9510 opti_type = OPTI_TYPE_ZERO_BYTE;
9511 dgst_pos0 = 0;
9512 dgst_pos1 = 1;
9513 dgst_pos2 = 2;
9514 dgst_pos3 = 3;
9515 break;
9516
9517 case 11400: hash_type = HASH_TYPE_MD5;
9518 salt_type = SALT_TYPE_EMBEDDED;
9519 attack_exec = ATTACK_EXEC_ON_GPU;
9520 opts_type = OPTS_TYPE_PT_GENERATE_LE
9521 | OPTS_TYPE_PT_ADD80
9522 | OPTS_TYPE_HASH_COPY;
9523 kern_type = KERN_TYPE_SIP_AUTH;
9524 dgst_size = DGST_SIZE_4_4;
9525 parse_func = sip_auth_parse_hash;
9526 sort_by_digest = sort_by_digest_4_4;
9527 opti_type = OPTI_TYPE_ZERO_BYTE;
9528 dgst_pos0 = 0;
9529 dgst_pos1 = 3;
9530 dgst_pos2 = 2;
9531 dgst_pos3 = 1;
9532 break;
9533
9534 case 11500: hash_type = HASH_TYPE_CRC32;
9535 salt_type = SALT_TYPE_INTERN;
9536 attack_exec = ATTACK_EXEC_ON_GPU;
9537 opts_type = OPTS_TYPE_PT_GENERATE_LE
9538 | OPTS_TYPE_ST_GENERATE_LE
9539 | OPTS_TYPE_ST_HEX;
9540 kern_type = KERN_TYPE_CRC32;
9541 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9542 parse_func = crc32_parse_hash;
9543 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9544 opti_type = OPTI_TYPE_ZERO_BYTE;
9545 dgst_pos0 = 0;
9546 dgst_pos1 = 1;
9547 dgst_pos2 = 2;
9548 dgst_pos3 = 3;
9549 break;
9550
9551 case 11600: hash_type = HASH_TYPE_AES;
9552 salt_type = SALT_TYPE_EMBEDDED;
9553 attack_exec = ATTACK_EXEC_ON_CPU;
9554 opts_type = OPTS_TYPE_PT_GENERATE_LE
9555 | OPTS_TYPE_PT_NEVERCRACK;
9556 kern_type = KERN_TYPE_SEVEN_ZIP;
9557 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9558 parse_func = seven_zip_parse_hash;
9559 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9560 opti_type = OPTI_TYPE_ZERO_BYTE;
9561 dgst_pos0 = 0;
9562 dgst_pos1 = 1;
9563 dgst_pos2 = 2;
9564 dgst_pos3 = 3;
9565 break;
9566
9567 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9568 salt_type = SALT_TYPE_NONE;
9569 attack_exec = ATTACK_EXEC_ON_GPU;
9570 opts_type = OPTS_TYPE_PT_GENERATE_LE
9571 | OPTS_TYPE_PT_ADD01;
9572 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9573 dgst_size = DGST_SIZE_4_8;
9574 parse_func = gost2012sbog_256_parse_hash;
9575 sort_by_digest = sort_by_digest_4_8;
9576 opti_type = OPTI_TYPE_ZERO_BYTE;
9577 dgst_pos0 = 0;
9578 dgst_pos1 = 1;
9579 dgst_pos2 = 2;
9580 dgst_pos3 = 3;
9581 break;
9582
9583 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9584 salt_type = SALT_TYPE_NONE;
9585 attack_exec = ATTACK_EXEC_ON_GPU;
9586 opts_type = OPTS_TYPE_PT_GENERATE_LE
9587 | OPTS_TYPE_PT_ADD01;
9588 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9589 dgst_size = DGST_SIZE_4_16;
9590 parse_func = gost2012sbog_512_parse_hash;
9591 sort_by_digest = sort_by_digest_4_16;
9592 opti_type = OPTI_TYPE_ZERO_BYTE;
9593 dgst_pos0 = 0;
9594 dgst_pos1 = 1;
9595 dgst_pos2 = 2;
9596 dgst_pos3 = 3;
9597 break;
9598
9599 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9600 salt_type = SALT_TYPE_EMBEDDED;
9601 attack_exec = ATTACK_EXEC_ON_CPU;
9602 opts_type = OPTS_TYPE_PT_GENERATE_LE
9603 | OPTS_TYPE_ST_BASE64
9604 | OPTS_TYPE_HASH_COPY;
9605 kern_type = KERN_TYPE_PBKDF2_MD5;
9606 dgst_size = DGST_SIZE_4_32;
9607 parse_func = pbkdf2_md5_parse_hash;
9608 sort_by_digest = sort_by_digest_4_32;
9609 opti_type = OPTI_TYPE_ZERO_BYTE;
9610 dgst_pos0 = 0;
9611 dgst_pos1 = 1;
9612 dgst_pos2 = 2;
9613 dgst_pos3 = 3;
9614 break;
9615
9616 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
9617 salt_type = SALT_TYPE_EMBEDDED;
9618 attack_exec = ATTACK_EXEC_ON_CPU;
9619 opts_type = OPTS_TYPE_PT_GENERATE_LE
9620 | OPTS_TYPE_ST_BASE64
9621 | OPTS_TYPE_HASH_COPY;
9622 kern_type = KERN_TYPE_PBKDF2_SHA1;
9623 dgst_size = DGST_SIZE_4_32;
9624 parse_func = pbkdf2_sha1_parse_hash;
9625 sort_by_digest = sort_by_digest_4_32;
9626 opti_type = OPTI_TYPE_ZERO_BYTE;
9627 dgst_pos0 = 0;
9628 dgst_pos1 = 1;
9629 dgst_pos2 = 2;
9630 dgst_pos3 = 3;
9631 break;
9632
9633 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
9634 salt_type = SALT_TYPE_EMBEDDED;
9635 attack_exec = ATTACK_EXEC_ON_CPU;
9636 opts_type = OPTS_TYPE_PT_GENERATE_LE
9637 | OPTS_TYPE_ST_BASE64
9638 | OPTS_TYPE_HASH_COPY;
9639 kern_type = KERN_TYPE_PBKDF2_SHA512;
9640 dgst_size = DGST_SIZE_8_16;
9641 parse_func = pbkdf2_sha512_parse_hash;
9642 sort_by_digest = sort_by_digest_8_16;
9643 opti_type = OPTI_TYPE_ZERO_BYTE;
9644 dgst_pos0 = 0;
9645 dgst_pos1 = 1;
9646 dgst_pos2 = 2;
9647 dgst_pos3 = 3;
9648 break;
9649
9650 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
9651 salt_type = SALT_TYPE_EMBEDDED;
9652 attack_exec = ATTACK_EXEC_ON_CPU;
9653 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9654 kern_type = KERN_TYPE_ECRYPTFS;
9655 dgst_size = DGST_SIZE_8_8;
9656 parse_func = ecryptfs_parse_hash;
9657 sort_by_digest = sort_by_digest_8_8;
9658 opti_type = OPTI_TYPE_ZERO_BYTE;
9659 dgst_pos0 = 0;
9660 dgst_pos1 = 1;
9661 dgst_pos2 = 2;
9662 dgst_pos3 = 3;
9663 break;
9664
9665 case 12300: hash_type = HASH_TYPE_ORACLET;
9666 salt_type = SALT_TYPE_EMBEDDED;
9667 attack_exec = ATTACK_EXEC_ON_CPU;
9668 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9669 kern_type = KERN_TYPE_ORACLET;
9670 dgst_size = DGST_SIZE_8_16;
9671 parse_func = oraclet_parse_hash;
9672 sort_by_digest = sort_by_digest_8_16;
9673 opti_type = OPTI_TYPE_ZERO_BYTE;
9674 dgst_pos0 = 0;
9675 dgst_pos1 = 1;
9676 dgst_pos2 = 2;
9677 dgst_pos3 = 3;
9678 break;
9679
9680 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
9681 salt_type = SALT_TYPE_EMBEDDED;
9682 attack_exec = ATTACK_EXEC_ON_CPU;
9683 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9684 kern_type = KERN_TYPE_BSDICRYPT;
9685 dgst_size = DGST_SIZE_4_4;
9686 parse_func = bsdicrypt_parse_hash;
9687 sort_by_digest = sort_by_digest_4_4;
9688 opti_type = OPTI_TYPE_ZERO_BYTE
9689 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9690 dgst_pos0 = 0;
9691 dgst_pos1 = 1;
9692 dgst_pos2 = 2;
9693 dgst_pos3 = 3;
9694 break;
9695
9696 case 12500: hash_type = HASH_TYPE_RAR3HP;
9697 salt_type = SALT_TYPE_EMBEDDED;
9698 attack_exec = ATTACK_EXEC_ON_CPU;
9699 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9700 kern_type = KERN_TYPE_RAR3;
9701 dgst_size = DGST_SIZE_4_4;
9702 parse_func = rar3hp_parse_hash;
9703 sort_by_digest = sort_by_digest_4_4;
9704 opti_type = OPTI_TYPE_ZERO_BYTE;
9705 dgst_pos0 = 0;
9706 dgst_pos1 = 1;
9707 dgst_pos2 = 2;
9708 dgst_pos3 = 3;
9709 break;
9710
9711 case 12600: hash_type = HASH_TYPE_SHA256;
9712 salt_type = SALT_TYPE_INTERN;
9713 attack_exec = ATTACK_EXEC_ON_GPU;
9714 opts_type = OPTS_TYPE_PT_GENERATE_BE
9715 | OPTS_TYPE_PT_ADD80;
9716 kern_type = KERN_TYPE_CF10;
9717 dgst_size = DGST_SIZE_4_8;
9718 parse_func = cf10_parse_hash;
9719 sort_by_digest = sort_by_digest_4_8;
9720 opti_type = OPTI_TYPE_ZERO_BYTE
9721 | OPTI_TYPE_PRECOMPUTE_INIT
9722 | OPTI_TYPE_EARLY_SKIP
9723 | OPTI_TYPE_NOT_ITERATED;
9724 dgst_pos0 = 3;
9725 dgst_pos1 = 7;
9726 dgst_pos2 = 2;
9727 dgst_pos3 = 6;
9728 break;
9729
9730 case 12700: hash_type = HASH_TYPE_AES;
9731 salt_type = SALT_TYPE_EMBEDDED;
9732 attack_exec = ATTACK_EXEC_ON_CPU;
9733 opts_type = OPTS_TYPE_PT_GENERATE_LE
9734 | OPTS_TYPE_HASH_COPY;
9735 kern_type = KERN_TYPE_MYWALLET;
9736 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9737 parse_func = mywallet_parse_hash;
9738 sort_by_digest = sort_by_digest_4_5;
9739 opti_type = OPTI_TYPE_ZERO_BYTE;
9740 dgst_pos0 = 0;
9741 dgst_pos1 = 1;
9742 dgst_pos2 = 2;
9743 dgst_pos3 = 3;
9744 break;
9745
9746 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
9747 salt_type = SALT_TYPE_EMBEDDED;
9748 attack_exec = ATTACK_EXEC_ON_CPU;
9749 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9750 kern_type = KERN_TYPE_MS_DRSR;
9751 dgst_size = DGST_SIZE_4_8;
9752 parse_func = ms_drsr_parse_hash;
9753 sort_by_digest = sort_by_digest_4_8;
9754 opti_type = OPTI_TYPE_ZERO_BYTE;
9755 dgst_pos0 = 0;
9756 dgst_pos1 = 1;
9757 dgst_pos2 = 2;
9758 dgst_pos3 = 3;
9759 break;
9760
9761 default: usage_mini_print (PROGNAME); return (-1);
9762 }
9763
9764 /**
9765 * transpose
9766 */
9767
9768 data.parse_func = parse_func;
9769
9770 /**
9771 * misc stuff
9772 */
9773
9774 if (hex_salt)
9775 {
9776 if (salt_type == SALT_TYPE_INTERN)
9777 {
9778 opts_type |= OPTS_TYPE_ST_HEX;
9779 }
9780 else
9781 {
9782 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
9783
9784 return (-1);
9785 }
9786 }
9787
9788 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
9789 | (salt_type == SALT_TYPE_EXTERN)
9790 | (salt_type == SALT_TYPE_EMBEDDED)
9791 | (salt_type == SALT_TYPE_VIRTUAL));
9792
9793 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
9794
9795 data.hash_type = hash_type;
9796 data.attack_mode = attack_mode;
9797 data.attack_kern = attack_kern;
9798 data.attack_exec = attack_exec;
9799 data.kern_type = kern_type;
9800 data.opts_type = opts_type;
9801 data.dgst_size = dgst_size;
9802 data.salt_type = salt_type;
9803 data.isSalted = isSalted;
9804 data.sort_by_digest = sort_by_digest;
9805 data.dgst_pos0 = dgst_pos0;
9806 data.dgst_pos1 = dgst_pos1;
9807 data.dgst_pos2 = dgst_pos2;
9808 data.dgst_pos3 = dgst_pos3;
9809
9810 esalt_size = 0;
9811
9812 switch (hash_mode)
9813 {
9814 case 2500: esalt_size = sizeof (wpa_t); break;
9815 case 5300: esalt_size = sizeof (ikepsk_t); break;
9816 case 5400: esalt_size = sizeof (ikepsk_t); break;
9817 case 5500: esalt_size = sizeof (netntlm_t); break;
9818 case 5600: esalt_size = sizeof (netntlm_t); break;
9819 case 6211:
9820 case 6212:
9821 case 6213:
9822 case 6221:
9823 case 6222:
9824 case 6223:
9825 case 6231:
9826 case 6232:
9827 case 6233:
9828 case 6241:
9829 case 6242:
9830 case 6243: esalt_size = sizeof (tc_t); break;
9831 case 6600: esalt_size = sizeof (agilekey_t); break;
9832 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
9833 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
9834 case 7300: esalt_size = sizeof (rakp_t); break;
9835 case 7500: esalt_size = sizeof (krb5pa_t); break;
9836 case 8200: esalt_size = sizeof (cloudkey_t); break;
9837 case 8800: esalt_size = sizeof (androidfde_t); break;
9838 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
9839 case 9400: esalt_size = sizeof (office2007_t); break;
9840 case 9500: esalt_size = sizeof (office2010_t); break;
9841 case 9600: esalt_size = sizeof (office2013_t); break;
9842 case 9700: esalt_size = sizeof (oldoffice01_t); break;
9843 case 9710: esalt_size = sizeof (oldoffice01_t); break;
9844 case 9720: esalt_size = sizeof (oldoffice01_t); break;
9845 case 9800: esalt_size = sizeof (oldoffice34_t); break;
9846 case 9810: esalt_size = sizeof (oldoffice34_t); break;
9847 case 9820: esalt_size = sizeof (oldoffice34_t); break;
9848 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
9849 case 10200: esalt_size = sizeof (cram_md5_t); break;
9850 case 10400: esalt_size = sizeof (pdf_t); break;
9851 case 10410: esalt_size = sizeof (pdf_t); break;
9852 case 10420: esalt_size = sizeof (pdf_t); break;
9853 case 10500: esalt_size = sizeof (pdf_t); break;
9854 case 10600: esalt_size = sizeof (pdf_t); break;
9855 case 10700: esalt_size = sizeof (pdf_t); break;
9856 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
9857 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
9858 case 11400: esalt_size = sizeof (sip_t); break;
9859 case 11600: esalt_size = sizeof (seven_zip_t); break;
9860 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
9861 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
9862 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
9863 }
9864
9865 data.esalt_size = esalt_size;
9866
9867 /**
9868 * choose dictionary parser
9869 */
9870
9871 if (hash_type == HASH_TYPE_LM)
9872 {
9873 get_next_word_func = get_next_word_lm;
9874 }
9875 else if (opts_type & OPTS_TYPE_PT_UPPER)
9876 {
9877 get_next_word_func = get_next_word_uc;
9878 }
9879 else
9880 {
9881 get_next_word_func = get_next_word_std;
9882 }
9883
9884 /**
9885 * dictstat
9886 */
9887
9888 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
9889
9890 #ifdef _POSIX
9891 size_t dictstat_nmemb = 0;
9892 #endif
9893
9894 #ifdef _WIN
9895 uint dictstat_nmemb = 0;
9896 #endif
9897
9898 char dictstat[256];
9899
9900 FILE *dictstat_fp = NULL;
9901
9902 if (keyspace == 0)
9903 {
9904 memset (dictstat, 0, sizeof (dictstat));
9905
9906 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s.dictstat", install_dir, PROGNAME);
9907
9908 dictstat_fp = fopen (dictstat, "rb");
9909
9910 if (dictstat_fp)
9911 {
9912 #ifdef _POSIX
9913 struct stat tmpstat;
9914
9915 fstat (fileno (dictstat_fp), &tmpstat);
9916 #endif
9917
9918 #ifdef _WIN
9919 struct stat64 tmpstat;
9920
9921 _fstat64 (fileno (dictstat_fp), &tmpstat);
9922 #endif
9923
9924 if (tmpstat.st_mtime < COMPTIME)
9925 {
9926 /* with v0.15 the format changed so we have to ensure user is using a good version
9927 since there is no version-header in the dictstat file */
9928
9929 fclose (dictstat_fp);
9930
9931 unlink (dictstat);
9932 }
9933 else
9934 {
9935 while (!feof (dictstat_fp))
9936 {
9937 dictstat_t d;
9938
9939 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
9940
9941 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
9942
9943 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
9944 {
9945 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
9946
9947 return -1;
9948 }
9949 }
9950
9951 fclose (dictstat_fp);
9952 }
9953 }
9954 }
9955
9956 /**
9957 * potfile
9958 */
9959
9960 char potfile[256];
9961
9962 memset (potfile, 0, sizeof (potfile));
9963
9964 snprintf (potfile, sizeof (potfile) - 1, "%s.pot", session);
9965
9966 data.pot_fp = NULL;
9967
9968 FILE *out_fp = NULL;
9969 FILE *pot_fp = NULL;
9970
9971 if (show == 1 || left == 1)
9972 {
9973 pot_fp = fopen (potfile, "rb");
9974
9975 if (pot_fp == NULL)
9976 {
9977 log_error ("ERROR: %s: %s", potfile, strerror (errno));
9978
9979 return (-1);
9980 }
9981
9982 if (outfile != NULL)
9983 {
9984 if ((out_fp = fopen (outfile, "ab")) == NULL)
9985 {
9986 log_error ("ERROR: %s: %s", outfile, strerror (errno));
9987
9988 fclose (pot_fp);
9989
9990 return (-1);
9991 }
9992 }
9993 else
9994 {
9995 out_fp = stdout;
9996 }
9997 }
9998 else
9999 {
10000 if (potfile_disable == 0)
10001 {
10002 pot_fp = fopen (potfile, "ab");
10003
10004 if (pot_fp == NULL)
10005 {
10006 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10007
10008 return (-1);
10009 }
10010
10011 data.pot_fp = pot_fp;
10012 }
10013 }
10014
10015 pot_t *pot = NULL;
10016
10017 uint pot_cnt = 0;
10018 uint pot_avail = 0;
10019
10020 if (show == 1 || left == 1)
10021 {
10022 SUPPRESS_OUTPUT = 1;
10023
10024 pot_avail = count_lines (pot_fp);
10025
10026 rewind (pot_fp);
10027
10028 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10029
10030 uint pot_hashes_avail = 0;
10031
10032 uint line_num = 0;
10033
10034 while (!feof (pot_fp))
10035 {
10036 line_num++;
10037
10038 char line_buf[BUFSIZ];
10039
10040 int line_len = fgetl (pot_fp, line_buf);
10041
10042 if (line_len == 0) continue;
10043
10044 char *plain_buf = line_buf + line_len;
10045
10046 pot_t *pot_ptr = &pot[pot_cnt];
10047
10048 hash_t *hashes_buf = &pot_ptr->hash;
10049
10050 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10051 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10052
10053 if (pot_cnt == pot_hashes_avail)
10054 {
10055 uint pos = 0;
10056
10057 for (pos = 0; pos < INCR_POT; pos++)
10058 {
10059 if ((pot_cnt + pos) >= pot_avail) break;
10060
10061 pot_t *tmp_pot = &pot[pot_cnt + pos];
10062
10063 hash_t *tmp_hash = &tmp_pot->hash;
10064
10065 tmp_hash->digest = mymalloc (dgst_size);
10066
10067 if (isSalted)
10068 {
10069 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10070 }
10071
10072 if (esalt_size)
10073 {
10074 tmp_hash->esalt = mymalloc (esalt_size);
10075 }
10076
10077 pot_hashes_avail++;
10078 }
10079 }
10080
10081 int plain_len = 0;
10082
10083 int parser_status;
10084
10085 int iter = MAX_CUT_TRIES;
10086
10087 do
10088 {
10089 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10090 {
10091 if (line_buf[i] == ':')
10092 {
10093 line_len--;
10094
10095 break;
10096 }
10097 }
10098
10099 if (data.hash_mode != 2500)
10100 {
10101 parser_status = parse_func (line_buf, line_len, hashes_buf);
10102 }
10103 else
10104 {
10105 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10106
10107 if (line_len > max_salt_size)
10108 {
10109 parser_status = PARSER_GLOBAL_LENGTH;
10110 }
10111 else
10112 {
10113 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10114
10115 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10116
10117 hashes_buf->salt->salt_len = line_len;
10118
10119 parser_status = PARSER_OK;
10120 }
10121 }
10122
10123 // if NOT parsed without error, we add the ":" to the plain
10124
10125 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10126 {
10127 plain_len++;
10128 plain_buf--;
10129 }
10130
10131 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10132
10133 if (parser_status < PARSER_GLOBAL_ZERO)
10134 {
10135 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10136
10137 continue;
10138 }
10139
10140 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10141
10142 pot_ptr->plain_len = plain_len;
10143
10144 pot_cnt++;
10145 }
10146
10147 fclose (pot_fp);
10148
10149 SUPPRESS_OUTPUT = 0;
10150
10151 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10152 }
10153
10154 /**
10155 * gpu accel and loops auto adjustment
10156 */
10157
10158 if (gpu_accel_chgd == 0) gpu_accel = set_gpu_accel (hash_mode);
10159 if (gpu_loops_chgd == 0) gpu_loops = set_gpu_loops (hash_mode);
10160
10161 if (workload_profile == 1)
10162 {
10163 gpu_loops /= 8;
10164 gpu_accel /= 4;
10165
10166 if (gpu_loops == 0) gpu_loops = 8;
10167 if (gpu_accel == 0) gpu_accel = 2;
10168 }
10169 else if (workload_profile == 3)
10170 {
10171 gpu_loops *= 8;
10172 gpu_accel *= 4;
10173
10174 if (gpu_loops > 1024) gpu_loops = 1024;
10175 if (gpu_accel > 256) gpu_accel = 256; // causes memory problems otherwise
10176 }
10177
10178 // those hashes *must* run at a specific gpu_loops count because of some optimization inside the kernel
10179
10180 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
10181 {
10182 gpu_loops = 1024;
10183 }
10184
10185 if (hash_mode == 12500)
10186 {
10187 gpu_loops = ROUNDS_RAR3 / 16;
10188 }
10189
10190 data.gpu_accel = gpu_accel;
10191 data.gpu_loops = gpu_loops;
10192
10193 /**
10194 * word len
10195 */
10196
10197 uint pw_min = PW_MIN;
10198 uint pw_max = PW_MAX;
10199
10200 switch (hash_mode)
10201 {
10202 case 400: if (pw_max > 40) pw_max = 40;
10203 break;
10204 case 500: if (pw_max > 16) pw_max = 16;
10205 break;
10206 case 1500: if (pw_max > 8) pw_max = 8;
10207 break;
10208 case 1600: if (pw_max > 16) pw_max = 16;
10209 break;
10210 case 1800: if (pw_max > 16) pw_max = 16;
10211 break;
10212 case 2100: if (pw_max > 16) pw_max = 16;
10213 break;
10214 case 2500: if (pw_min < 8) pw_min = 8;
10215 break;
10216 case 3000: if (pw_max > 7) pw_max = 7;
10217 break;
10218 case 5200: if (pw_max > 24) pw_max = 24;
10219 break;
10220 case 5800: if (pw_max > 16) pw_max = 16;
10221 break;
10222 case 6300: if (pw_max > 16) pw_max = 16;
10223 break;
10224 case 7400: if (pw_max > 16) pw_max = 16;
10225 break;
10226 case 7900: if (pw_max > 48) pw_max = 48;
10227 break;
10228 case 8500: if (pw_max > 8) pw_max = 8;
10229 break;
10230 case 8600: if (pw_max > 16) pw_max = 16;
10231 break;
10232 case 9710: pw_min = 5;
10233 pw_max = 5;
10234 break;
10235 case 9810: pw_min = 5;
10236 pw_max = 5;
10237 break;
10238 case 10410: pw_min = 5;
10239 pw_max = 5;
10240 break;
10241 case 10300: if (pw_max < 3) pw_min = 3;
10242 if (pw_max > 40) pw_max = 40;
10243 break;
10244 case 10500: if (pw_max < 3) pw_min = 3;
10245 if (pw_max > 40) pw_max = 40;
10246 break;
10247 case 10700: if (pw_max > 16) pw_max = 16;
10248 break;
10249 case 11300: if (pw_max > 40) pw_max = 40;
10250 break;
10251 case 12500: if (pw_max > 20) pw_max = 20;
10252 break;
10253 case 12800: if (pw_max > 24) pw_max = 24;
10254 break;
10255 }
10256
10257 if (attack_exec == ATTACK_EXEC_ON_GPU)
10258 {
10259 switch (attack_kern)
10260 {
10261 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10262 break;
10263 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10264 break;
10265 }
10266 }
10267
10268 /**
10269 * charsets : keep them together for more easy maintainnce
10270 */
10271
10272 cs_t mp_sys[6];
10273 cs_t mp_usr[4];
10274
10275 memset (mp_sys, 0, sizeof (mp_sys));
10276 memset (mp_usr, 0, sizeof (mp_usr));
10277
10278 mp_setup_sys (mp_sys);
10279
10280 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10281 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10282 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10283 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10284
10285 /**
10286 * load hashes, part I: find input mode, count hashes
10287 */
10288
10289 uint hashlist_mode = 0;
10290 uint hashlist_format = HLFMT_HASHCAT;
10291
10292 uint hashes_avail = 0;
10293
10294 if (benchmark == 0)
10295 {
10296 struct stat f;
10297
10298 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10299
10300 if ((hash_mode == 2500) ||
10301 (hash_mode == 5200) ||
10302 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10303 (hash_mode == 9000))
10304 {
10305 hashlist_mode = HL_MODE_ARG;
10306
10307 char *hashfile = myargv[optind];
10308
10309 data.hashfile = hashfile;
10310
10311 logfile_top_var_string ("target", hashfile);
10312 }
10313
10314 if (hashlist_mode == HL_MODE_ARG)
10315 {
10316 if (hash_mode == 2500)
10317 {
10318 struct stat st;
10319
10320 if (stat (data.hashfile, &st) == -1)
10321 {
10322 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10323
10324 return (-1);
10325 }
10326
10327 hashes_avail = st.st_size / sizeof (hccap_t);
10328 }
10329 else
10330 {
10331 hashes_avail = 1;
10332 }
10333 }
10334 else if (hashlist_mode == HL_MODE_FILE)
10335 {
10336 char *hashfile = myargv[optind];
10337
10338 data.hashfile = hashfile;
10339
10340 logfile_top_var_string ("target", hashfile);
10341
10342 FILE *fp = NULL;
10343
10344 if ((fp = fopen (hashfile, "rb")) == NULL)
10345 {
10346 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10347
10348 return (-1);
10349 }
10350
10351 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10352
10353 hashes_avail = count_lines (fp);
10354
10355 rewind (fp);
10356
10357 if (hashes_avail == 0)
10358 {
10359 log_error ("ERROR: hashfile is empty or corrupt");
10360
10361 fclose (fp);
10362
10363 return (-1);
10364 }
10365
10366 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10367
10368 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10369 {
10370 log_error ("ERROR: remove not supported in native hashfile-format mode");
10371
10372 fclose (fp);
10373
10374 return (-1);
10375 }
10376
10377 fclose (fp);
10378 }
10379 }
10380 else
10381 {
10382 hashlist_mode = HL_MODE_ARG;
10383
10384 hashes_avail = 1;
10385 }
10386
10387 if (hash_mode == 3000) hashes_avail *= 2;
10388
10389 data.hashlist_mode = hashlist_mode;
10390 data.hashlist_format = hashlist_format;
10391
10392 logfile_top_uint (hashlist_mode);
10393 logfile_top_uint (hashlist_format);
10394
10395 /**
10396 * load hashes, part II: allocate required memory, set pointers
10397 */
10398
10399 hash_t *hashes_buf = NULL;
10400 void *digests_buf = NULL;
10401 salt_t *salts_buf = NULL;
10402 void *esalts_buf = NULL;
10403
10404 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10405
10406 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10407
10408 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10409 {
10410 uint32_t hash_pos;
10411
10412 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10413 {
10414 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10415
10416 hashes_buf[hash_pos].hash_info = hash_info;
10417
10418 if (username && (remove || show || left))
10419 {
10420 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10421 }
10422
10423 if (benchmark)
10424 {
10425 hash_info->orighash = (char *) mymalloc (256);
10426 }
10427 }
10428 }
10429
10430 if (isSalted)
10431 {
10432 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10433
10434 if (esalt_size)
10435 {
10436 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10437 }
10438 }
10439 else
10440 {
10441 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10442 }
10443
10444 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10445 {
10446 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10447
10448 if (isSalted)
10449 {
10450 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10451
10452 if (esalt_size)
10453 {
10454 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10455 }
10456 }
10457 else
10458 {
10459 hashes_buf[hash_pos].salt = &salts_buf[0];
10460 }
10461 }
10462
10463 /**
10464 * load hashes, part III: parse hashes or generate them if benchmark
10465 */
10466
10467 uint hashes_cnt = 0;
10468
10469 if (benchmark == 0)
10470 {
10471 if (keyspace == 1)
10472 {
10473 // useless to read hash file for keyspace, cheat a little bit w/ optind
10474 }
10475 else if (hashes_avail == 0)
10476 {
10477 }
10478 else if (hashlist_mode == HL_MODE_ARG)
10479 {
10480 char *input_buf = myargv[optind];
10481
10482 uint input_len = strlen (input_buf);
10483
10484 logfile_top_var_string ("target", input_buf);
10485
10486 char *hash_buf = NULL;
10487 int hash_len = 0;
10488
10489 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10490
10491 if (hash_len)
10492 {
10493 if (opts_type & OPTS_TYPE_HASH_COPY)
10494 {
10495 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10496
10497 hash_info_tmp->orighash = mystrdup (hash_buf);
10498 }
10499
10500 if (isSalted)
10501 {
10502 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10503 }
10504
10505 int parser_status = PARSER_OK;
10506
10507 if (hash_mode == 2500)
10508 {
10509 if (hash_len == 0)
10510 {
10511 log_error ("ERROR: hccap file not specified");
10512
10513 return (-1);
10514 }
10515
10516 hashlist_mode = HL_MODE_FILE;
10517
10518 data.hashlist_mode = hashlist_mode;
10519
10520 FILE *fp = fopen (hash_buf, "rb");
10521
10522 if (fp == NULL)
10523 {
10524 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10525
10526 return (-1);
10527 }
10528
10529 if (hashes_avail < 1)
10530 {
10531 log_error ("ERROR: hccap file is empty or corrupt");
10532
10533 fclose (fp);
10534
10535 return (-1);
10536 }
10537
10538 uint hccap_size = sizeof (hccap_t);
10539
10540 char in[hccap_size];
10541
10542 while (!feof (fp))
10543 {
10544 int n = fread (&in, hccap_size, 1, fp);
10545
10546 if (n != 1)
10547 {
10548 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
10549
10550 break;
10551 }
10552
10553 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
10554
10555 if (parser_status != PARSER_OK)
10556 {
10557 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
10558
10559 continue;
10560 }
10561
10562 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
10563
10564 if ((show == 1) || (left == 1))
10565 {
10566 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
10567
10568 char *salt_ptr = (char *) tmp_salt->salt_buf;
10569
10570 int cur_pos = tmp_salt->salt_len;
10571 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10572
10573 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
10574
10575 unsigned char *pke_ptr = (unsigned char *) wpa->pke;
10576
10577 // do the appending task
10578
10579 snprintf (salt_ptr + cur_pos,
10580 rem_len,
10581 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
10582 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
10583 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
10584
10585
10586 // memset () the remaining part of the salt
10587
10588 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
10589 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10590
10591 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
10592
10593 tmp_salt->salt_len += 1 + 12 + 1 + 12;
10594 }
10595
10596 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);
10597 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);
10598
10599 hashes_cnt++;
10600 }
10601
10602 fclose (fp);
10603 }
10604 else if (hash_mode == 3000)
10605 {
10606 if (hash_len == 32)
10607 {
10608 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10609
10610 hash_t *lm_hash_left = NULL;
10611
10612 if (parser_status == PARSER_OK)
10613 {
10614 lm_hash_left = &hashes_buf[hashes_cnt];
10615
10616 hashes_cnt++;
10617 }
10618 else
10619 {
10620 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10621 }
10622
10623
10624 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10625
10626 hash_t *lm_hash_right = NULL;
10627
10628 if (parser_status == PARSER_OK)
10629 {
10630 lm_hash_right = &hashes_buf[hashes_cnt];
10631
10632 hashes_cnt++;
10633 }
10634 else
10635 {
10636 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10637 }
10638
10639 // show / left
10640
10641 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
10642 {
10643 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);
10644 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);
10645 }
10646 }
10647 else
10648 {
10649 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10650
10651 if (parser_status == PARSER_OK)
10652 {
10653 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10654 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10655 }
10656
10657 if (parser_status == PARSER_OK)
10658 {
10659 hashes_cnt++;
10660 }
10661 else
10662 {
10663 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10664 }
10665 }
10666 }
10667 else
10668 {
10669 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10670
10671 if (parser_status == PARSER_OK)
10672 {
10673 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10674 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10675 }
10676
10677 if (parser_status == PARSER_OK)
10678 {
10679 hashes_cnt++;
10680 }
10681 else
10682 {
10683 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10684 }
10685 }
10686 }
10687 }
10688 else if (hashlist_mode == HL_MODE_FILE)
10689 {
10690 char *hashfile = data.hashfile;
10691
10692 FILE *fp;
10693
10694 if ((fp = fopen (hashfile, "rb")) == NULL)
10695 {
10696 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10697
10698 return (-1);
10699 }
10700
10701 uint line_num = 0;
10702
10703 while (!feof (fp))
10704 {
10705 line_num++;
10706
10707 char line_buf[BUFSIZ];
10708
10709 int line_len = fgetl (fp, line_buf);
10710
10711 if (line_len == 0) continue;
10712
10713 char *hash_buf = NULL;
10714 int hash_len = 0;
10715
10716 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
10717
10718 if (username)
10719 {
10720 char *user_buf = NULL;
10721 int user_len = 0;
10722
10723 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
10724
10725 if (remove || show)
10726 {
10727 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
10728
10729 *user = (user_t *) malloc (sizeof (user_t));
10730
10731 user_t *user_ptr = *user;
10732
10733 if (user_buf != NULL)
10734 {
10735 user_ptr->user_name = mystrdup (user_buf);
10736 }
10737 else
10738 {
10739 user_ptr->user_name = mystrdup ("");
10740 }
10741
10742 user_ptr->user_len = user_len;
10743 }
10744 }
10745
10746 if (opts_type & OPTS_TYPE_HASH_COPY)
10747 {
10748 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10749
10750 hash_info_tmp->orighash = mystrdup (hash_buf);
10751 }
10752
10753 if (isSalted)
10754 {
10755 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
10756 }
10757
10758 if (hash_mode == 3000)
10759 {
10760 if (hash_len == 32)
10761 {
10762 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10763
10764 if (parser_status < PARSER_GLOBAL_ZERO)
10765 {
10766 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10767
10768 continue;
10769 }
10770
10771 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
10772
10773 hashes_cnt++;
10774
10775 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10776
10777 if (parser_status < PARSER_GLOBAL_ZERO)
10778 {
10779 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10780
10781 continue;
10782 }
10783
10784 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
10785
10786 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);
10787
10788 hashes_cnt++;
10789
10790 // show / left
10791
10792 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);
10793 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);
10794 }
10795 else
10796 {
10797 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10798
10799 if (parser_status < PARSER_GLOBAL_ZERO)
10800 {
10801 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10802
10803 continue;
10804 }
10805
10806 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);
10807
10808 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10809 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10810
10811 hashes_cnt++;
10812 }
10813 }
10814 else
10815 {
10816 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10817
10818 if (parser_status < PARSER_GLOBAL_ZERO)
10819 {
10820 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10821
10822 continue;
10823 }
10824
10825 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);
10826
10827 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10828 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10829
10830 hashes_cnt++;
10831 }
10832 }
10833
10834 fclose (fp);
10835
10836 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
10837
10838 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
10839 }
10840 }
10841 else
10842 {
10843 if (isSalted)
10844 {
10845 hashes_buf[0].salt->salt_len = 8;
10846
10847 // special salt handling
10848
10849 switch (hash_mode)
10850 {
10851 case 1500: hashes_buf[0].salt->salt_len = 2;
10852 break;
10853 case 1731: hashes_buf[0].salt->salt_len = 4;
10854 break;
10855 case 2410: hashes_buf[0].salt->salt_len = 4;
10856 break;
10857 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
10858 break;
10859 case 3100: hashes_buf[0].salt->salt_len = 1;
10860 break;
10861 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
10862 break;
10863 case 5800: hashes_buf[0].salt->salt_len = 16;
10864 break;
10865 case 6800: hashes_buf[0].salt->salt_len = 32;
10866 break;
10867 case 8400: hashes_buf[0].salt->salt_len = 40;
10868 break;
10869 case 8800: hashes_buf[0].salt->salt_len = 16;
10870 break;
10871 case 8900: hashes_buf[0].salt->salt_len = 16;
10872 hashes_buf[0].salt->scrypt_N = 1024;
10873 hashes_buf[0].salt->scrypt_r = 1;
10874 hashes_buf[0].salt->scrypt_p = 1;
10875 break;
10876 case 9100: hashes_buf[0].salt->salt_len = 16;
10877 break;
10878 case 9300: hashes_buf[0].salt->salt_len = 14;
10879 hashes_buf[0].salt->scrypt_N = 16384;
10880 hashes_buf[0].salt->scrypt_r = 1;
10881 hashes_buf[0].salt->scrypt_p = 1;
10882 break;
10883 case 9400: hashes_buf[0].salt->salt_len = 16;
10884 break;
10885 case 9500: hashes_buf[0].salt->salt_len = 16;
10886 break;
10887 case 9600: hashes_buf[0].salt->salt_len = 16;
10888 break;
10889 case 9700: hashes_buf[0].salt->salt_len = 16;
10890 break;
10891 case 9710: hashes_buf[0].salt->salt_len = 16;
10892 break;
10893 case 9720: hashes_buf[0].salt->salt_len = 16;
10894 break;
10895 case 9800: hashes_buf[0].salt->salt_len = 16;
10896 break;
10897 case 9810: hashes_buf[0].salt->salt_len = 16;
10898 break;
10899 case 9820: hashes_buf[0].salt->salt_len = 16;
10900 break;
10901 case 10300: hashes_buf[0].salt->salt_len = 12;
10902 break;
10903 case 11500: hashes_buf[0].salt->salt_len = 4;
10904 break;
10905 case 11600: hashes_buf[0].salt->salt_len = 4;
10906 break;
10907 case 12400: hashes_buf[0].salt->salt_len = 4;
10908 break;
10909 case 12500: hashes_buf[0].salt->salt_len = 8;
10910 break;
10911 case 12600: hashes_buf[0].salt->salt_len = 64;
10912 break;
10913 }
10914
10915 // special esalt handling
10916
10917 switch (hash_mode)
10918 {
10919 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
10920 break;
10921 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
10922 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
10923 break;
10924 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
10925 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
10926 break;
10927 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
10928 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
10929 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
10930 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
10931 break;
10932 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
10933 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
10934 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
10935 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
10936 break;
10937 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
10938 break;
10939 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10940 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
10941 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
10942 break;
10943 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10944 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
10945 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
10946 break;
10947 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10948 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
10949 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
10950 break;
10951 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10952 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
10953 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
10954 break;
10955 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10956 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
10957 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
10958 break;
10959 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10960 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
10961 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
10962 break;
10963 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
10964 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
10965 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
10966 break;
10967 }
10968 }
10969
10970 // set hashfile
10971
10972 switch (hash_mode)
10973 {
10974 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
10975 break;
10976 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
10977 break;
10978 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
10979 break;
10980 case 6211:
10981 case 6212:
10982 case 6213:
10983 case 6221:
10984 case 6222:
10985 case 6223:
10986 case 6231:
10987 case 6232:
10988 case 6233:
10989 case 6241:
10990 case 6242:
10991 case 6243: data.hashfile = mystrdup ("hashcat.tc");
10992 break;
10993 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
10994 break;
10995 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
10996 break;
10997 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
10998 break;
10999 }
11000
11001 // set default iterations
11002
11003 switch (hash_mode)
11004 {
11005 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11006 break;
11007 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11008 break;
11009 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11010 break;
11011 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11012 break;
11013 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11014 break;
11015 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11016 break;
11017 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11018 break;
11019 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11020 break;
11021 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11022 break;
11023 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11024 break;
11025 case 6211:
11026 case 6212:
11027 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11028 break;
11029 case 6221:
11030 case 6222:
11031 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11032 break;
11033 case 6231:
11034 case 6232:
11035 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11036 break;
11037 case 6241:
11038 case 6242:
11039 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11040 break;
11041 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11042 break;
11043 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11044 break;
11045 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11046 break;
11047 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11048 break;
11049 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11050 break;
11051 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11052 break;
11053 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11054 break;
11055 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11056 break;
11057 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11058 break;
11059 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11060 break;
11061 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11062 break;
11063 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11064 break;
11065 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11066 break;
11067 case 8900: hashes_buf[0].salt->salt_iter = 1;
11068 break;
11069 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11070 break;
11071 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11072 break;
11073 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11074 break;
11075 case 9300: hashes_buf[0].salt->salt_iter = 1;
11076 break;
11077 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11078 break;
11079 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11080 break;
11081 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11082 break;
11083 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11084 break;
11085 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11086 break;
11087 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11088 break;
11089 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11090 break;
11091 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11092 break;
11093 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11094 break;
11095 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11096 break;
11097 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11098 break;
11099 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11100 break;
11101 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11102 break;
11103 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11104 break;
11105 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11106 break;
11107 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11108 break;
11109 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11110 break;
11111 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11112 break;
11113 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11114 break;
11115 }
11116
11117 // set special tuning for benchmark-mode 1
11118
11119 if (benchmark_mode == 1)
11120 {
11121 gpu_loops *= 8;
11122 gpu_accel *= 4;
11123
11124 switch (hash_mode)
11125 {
11126 case 400: gpu_loops = ROUNDS_PHPASS;
11127 gpu_accel = 32;
11128 break;
11129 case 500: gpu_loops = ROUNDS_MD5CRYPT;
11130 gpu_accel = 32;
11131 break;
11132 case 501: gpu_loops = ROUNDS_MD5CRYPT;
11133 gpu_accel = 32;
11134 break;
11135 case 1600: gpu_loops = ROUNDS_MD5CRYPT;
11136 gpu_accel = 32;
11137 break;
11138 case 1800: gpu_loops = ROUNDS_SHA512CRYPT;
11139 gpu_accel = 16;
11140 break;
11141 case 2100: gpu_loops = ROUNDS_DCC2;
11142 gpu_accel = 16;
11143 break;
11144 case 2500: gpu_loops = ROUNDS_WPA2;
11145 gpu_accel = 32;
11146 break;
11147 case 3200: gpu_loops = ROUNDS_BCRYPT;
11148 gpu_accel = 8;
11149 break;
11150 case 5200: gpu_loops = ROUNDS_PSAFE3;
11151 gpu_accel = 16;
11152 break;
11153 case 5800: gpu_loops = ROUNDS_ANDROIDPIN;
11154 gpu_accel = 16;
11155 break;
11156 case 6211: gpu_loops = ROUNDS_TRUECRYPT_2K;
11157 gpu_accel = 64;
11158 break;
11159 case 6212: gpu_loops = ROUNDS_TRUECRYPT_2K;
11160 gpu_accel = 32;
11161 break;
11162 case 6213: gpu_loops = ROUNDS_TRUECRYPT_2K;
11163 gpu_accel = 32;
11164 break;
11165 case 6221: gpu_loops = ROUNDS_TRUECRYPT_1K;
11166 gpu_accel = 8;
11167 break;
11168 case 6222: gpu_loops = ROUNDS_TRUECRYPT_1K;
11169 gpu_accel = 8;
11170 break;
11171 case 6223: gpu_loops = ROUNDS_TRUECRYPT_1K;
11172 gpu_accel = 8;
11173 break;
11174 case 6231: gpu_loops = ROUNDS_TRUECRYPT_1K;
11175 gpu_accel = 8;
11176 break;
11177 case 6232: gpu_loops = ROUNDS_TRUECRYPT_1K;
11178 gpu_accel = 8;
11179 break;
11180 case 6233: gpu_loops = ROUNDS_TRUECRYPT_1K;
11181 gpu_accel = 8;
11182 break;
11183 case 6241: gpu_loops = ROUNDS_TRUECRYPT_1K;
11184 gpu_accel = 128;
11185 break;
11186 case 6242: gpu_loops = ROUNDS_TRUECRYPT_1K;
11187 gpu_accel = 64;
11188 break;
11189 case 6243: gpu_loops = ROUNDS_TRUECRYPT_1K;
11190 gpu_accel = 64;
11191 break;
11192 case 6300: gpu_loops = ROUNDS_MD5CRYPT;
11193 gpu_accel = 32;
11194 break;
11195 case 6700: gpu_loops = ROUNDS_SHA1AIX;
11196 gpu_accel = 128;
11197 break;
11198 case 6400: gpu_loops = ROUNDS_SHA256AIX;
11199 gpu_accel = 128;
11200 break;
11201 case 6500: gpu_loops = ROUNDS_SHA512AIX;
11202 gpu_accel = 32;
11203 break;
11204 case 6600: gpu_loops = ROUNDS_AGILEKEY;
11205 gpu_accel = 64;
11206 break;
11207 case 6800: gpu_loops = ROUNDS_LASTPASS;
11208 gpu_accel = 64;
11209 break;
11210 case 7100: gpu_loops = ROUNDS_SHA512OSX;
11211 gpu_accel = 8;
11212 break;
11213 case 7200: gpu_loops = ROUNDS_GRUB;
11214 gpu_accel = 16;
11215 break;
11216 case 7400: gpu_loops = ROUNDS_SHA256CRYPT;
11217 gpu_accel = 8;
11218 break;
11219 case 7900: gpu_loops = ROUNDS_DRUPAL7;
11220 gpu_accel = 8;
11221 break;
11222 case 8200: gpu_loops = ROUNDS_CLOUDKEY;
11223 gpu_accel = 8;
11224 break;
11225 case 8800: gpu_loops = ROUNDS_ANDROIDFDE;
11226 gpu_accel = 32;
11227 break;
11228 case 8900: gpu_loops = 1;
11229 gpu_accel = 64;
11230 break;
11231 case 9000: gpu_loops = ROUNDS_PSAFE2;
11232 gpu_accel = 16;
11233 break;
11234 case 9100: gpu_loops = ROUNDS_LOTUS8;
11235 gpu_accel = 64;
11236 break;
11237 case 9200: gpu_loops = ROUNDS_CISCO8;
11238 gpu_accel = 8;
11239 break;
11240 case 9300: gpu_loops = 1;
11241 gpu_accel = 4;
11242 break;
11243 case 9400: gpu_loops = ROUNDS_OFFICE2007;
11244 gpu_accel = 32;
11245 break;
11246 case 9500: gpu_loops = ROUNDS_OFFICE2010;
11247 gpu_accel = 32;
11248 break;
11249 case 9600: gpu_loops = ROUNDS_OFFICE2013;
11250 gpu_accel = 8;
11251 break;
11252 case 10000: gpu_loops = ROUNDS_DJANGOPBKDF2;
11253 gpu_accel = 8;
11254 break;
11255 case 10300: gpu_loops = ROUNDS_SAPH_SHA1;
11256 gpu_accel = 16;
11257 break;
11258 case 10500: gpu_loops = ROUNDS_PDF14;
11259 gpu_accel = 256;
11260 break;
11261 case 10700: gpu_loops = ROUNDS_PDF17L8;
11262 gpu_accel = 8;
11263 break;
11264 case 10900: gpu_loops = ROUNDS_PBKDF2_SHA256;
11265 gpu_accel = 8;
11266 break;
11267 case 11300: gpu_loops = ROUNDS_BITCOIN_WALLET;
11268 gpu_accel = 8;
11269 break;
11270 case 11600: gpu_loops = ROUNDS_SEVEN_ZIP;
11271 gpu_accel = 8;
11272 break;
11273 case 11900: gpu_loops = ROUNDS_PBKDF2_MD5;
11274 gpu_accel = 8;
11275 break;
11276 case 12000: gpu_loops = ROUNDS_PBKDF2_SHA1;
11277 gpu_accel = 8;
11278 break;
11279 case 12100: gpu_loops = ROUNDS_PBKDF2_SHA512;
11280 gpu_accel = 8;
11281 break;
11282 case 12200: gpu_loops = ROUNDS_ECRYPTFS;
11283 gpu_accel = 8;
11284 break;
11285 case 12300: gpu_loops = ROUNDS_ORACLET;
11286 gpu_accel = 8;
11287 break;
11288 case 12500: gpu_loops = ROUNDS_RAR3;
11289 gpu_accel = 32;
11290 break;
11291 case 12700: gpu_loops = ROUNDS_MYWALLET;
11292 gpu_accel = 512;
11293 break;
11294 case 12800: gpu_loops = ROUNDS_MS_DRSR;
11295 gpu_accel = 512;
11296 break;
11297 }
11298
11299 // some algorithm collide too fast, make that impossible
11300
11301 switch (hash_mode)
11302 {
11303 case 11500: ((uint *) digests_buf)[1] = 1;
11304 break;
11305 }
11306
11307 if (gpu_loops > 1024) gpu_loops = 1024;
11308 if (gpu_accel > 256) gpu_accel = 256; // causes memory problems otherwise
11309 }
11310
11311 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
11312 {
11313 gpu_loops = 1024;
11314 }
11315
11316 if (hash_mode == 12500)
11317 {
11318 gpu_loops = ROUNDS_RAR3 / 16;
11319 }
11320
11321 data.gpu_accel = gpu_accel;
11322 data.gpu_loops = gpu_loops;
11323
11324 hashes_cnt = 1;
11325 }
11326
11327 if (show == 1 || left == 1)
11328 {
11329 for (uint i = 0; i < pot_cnt; i++)
11330 {
11331 pot_t *pot_ptr = &pot[i];
11332
11333 hash_t *hashes_buf = &pot_ptr->hash;
11334
11335 local_free (hashes_buf->digest);
11336
11337 if (isSalted)
11338 {
11339 local_free (hashes_buf->salt);
11340 }
11341 }
11342
11343 local_free (pot);
11344
11345 if (data.quiet == 0) log_info_nn ("");
11346
11347 return (0);
11348 }
11349
11350 if (keyspace == 0)
11351 {
11352 if (hashes_cnt == 0)
11353 {
11354 log_error ("ERROR: No hashes loaded");
11355
11356 return (-1);
11357 }
11358 }
11359
11360 /**
11361 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11362 */
11363
11364 if (data.outfile != NULL)
11365 {
11366 if (data.hashfile != NULL)
11367 {
11368 #ifdef _POSIX
11369 struct stat tmpstat_outfile;
11370 struct stat tmpstat_hashfile;
11371 #endif
11372
11373 #ifdef _WIN
11374 struct stat64 tmpstat_outfile;
11375 struct stat64 tmpstat_hashfile;
11376 #endif
11377
11378 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11379
11380 if (tmp_outfile_fp)
11381 {
11382 #ifdef _POSIX
11383 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11384 #endif
11385
11386 #ifdef _WIN
11387 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11388 #endif
11389
11390 fclose (tmp_outfile_fp);
11391 }
11392
11393 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11394
11395 if (tmp_hashfile_fp)
11396 {
11397 #ifdef _POSIX
11398 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11399 #endif
11400
11401 #ifdef _WIN
11402 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11403 #endif
11404
11405 fclose (tmp_hashfile_fp);
11406 }
11407
11408 if (tmp_outfile_fp && tmp_outfile_fp)
11409 {
11410 tmpstat_outfile.st_mode = 0;
11411 tmpstat_outfile.st_nlink = 0;
11412 tmpstat_outfile.st_uid = 0;
11413 tmpstat_outfile.st_gid = 0;
11414 tmpstat_outfile.st_rdev = 0;
11415 tmpstat_outfile.st_atime = 0;
11416
11417 tmpstat_hashfile.st_mode = 0;
11418 tmpstat_hashfile.st_nlink = 0;
11419 tmpstat_hashfile.st_uid = 0;
11420 tmpstat_hashfile.st_gid = 0;
11421 tmpstat_hashfile.st_rdev = 0;
11422 tmpstat_hashfile.st_atime = 0;
11423
11424 #ifdef _POSIX
11425 tmpstat_outfile.st_blksize = 0;
11426 tmpstat_outfile.st_blocks = 0;
11427
11428 tmpstat_hashfile.st_blksize = 0;
11429 tmpstat_hashfile.st_blocks = 0;
11430 #endif
11431
11432 #ifdef _POSIX
11433 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11434 {
11435 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11436
11437 return (-1);
11438 }
11439 #endif
11440
11441 #ifdef _WIN
11442 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11443 {
11444 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11445
11446 return (-1);
11447 }
11448 #endif
11449 }
11450 }
11451 }
11452
11453 /**
11454 * Remove duplicates
11455 */
11456
11457 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11458
11459 if (isSalted)
11460 {
11461 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11462 }
11463 else
11464 {
11465 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11466 }
11467
11468 uint hashes_cnt_orig = hashes_cnt;
11469
11470 hashes_cnt = 1;
11471
11472 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11473 {
11474 if (isSalted)
11475 {
11476 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11477 {
11478 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11479 }
11480 }
11481 else
11482 {
11483 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11484 }
11485
11486 if (hashes_pos > hashes_cnt)
11487 {
11488 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11489 }
11490
11491 hashes_cnt++;
11492 }
11493
11494 /**
11495 * Potfile removes
11496 */
11497
11498 uint potfile_remove_cracks = 0;
11499
11500 if (potfile_disable == 0)
11501 {
11502 hash_t hash_buf;
11503
11504 hash_buf.digest = mymalloc (dgst_size);
11505 hash_buf.salt = NULL;
11506 hash_buf.esalt = NULL;
11507 hash_buf.hash_info = NULL;
11508 hash_buf.cracked = 0;
11509
11510 if (isSalted)
11511 {
11512 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11513 }
11514
11515 if (esalt_size)
11516 {
11517 hash_buf.esalt = mymalloc (esalt_size);
11518 }
11519
11520 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11521
11522 // no solution for these special hash types (for instane because they use hashfile in output etc)
11523 if ((hash_mode != 5200) &&
11524 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11525 (hash_mode != 9000))
11526 {
11527 FILE *fp = fopen (potfile, "rb");
11528
11529 if (fp != NULL)
11530 {
11531 while (!feof (fp))
11532 {
11533 char line_buf[BUFSIZ];
11534
11535 memset (line_buf, 0, BUFSIZ);
11536
11537 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11538
11539 if (ptr == NULL) break;
11540
11541 int line_len = strlen (line_buf);
11542
11543 if (line_len == 0) continue;
11544
11545 int iter = MAX_CUT_TRIES;
11546
11547 for (int i = line_len - 1; i && iter; i--, line_len--)
11548 {
11549 if (line_buf[i] != ':') continue;
11550
11551 if (isSalted)
11552 {
11553 memset (hash_buf.salt, 0, sizeof (salt_t));
11554 }
11555
11556 hash_t *found = NULL;
11557
11558 if (hash_mode == 6800)
11559 {
11560 if (i < 48) // 48 = 12 * uint in salt_buf[]
11561 {
11562 // manipulate salt_buf
11563 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11564
11565 hash_buf.salt->salt_len = i;
11566
11567 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11568 }
11569 }
11570 else if (hash_mode == 2500)
11571 {
11572 if (i < 48) // 48 = 12 * uint in salt_buf[]
11573 {
11574 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11575 // manipulate salt_buf
11576
11577 // to be safe work with a copy (because of line_len loop, i etc)
11578
11579 char line_buf_cpy[BUFSIZ];
11580 memset (line_buf_cpy, 0, BUFSIZ);
11581
11582 memset (line_buf_cpy, 0, sizeof (line_buf_cpy));
11583
11584 memcpy (line_buf_cpy, line_buf, i);
11585
11586 char *mac2_pos = strrchr (line_buf_cpy, ':');
11587
11588 if (mac2_pos == NULL) continue;
11589
11590 mac2_pos[0] = 0;
11591 mac2_pos++;
11592
11593 if (strlen (mac2_pos) != 12) continue;
11594
11595 char *mac1_pos = strrchr (line_buf_cpy, ':');
11596
11597 if (mac1_pos == NULL) continue;
11598
11599 mac1_pos[0] = 0;
11600 mac1_pos++;
11601
11602 if (strlen (mac1_pos) != 12) continue;
11603
11604 uint essid_length = mac1_pos - line_buf_cpy - 1;
11605
11606 // here we need the ESSID
11607 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11608
11609 hash_buf.salt->salt_len = essid_length;
11610
11611 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11612
11613 if (found)
11614 {
11615 wpa_t *wpa = (wpa_t *) found->esalt;
11616
11617 uint pke[25];
11618
11619 char *pke_ptr = (char *) pke;
11620
11621 for (uint i = 0; i < 25; i++)
11622 {
11623 pke[i] = byte_swap_32 (wpa->pke[i]);
11624 }
11625
11626 unsigned char mac1[6];
11627 unsigned char mac2[6];
11628
11629 memcpy (mac1, pke_ptr + 23, 6);
11630 memcpy (mac2, pke_ptr + 29, 6);
11631
11632 // compare hex string(s) vs binary MAC address(es)
11633
11634 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11635 {
11636 if (mac1[i] != (unsigned char) hex_to_char (&mac1_pos[j]))
11637 {
11638 found = NULL;
11639 break;
11640 }
11641 }
11642
11643 // early skip ;)
11644 if (!found) continue;
11645
11646 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11647 {
11648 if (mac2[i] != (unsigned char) hex_to_char (&mac2_pos[j]))
11649 {
11650 found = NULL;
11651 break;
11652 }
11653 }
11654 }
11655 }
11656 }
11657 else
11658 {
11659 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11660
11661 if (parser_status == PARSER_OK)
11662 {
11663 if (isSalted)
11664 {
11665 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11666 }
11667 else
11668 {
11669 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11670 }
11671 }
11672 }
11673
11674 if (found == NULL) continue;
11675
11676 if (!found->cracked) potfile_remove_cracks++;
11677
11678 found->cracked = 1;
11679
11680 if (found) break;
11681
11682 iter--;
11683 }
11684 }
11685
11686 fclose (fp);
11687 }
11688 }
11689
11690 if (esalt_size)
11691 {
11692 local_free (hash_buf.esalt);
11693 }
11694
11695 if (isSalted)
11696 {
11697 local_free (hash_buf.salt);
11698 }
11699
11700 local_free (hash_buf.digest);
11701 }
11702
11703 /**
11704 * Now generate all the buffers required for later
11705 */
11706
11707 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11708
11709 salt_t *salts_buf_new = NULL;
11710 void *esalts_buf_new = NULL;
11711
11712 if (isSalted)
11713 {
11714 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11715
11716 if (esalt_size)
11717 {
11718 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
11719 }
11720 }
11721 else
11722 {
11723 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
11724 }
11725
11726 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
11727
11728 uint digests_cnt = hashes_cnt;
11729 uint digests_done = 0;
11730
11731 uint size_digests = digests_cnt * dgst_size;
11732 uint size_shown = digests_cnt * sizeof (uint);
11733
11734 uint *digests_shown = (uint *) mymalloc (size_shown);
11735 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
11736
11737 uint salts_cnt = 0;
11738 uint salts_done = 0;
11739
11740 hashinfo_t **hash_info = NULL;
11741
11742 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11743 {
11744 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
11745
11746 if (username && (remove || show))
11747 {
11748 uint user_pos;
11749
11750 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
11751 {
11752 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
11753
11754 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
11755 }
11756 }
11757 }
11758
11759 uint *salts_shown = (uint *) mymalloc (size_shown);
11760
11761 salt_t *salt_buf;
11762
11763 {
11764 // copied from inner loop
11765
11766 salt_buf = &salts_buf_new[salts_cnt];
11767
11768 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
11769
11770 if (esalt_size)
11771 {
11772 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
11773 }
11774
11775 salt_buf->digests_cnt = 0;
11776 salt_buf->digests_done = 0;
11777 salt_buf->digests_offset = 0;
11778
11779 salts_cnt++;
11780 }
11781
11782 if (hashes_buf[0].cracked == 1)
11783 {
11784 digests_shown[0] = 1;
11785
11786 digests_done++;
11787
11788 salt_buf->digests_done++;
11789 }
11790
11791 salt_buf->digests_cnt++;
11792
11793 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
11794
11795 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11796 {
11797 hash_info[0] = hashes_buf[0].hash_info;
11798 }
11799
11800 // copy from inner loop
11801
11802 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
11803 {
11804 if (isSalted)
11805 {
11806 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
11807 {
11808 salt_buf = &salts_buf_new[salts_cnt];
11809
11810 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
11811
11812 if (esalt_size)
11813 {
11814 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
11815 }
11816
11817 salt_buf->digests_cnt = 0;
11818 salt_buf->digests_done = 0;
11819 salt_buf->digests_offset = hashes_pos;
11820
11821 salts_cnt++;
11822 }
11823 }
11824
11825 if (hashes_buf[hashes_pos].cracked == 1)
11826 {
11827 digests_shown[hashes_pos] = 1;
11828
11829 digests_done++;
11830
11831 salt_buf->digests_done++;
11832 }
11833
11834 salt_buf->digests_cnt++;
11835
11836 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
11837
11838 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11839 {
11840 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
11841 }
11842 }
11843
11844 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
11845 {
11846 salt_t *salt_buf = &salts_buf_new[salt_pos];
11847
11848 if (salt_buf->digests_done == salt_buf->digests_cnt)
11849 {
11850 salts_shown[salt_pos] = 1;
11851
11852 salts_done++;
11853 }
11854
11855 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
11856 }
11857
11858 local_free (digests_buf);
11859 local_free (salts_buf);
11860 local_free (esalts_buf);
11861
11862 digests_buf = digests_buf_new;
11863 salts_buf = salts_buf_new;
11864 esalts_buf = esalts_buf_new;
11865
11866 local_free (hashes_buf);
11867
11868 /**
11869 * special modification not set from parser
11870 */
11871
11872 switch (hash_mode)
11873 {
11874 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
11875 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
11876 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
11877 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
11878 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
11879 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
11880 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
11881 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
11882 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
11883 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
11884 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
11885 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
11886 }
11887
11888 if (truecrypt_keyfiles)
11889 {
11890 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
11891
11892 char *keyfiles = strdup (truecrypt_keyfiles);
11893
11894 char *keyfile = strtok (keyfiles, ",");
11895
11896 do
11897 {
11898 truecrypt_crc32 (keyfile, (unsigned char *) keyfile_buf);
11899
11900 } while ((keyfile = strtok (NULL, ",")) != NULL);
11901
11902 free (keyfiles);
11903 }
11904
11905 data.digests_cnt = digests_cnt;
11906 data.digests_done = digests_done;
11907 data.digests_buf = digests_buf;
11908 data.digests_shown = digests_shown;
11909 data.digests_shown_tmp = digests_shown_tmp;
11910
11911 data.salts_cnt = salts_cnt;
11912 data.salts_done = salts_done;
11913 data.salts_buf = salts_buf;
11914 data.salts_shown = salts_shown;
11915
11916 data.esalts_buf = esalts_buf;
11917 data.hash_info = hash_info;
11918
11919 /**
11920 * Automatic Optimizers
11921 */
11922
11923 if (salts_cnt == 1)
11924 opti_type |= OPTI_TYPE_SINGLE_SALT;
11925
11926 if (digests_cnt == 1)
11927 opti_type |= OPTI_TYPE_SINGLE_HASH;
11928
11929 if (attack_exec == ATTACK_EXEC_ON_GPU)
11930 opti_type |= OPTI_TYPE_NOT_ITERATED;
11931
11932 if (attack_mode == ATTACK_MODE_BF)
11933 opti_type |= OPTI_TYPE_BRUTE_FORCE;
11934
11935 data.opti_type = opti_type;
11936
11937 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
11938 {
11939 if (opti_type & OPTI_TYPE_SINGLE_HASH)
11940 {
11941 if (opti_type & OPTI_TYPE_APPENDED_SALT)
11942 {
11943 if (opts_type & OPTS_TYPE_ST_ADD80)
11944 {
11945 opts_type &= ~OPTS_TYPE_ST_ADD80;
11946 opts_type |= OPTS_TYPE_PT_ADD80;
11947 }
11948
11949 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
11950 {
11951 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
11952 opts_type |= OPTS_TYPE_PT_ADDBITS14;
11953 }
11954
11955 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
11956 {
11957 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
11958 opts_type |= OPTS_TYPE_PT_ADDBITS15;
11959 }
11960 }
11961 }
11962 }
11963
11964 /**
11965 * Some algorithm, like descrypt, can benefit from JIT compilation
11966 */
11967
11968 uint force_jit_compilation = 0;
11969
11970 if (hash_mode == 8900)
11971 {
11972 force_jit_compilation = 8900;
11973 }
11974 else if (hash_mode == 9300)
11975 {
11976 force_jit_compilation = 8900;
11977 }
11978 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
11979 {
11980 force_jit_compilation = 1500;
11981 }
11982
11983 /**
11984 * generate bitmap tables
11985 */
11986
11987 const uint bitmap_shift1 = 5;
11988 const uint bitmap_shift2 = 13;
11989
11990 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
11991
11992 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
11993 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
11994 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
11995 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
11996 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
11997 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
11998 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
11999 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12000
12001 uint bitmap_bits;
12002 uint bitmap_nums;
12003 uint bitmap_mask;
12004 uint bitmap_size;
12005
12006 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12007 {
12008 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12009
12010 bitmap_nums = 1 << bitmap_bits;
12011
12012 bitmap_mask = bitmap_nums - 1;
12013
12014 bitmap_size = bitmap_nums * sizeof (uint);
12015
12016 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12017
12018 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;
12019 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;
12020
12021 break;
12022 }
12023
12024 bitmap_nums = 1 << bitmap_bits;
12025
12026 bitmap_mask = bitmap_nums - 1;
12027
12028 bitmap_size = bitmap_nums * sizeof (uint);
12029
12030 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);
12031 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);
12032
12033 /**
12034 * prepare quick rule
12035 */
12036
12037 data.rule_buf_l = rule_buf_l;
12038 data.rule_buf_r = rule_buf_r;
12039
12040 int rule_len_l = (int) strlen (rule_buf_l);
12041 int rule_len_r = (int) strlen (rule_buf_r);
12042
12043 data.rule_len_l = rule_len_l;
12044 data.rule_len_r = rule_len_r;
12045
12046 /**
12047 * load rules
12048 */
12049
12050 uint *all_gpu_rules_cnt = NULL;
12051
12052 gpu_rule_t **all_gpu_rules_buf = NULL;
12053
12054 if (rp_files_cnt)
12055 {
12056 all_gpu_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12057
12058 all_gpu_rules_buf = (gpu_rule_t **) mycalloc (rp_files_cnt, sizeof (gpu_rule_t *));
12059 }
12060
12061 char rule_buf[BUFSIZ];
12062
12063 int rule_len = 0;
12064
12065 for (uint i = 0; i < rp_files_cnt; i++)
12066 {
12067 uint gpu_rules_avail = 0;
12068
12069 uint gpu_rules_cnt = 0;
12070
12071 gpu_rule_t *gpu_rules_buf = NULL;
12072
12073 char *rp_file = rp_files[i];
12074
12075 char in[BLOCK_SIZE];
12076 char out[BLOCK_SIZE];
12077
12078 FILE *fp = NULL;
12079
12080 uint rule_line = 0;
12081
12082 if ((fp = fopen (rp_file, "rb")) == NULL)
12083 {
12084 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12085
12086 return (-1);
12087 }
12088
12089 while (!feof (fp))
12090 {
12091 memset (rule_buf, 0, BUFSIZ);
12092
12093 rule_len = fgetl (fp, rule_buf);
12094
12095 rule_line++;
12096
12097 if (rule_len == 0) continue;
12098
12099 if (rule_buf[0] == '#') continue;
12100
12101 if (gpu_rules_avail == gpu_rules_cnt)
12102 {
12103 gpu_rules_buf = (gpu_rule_t *) myrealloc (gpu_rules_buf, gpu_rules_avail * sizeof (gpu_rule_t), INCR_RULES * sizeof (gpu_rule_t));
12104
12105 gpu_rules_avail += INCR_RULES;
12106 }
12107
12108 memset (in, 0, BLOCK_SIZE);
12109 memset (out, 0, BLOCK_SIZE);
12110
12111 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12112
12113 if (result == -1)
12114 {
12115 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12116
12117 continue;
12118 }
12119
12120 if (cpu_rule_to_gpu_rule (rule_buf, rule_len, &gpu_rules_buf[gpu_rules_cnt]) == -1)
12121 {
12122 log_info ("WARNING: Cannot convert rule for use on GPU in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12123
12124 memset (&gpu_rules_buf[gpu_rules_cnt], 0, sizeof (gpu_rule_t)); // needs to be cleared otherwise we could have some remaining data
12125
12126 continue;
12127 }
12128
12129 /* its so slow
12130 if (rulefind (&gpu_rules_buf[gpu_rules_cnt], gpu_rules_buf, gpu_rules_cnt, sizeof (gpu_rule_t), sort_by_gpu_rule))
12131 {
12132 log_info ("Duplicate rule for use on GPU in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12133
12134 continue;
12135 }
12136 */
12137
12138 gpu_rules_cnt++;
12139 }
12140
12141 fclose (fp);
12142
12143 all_gpu_rules_cnt[i] = gpu_rules_cnt;
12144
12145 all_gpu_rules_buf[i] = gpu_rules_buf;
12146 }
12147
12148 /**
12149 * merge rules or automatic rule generator
12150 */
12151
12152 uint gpu_rules_cnt = 0;
12153
12154 gpu_rule_t *gpu_rules_buf = NULL;
12155
12156 if (attack_mode == ATTACK_MODE_STRAIGHT)
12157 {
12158 if (rp_files_cnt)
12159 {
12160 gpu_rules_cnt = 1;
12161
12162 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12163
12164 repeats[0] = gpu_rules_cnt;
12165
12166 for (uint i = 0; i < rp_files_cnt; i++)
12167 {
12168 gpu_rules_cnt *= all_gpu_rules_cnt[i];
12169
12170 repeats[i + 1] = gpu_rules_cnt;
12171 }
12172
12173 gpu_rules_buf = (gpu_rule_t *) mycalloc (gpu_rules_cnt, sizeof (gpu_rule_t));
12174
12175 memset (gpu_rules_buf, 0, gpu_rules_cnt * sizeof (gpu_rule_t));
12176
12177 for (uint i = 0; i < gpu_rules_cnt; i++)
12178 {
12179 uint out_pos = 0;
12180
12181 gpu_rule_t *out = &gpu_rules_buf[i];
12182
12183 for (uint j = 0; j < rp_files_cnt; j++)
12184 {
12185 uint in_off = (i / repeats[j]) % all_gpu_rules_cnt[j];
12186 uint in_pos;
12187
12188 gpu_rule_t *in = &all_gpu_rules_buf[j][in_off];
12189
12190 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12191 {
12192 if (out_pos == RULES_MAX - 1)
12193 {
12194 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12195
12196 break;
12197 }
12198
12199 out->cmds[out_pos] = in->cmds[in_pos];
12200 }
12201 }
12202 }
12203
12204 local_free (repeats);
12205 }
12206 else if (rp_gen)
12207 {
12208 uint gpu_rules_avail = 0;
12209
12210 while (gpu_rules_cnt < rp_gen)
12211 {
12212 if (gpu_rules_avail == gpu_rules_cnt)
12213 {
12214 gpu_rules_buf = (gpu_rule_t *) myrealloc (gpu_rules_buf, gpu_rules_avail * sizeof (gpu_rule_t), INCR_RULES * sizeof (gpu_rule_t));
12215
12216 gpu_rules_avail += INCR_RULES;
12217 }
12218
12219 memset (rule_buf, 0, BLOCK_SIZE);
12220
12221 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12222
12223 if (cpu_rule_to_gpu_rule (rule_buf, rule_len, &gpu_rules_buf[gpu_rules_cnt]) == -1) continue;
12224
12225 gpu_rules_cnt++;
12226 }
12227 }
12228 }
12229
12230 /**
12231 * generate NOP rules
12232 */
12233
12234 if (gpu_rules_cnt == 0)
12235 {
12236 gpu_rules_buf = (gpu_rule_t *) mymalloc (sizeof (gpu_rule_t));
12237
12238 gpu_rules_buf[gpu_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12239
12240 gpu_rules_cnt++;
12241 }
12242
12243 data.gpu_rules_cnt = gpu_rules_cnt;
12244 data.gpu_rules_buf = gpu_rules_buf;
12245
12246 /**
12247 * platform
12248 */
12249
12250 cl_platform_id CL_platforms[CL_PLATFORMS_MAX];
12251
12252 uint CL_platforms_cnt = 0;
12253
12254 hc_clGetPlatformIDs (CL_PLATFORMS_MAX, CL_platforms, &CL_platforms_cnt);
12255
12256 if (CL_platforms_cnt == 0)
12257 {
12258 log_error ("ERROR: No OpenCL compatible platform found");
12259
12260 return (-1);
12261 }
12262
12263 uint CL_platform_sel = 0;
12264
12265 if (CL_platforms_cnt > 1)
12266 {
12267 if (gpu_platform == NULL)
12268 {
12269 log_error ("ERROR: Too many OpenCL compatible platforms found");
12270 log_error (" Please select a single platform using the --gpu-platform option");
12271 log_error ("");
12272 log_error ("Available OpenCL platforms:");
12273
12274 for (uint i = 0; i < CL_platforms_cnt; i++)
12275 {
12276 char CL_platform_vendor[INFOSZ];
12277
12278 memset (CL_platform_vendor, 0, sizeof (CL_platform_vendor));
12279
12280 hc_clGetPlatformInfo (CL_platforms[i], CL_PLATFORM_VENDOR, sizeof (CL_platform_vendor), CL_platform_vendor, NULL);
12281
12282 printf ("* %d = %s\n", i + 1, CL_platform_vendor);
12283 }
12284 }
12285 else
12286 {
12287 CL_platform_sel = atoi (gpu_platform);
12288 }
12289
12290 return (-1);
12291 }
12292
12293 cl_platform_id CL_platform = CL_platforms[CL_platform_sel];
12294
12295 char CL_platform_vendor[INFOSZ];
12296
12297 memset (CL_platform_vendor, 0, sizeof (CL_platform_vendor));
12298
12299 hc_clGetPlatformInfo (CL_platform, CL_PLATFORM_VENDOR, sizeof (CL_platform_vendor), CL_platform_vendor, NULL);
12300
12301 uint vendor_id;
12302
12303 if (strcmp (CL_platform_vendor, CL_VENDOR_AMD) == 0)
12304 {
12305 vendor_id = VENDOR_ID_AMD;
12306 }
12307 else if (strcmp (CL_platform_vendor, CL_VENDOR_NV) == 0)
12308 {
12309 vendor_id = VENDOR_ID_NV;
12310
12311 // make sure that we do not directly control the fan for NVidia
12312
12313 gpu_temp_retain = 0;
12314 data.gpu_temp_retain = gpu_temp_retain;
12315 }
12316 else
12317 {
12318 vendor_id = VENDOR_ID_UNKNOWN;
12319 }
12320
12321 if (vendor_id == VENDOR_ID_UNKNOWN)
12322 {
12323 log_error ("Warning: unknown OpenCL vendor '%s' detected", CL_platform_vendor);
12324
12325 gpu_temp_disable = 1;
12326 }
12327
12328 data.vendor_id = vendor_id;
12329
12330 /**
12331 * devices
12332 */
12333
12334 cl_device_id devices_all[DEVICES_MAX];
12335 cl_device_id devices[DEVICES_MAX];
12336
12337 uint devices_all_cnt = 0;
12338
12339 hc_clGetDeviceIDs (CL_platform, CL_DEVICE_TYPE_GPU, DEVICES_MAX, devices_all, (uint *) &devices_all_cnt);
12340
12341 int hm_adapters_all = devices_all_cnt;
12342
12343 hm_attrs_t hm_adapter_all[DEVICES_MAX];
12344
12345 memset (hm_adapter_all, 0, sizeof (hm_adapter_all));
12346
12347 if (gpu_temp_disable == 0)
12348 {
12349 if (vendor_id == VENDOR_ID_NV)
12350 {
12351 #ifdef LINUX
12352 HM_LIB hm_dll = hm_init ();
12353
12354 data.hm_dll = hm_dll;
12355
12356 if (hc_NVML_nvmlInit (hm_dll) == NVML_SUCCESS)
12357 {
12358 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX];
12359
12360 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12361
12362 int tmp_out = 0;
12363
12364 for (int i = 0; i < tmp_in; i++)
12365 {
12366 hm_adapter_all[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12367 }
12368
12369 hm_adapters_all = tmp_out;
12370
12371 for (int i = 0; i < tmp_out; i++)
12372 {
12373 unsigned int speed;
12374
12375 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;
12376 }
12377 }
12378 #endif
12379
12380 #ifdef WIN
12381 if (NvAPI_Initialize () == NVAPI_OK)
12382 {
12383 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX];
12384
12385 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12386
12387 int tmp_out = 0;
12388
12389 for (int i = 0; i < tmp_in; i++)
12390 {
12391 hm_adapter_all[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12392 }
12393
12394 hm_adapters_all = tmp_out;
12395
12396 for (int i = 0; i < tmp_out; i++)
12397 {
12398 NvU32 speed;
12399
12400 if (NvAPI_GPU_GetTachReading (hm_adapter_all[i].adapter_index.nv, &speed) != NVAPI_NOT_SUPPORTED) hm_adapter_all[i].fan_supported = 1;
12401 }
12402 }
12403 #endif
12404 }
12405
12406 if (vendor_id == VENDOR_ID_AMD)
12407 {
12408 HM_LIB hm_dll = hm_init ();
12409
12410 data.hm_dll = hm_dll;
12411
12412 if (hc_ADL_Main_Control_Create (hm_dll, ADL_Main_Memory_Alloc, 0) == ADL_OK)
12413 {
12414 // total number of adapters
12415
12416 int hm_adapters_num;
12417
12418 if (get_adapters_num_amd (hm_dll, &hm_adapters_num) != 0) return (-1);
12419
12420 // adapter info
12421
12422 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (hm_dll, hm_adapters_num);
12423
12424 if (lpAdapterInfo == NULL) return (-1);
12425
12426 // get a list (of ids of) valid/usable adapters
12427
12428 int num_adl_adapters = 0;
12429
12430 uint32_t *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
12431
12432 if (num_adl_adapters > 0)
12433 {
12434 hc_thread_mutex_lock (mux_adl);
12435
12436 // hm_get_opencl_busid_devid (hm_adapter_all, devices_all_cnt, devices_all);
12437
12438 hm_get_adapter_index_amd (hm_adapter_all, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12439
12440 hm_get_overdrive_version (hm_dll, hm_adapter_all, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12441 hm_check_fanspeed_control (hm_dll, hm_adapter_all, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12442
12443 hc_thread_mutex_unlock (mux_adl);
12444 }
12445
12446 hm_adapters_all = num_adl_adapters;
12447
12448 myfree (valid_adl_device_list);
12449 myfree (lpAdapterInfo);
12450 }
12451 }
12452 }
12453
12454 if (hm_adapters_all == 0)
12455 {
12456 gpu_temp_disable = 1;
12457 }
12458
12459 if (gpu_temp_disable == 1)
12460 {
12461 gpu_temp_abort = 0;
12462 gpu_temp_retain = 0;
12463 }
12464
12465 /**
12466 * enable custom signal handler(s)
12467 */
12468
12469 if (benchmark == 0)
12470 {
12471 hc_signal (sigHandler_default);
12472 }
12473 else
12474 {
12475 hc_signal (sigHandler_benchmark);
12476 }
12477
12478 /**
12479 * devices mask and properties
12480 */
12481
12482 uint devices_cnt = 0;
12483
12484 for (uint device_all_id = 0; device_all_id < devices_all_cnt; device_all_id++)
12485 {
12486 if (gpu_devicemask)
12487 {
12488 uint device_all_id_mask = 1 << device_all_id;
12489
12490 if ((device_all_id_mask & gpu_devicemask) != device_all_id_mask)
12491 {
12492 if (quiet == 0 && algorithm_pos == 0) log_info ("Device #%d: skipped by user", device_all_id_mask + 1);
12493
12494 continue;
12495 }
12496 }
12497
12498 const uint device_id = devices_cnt;
12499
12500 devices[device_id] = devices_all[device_all_id];
12501
12502 memcpy (&data.hm_device[device_id], &hm_adapter_all[device_all_id], sizeof (hm_attrs_t));
12503
12504 char device_name[INFOSZ];
12505
12506 memset (device_name, 0, sizeof (device_name));
12507
12508 cl_ulong global_mem_size;
12509 cl_ulong max_mem_alloc_size;
12510 cl_uint max_clock_frequency;
12511 cl_uint max_compute_units;
12512
12513 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_NAME, sizeof (device_name), &device_name, NULL);
12514 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (global_mem_size), &global_mem_size, NULL);
12515 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (max_mem_alloc_size), &max_mem_alloc_size, NULL);
12516 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (max_clock_frequency), &max_clock_frequency, NULL);
12517 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (max_compute_units), &max_compute_units, NULL);
12518
12519 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12520 {
12521 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12522 device_all_id + 1,
12523 device_name,
12524 (unsigned int) (max_mem_alloc_size / 1024 / 1024),
12525 (unsigned int) (global_mem_size / 1024 / 1024),
12526 (unsigned int) (max_clock_frequency),
12527 (unsigned int) max_compute_units);
12528 }
12529
12530 devices_cnt++;
12531 }
12532
12533 if (devices_cnt == 0)
12534 {
12535 log_error ("ERROR: No devices left that matches your specification.");
12536
12537 return (-1);
12538 }
12539
12540 data.devices_cnt = devices_cnt;
12541
12542 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12543 {
12544 log_info ("");
12545 }
12546
12547 /**
12548 * inform the user
12549 */
12550
12551 // gpu temp sanity check
12552
12553 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
12554 {
12555 if (gpu_temp_abort < gpu_temp_retain)
12556 {
12557 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
12558
12559 return (-1);
12560 }
12561 }
12562
12563 data.gpu_temp_disable = gpu_temp_disable;
12564 data.gpu_temp_abort = gpu_temp_abort;
12565 data.gpu_temp_retain = gpu_temp_retain;
12566
12567 if (data.quiet == 0)
12568 {
12569 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
12570
12571 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);
12572
12573 if (attack_mode == ATTACK_MODE_STRAIGHT)
12574 {
12575 log_info ("Rules: %u", gpu_rules_cnt);
12576 }
12577
12578 if (opti_type)
12579 {
12580 log_info ("Applicable Optimizers:");
12581
12582 for (uint i = 0; i < 32; i++)
12583 {
12584 const uint opti_bit = 1 << i;
12585
12586 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
12587 }
12588 }
12589
12590 /**
12591 * Watchdog and Temperature balance
12592 */
12593
12594 if (gpu_temp_abort == 0)
12595 {
12596 log_info ("Watchdog: Temperature abort trigger disabled");
12597 }
12598 else
12599 {
12600 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
12601 }
12602
12603 if (gpu_temp_retain == 0)
12604 {
12605 log_info ("Watchdog: Temperature retain trigger disabled");
12606 }
12607 else
12608 {
12609 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
12610 }
12611 }
12612
12613 /**
12614 * devices init
12615 */
12616
12617 int *temp_retain_fanspeed_value = (int *) mycalloc (devices_cnt, sizeof (int));
12618
12619 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (devices_cnt, sizeof (ADLOD6MemClockState));
12620
12621 int *od_power_control_status = (int *) mycalloc (devices_cnt, sizeof (int));
12622
12623 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (devices_cnt, sizeof (hc_device_param_t));
12624
12625 data.devices_param = devices_param;
12626
12627 for (uint device_id = 0; device_id < devices_cnt; device_id++)
12628 {
12629 hc_device_param_t *device_param = &data.devices_param[device_id];
12630
12631 cl_device_id device = devices[device_id];
12632
12633 device_param->device = device;
12634
12635 cl_uint max_compute_units = 0;
12636
12637 hc_clGetDeviceInfo (device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (max_compute_units), &max_compute_units, NULL);
12638
12639 device_param->gpu_processors = max_compute_units;
12640
12641 cl_ulong max_mem_alloc_size = 0;
12642
12643 hc_clGetDeviceInfo (device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (max_mem_alloc_size), &max_mem_alloc_size, NULL);
12644
12645 device_param->gpu_maxmem_alloc = max_mem_alloc_size;
12646
12647 char tmp[INFOSZ], t1[64];
12648
12649 memset (tmp, 0, sizeof (tmp));
12650
12651 hc_clGetDeviceInfo (device, CL_DEVICE_NAME, sizeof (tmp), &tmp, NULL);
12652
12653 device_param->device_name = mystrdup (tmp);
12654
12655 memset (tmp, 0, sizeof (tmp));
12656
12657 hc_clGetDeviceInfo (device, CL_DEVICE_VERSION, sizeof (tmp), &tmp, NULL);
12658
12659 memset (t1, 0, sizeof (t1));
12660
12661 sscanf (tmp, "%*16s %*16s %*16s (%[^)]16s)", t1);
12662
12663 device_param->device_version = mystrdup (t1);
12664
12665 memset (tmp, 0, sizeof (tmp));
12666
12667 hc_clGetDeviceInfo (device, CL_DRIVER_VERSION, sizeof (tmp), &tmp, NULL);
12668
12669 device_param->driver_version = mystrdup (tmp);
12670
12671 if (vendor_id == VENDOR_ID_AMD)
12672 {
12673 cl_uint gpu_processor_cores = 0;
12674
12675 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12676
12677 hc_clGetDeviceInfo (device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (gpu_processor_cores), &gpu_processor_cores, NULL);
12678
12679 device_param->gpu_processor_cores = gpu_processor_cores;
12680 }
12681
12682 if (vendor_id == VENDOR_ID_NV)
12683 {
12684 cl_uint kernel_exec_timeout = 0;
12685
12686 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12687
12688 hc_clGetDeviceInfo (device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12689
12690 device_param->kernel_exec_timeout = kernel_exec_timeout;
12691
12692 cl_uint gpu_processor_cores = 0;
12693
12694 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12695
12696 hc_clGetDeviceInfo (device, CL_DEVICE_WARP_SIZE_NV, sizeof (gpu_processor_cores), &gpu_processor_cores, NULL);
12697
12698 device_param->gpu_processor_cores = gpu_processor_cores;
12699
12700 cl_uint sm_minor = 0;
12701 cl_uint sm_major = 0;
12702
12703 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12704 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12705
12706 hc_clGetDeviceInfo (device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12707 hc_clGetDeviceInfo (device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12708
12709 device_param->sm_minor = sm_minor;
12710 device_param->sm_major = sm_major;
12711 }
12712
12713 /**
12714 * common driver check
12715 */
12716
12717 if (vendor_id == VENDOR_ID_NV)
12718 {
12719 if (device_param->kernel_exec_timeout != 0)
12720 {
12721 if (data.quiet == 0) log_info ("Device #%u: WARNING! Kernel exec timeout is not disabled, it might cause you errors of code 702", device_id + 1);
12722 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12723 }
12724 }
12725
12726 if (vendor_id == VENDOR_ID_AMD)
12727 {
12728 int catalyst_check = (force == 1) ? 0 : 1;
12729
12730 int catalyst_warn = 0;
12731
12732 int catalyst_broken = 0;
12733
12734 if (catalyst_check == 1)
12735 {
12736 catalyst_warn = 1;
12737
12738 // v14.9 and higher
12739 if ((atoi (device_param->device_version) >= 1573)
12740 && (atoi (device_param->driver_version) >= 1573))
12741 {
12742 catalyst_warn = 0;
12743 }
12744
12745 catalyst_check = 0;
12746 }
12747
12748 if (catalyst_broken == 1)
12749 {
12750 log_error ("");
12751 log_error ("ATTENTION! The installed GPU driver in your system is known to be broken!");
12752 log_error ("It will pass over cracked hashes and does not report them as cracked");
12753 log_error ("You are STRONGLY encouraged not to use it");
12754 log_error ("You can use --force to override this but do not post error reports if you do so");
12755
12756 return (-1);
12757 }
12758
12759 if (catalyst_warn == 1)
12760 {
12761 log_error ("");
12762 log_error ("ATTENTION! Unsupported or incorrect installed GPU driver detected!");
12763 log_error ("You are STRONGLY encouraged to use the official supported GPU driver for good reasons");
12764 log_error ("See oclHashcat's homepage for official supported GPU drivers");
12765 #ifdef _WIN
12766 log_error ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12767 #endif
12768 log_error ("You can use --force to override this but do not post error reports if you do so");
12769
12770 return (-1);
12771 }
12772 }
12773 }
12774
12775 /*
12776 * Temporary fix:
12777 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
12778 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
12779 * were not working @ full speed (setting hc_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
12780 * Driver / ADL bug?
12781 */
12782
12783 if (vendor_id == VENDOR_ID_AMD)
12784 {
12785 if (powertune_enable == 1)
12786 {
12787 hc_thread_mutex_lock (mux_adl);
12788
12789 for (uint i = 0; i < devices_cnt; i++)
12790 {
12791 if (data.hm_device[i].od_version == 6)
12792 {
12793 // set powertune value only
12794
12795 int powertune_supported = 0;
12796
12797 int ADL_rc = 0;
12798
12799 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll, data.hm_device[i].adapter_index.amd, &powertune_supported)) != ADL_OK)
12800 {
12801 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
12802
12803 return (-1);
12804 }
12805
12806 if (powertune_supported != 0)
12807 {
12808 // powertune set
12809 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
12810
12811 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll, data.hm_device[i].adapter_index.amd, &powertune)) != ADL_OK)
12812 {
12813 log_error ("ERROR: Failed to get current ADL PowerControl settings");
12814
12815 return (-1);
12816 }
12817
12818 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll, data.hm_device[i].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
12819 {
12820 log_error ("ERROR: Failed to set new ADL PowerControl values");
12821
12822 return (-1);
12823 }
12824 }
12825 }
12826 }
12827
12828 hc_thread_mutex_unlock (mux_adl);
12829 }
12830 }
12831
12832 uint gpu_blocks_all = 0;
12833
12834 for (uint device_id = 0; device_id < devices_cnt; device_id++)
12835 {
12836 /**
12837 * host buffer
12838 */
12839
12840 hc_device_param_t *device_param = &data.devices_param[device_id];
12841
12842 /**
12843 * device properties
12844 */
12845
12846 char *device_name = device_param->device_name;
12847 char *device_version = device_param->device_version;
12848 char *driver_version = device_param->driver_version;
12849
12850 uint gpu_processors = device_param->gpu_processors;
12851
12852 uint gpu_processor_cores = device_param->gpu_processor_cores;
12853
12854 /**
12855 * create context for each device
12856 */
12857
12858 device_param->context = hc_clCreateContext (NULL, 1, &device_param->device, NULL, NULL);
12859
12860 /**
12861 * create command-queue
12862 */
12863
12864 // not support with NV
12865 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
12866
12867 device_param->command_queue = hc_clCreateCommandQueue (device_param->context, device_param->device, 0);
12868
12869 /**
12870 * create input buffers on device
12871 */
12872
12873 uint gpu_threads = GPU_THREADS;
12874
12875 // bcrypt
12876 if (hash_mode == 3200) gpu_threads = 8;
12877 if (hash_mode == 9000) gpu_threads = 8;
12878
12879 uint gpu_power = gpu_processors * gpu_threads * gpu_accel;
12880 uint gpu_blocks = gpu_power;
12881
12882 device_param->gpu_threads = gpu_threads;
12883 device_param->gpu_power_user = gpu_power;
12884 device_param->gpu_blocks_user = gpu_blocks;
12885
12886 gpu_blocks_all += gpu_blocks;
12887
12888 uint size_pws = gpu_power * sizeof (pw_t);
12889
12890 uint size_tmps = 4;
12891
12892 switch (hash_mode)
12893 {
12894 case 400: size_tmps = gpu_blocks * sizeof (phpass_tmp_t); break;
12895 case 500: size_tmps = gpu_blocks * sizeof (md5crypt_tmp_t); break;
12896 case 501: size_tmps = gpu_blocks * sizeof (md5crypt_tmp_t); break;
12897 case 1600: size_tmps = gpu_blocks * sizeof (md5crypt_tmp_t); break;
12898 case 1800: size_tmps = gpu_blocks * sizeof (sha512crypt_tmp_t); break;
12899 case 2100: size_tmps = gpu_blocks * sizeof (dcc2_tmp_t); break;
12900 case 2500: size_tmps = gpu_blocks * sizeof (wpa_tmp_t); break;
12901 case 3200: size_tmps = gpu_blocks * sizeof (bcrypt_tmp_t); break;
12902 case 5200: size_tmps = gpu_blocks * sizeof (pwsafe3_tmp_t); break;
12903 case 5800: size_tmps = gpu_blocks * sizeof (androidpin_tmp_t); break;
12904 case 6211:
12905 case 6212:
12906 case 6213: size_tmps = gpu_blocks * sizeof (tc_tmp_t); break;
12907 case 6221:
12908 case 6222:
12909 case 6223: size_tmps = gpu_blocks * sizeof (tc64_tmp_t); break;
12910 case 6231:
12911 case 6232:
12912 case 6233: size_tmps = gpu_blocks * sizeof (tc_tmp_t); break;
12913 case 6241:
12914 case 6242:
12915 case 6243: size_tmps = gpu_blocks * sizeof (tc_tmp_t); break;
12916 case 6300: size_tmps = gpu_blocks * sizeof (md5crypt_tmp_t); break;
12917 case 6400: size_tmps = gpu_blocks * sizeof (sha256aix_tmp_t); break;
12918 case 6500: size_tmps = gpu_blocks * sizeof (sha512aix_tmp_t); break;
12919 case 6600: size_tmps = gpu_blocks * sizeof (agilekey_tmp_t); break;
12920 case 6700: size_tmps = gpu_blocks * sizeof (sha1aix_tmp_t); break;
12921 case 6800: size_tmps = gpu_blocks * sizeof (lastpass_tmp_t); break;
12922 case 7100: size_tmps = gpu_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
12923 case 7200: size_tmps = gpu_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
12924 case 7400: size_tmps = gpu_blocks * sizeof (sha256crypt_tmp_t); break;
12925 case 7900: size_tmps = gpu_blocks * sizeof (drupal7_tmp_t); break;
12926 case 8200: size_tmps = gpu_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
12927 case 8800: size_tmps = gpu_blocks * sizeof (androidfde_tmp_t); break;
12928 case 8900: size_tmps = gpu_blocks * sizeof (scrypt_tmp_t); break;
12929 case 9000: size_tmps = gpu_blocks * sizeof (pwsafe2_tmp_t); break;
12930 case 9100: size_tmps = gpu_blocks * sizeof (lotus8_tmp_t); break;
12931 case 9200: size_tmps = gpu_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
12932 case 9300: size_tmps = gpu_blocks * sizeof (scrypt_tmp_t); break;
12933 case 9400: size_tmps = gpu_blocks * sizeof (office2007_tmp_t); break;
12934 case 9500: size_tmps = gpu_blocks * sizeof (office2010_tmp_t); break;
12935 case 9600: size_tmps = gpu_blocks * sizeof (office2013_tmp_t); break;
12936 case 10000: size_tmps = gpu_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
12937 case 10200: size_tmps = gpu_blocks * sizeof (cram_md5_t); break;
12938 case 10300: size_tmps = gpu_blocks * sizeof (saph_sha1_tmp_t); break;
12939 case 10500: size_tmps = gpu_blocks * sizeof (pdf14_tmp_t); break;
12940 case 10700: size_tmps = gpu_blocks * sizeof (pdf17l8_tmp_t); break;
12941 case 10900: size_tmps = gpu_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
12942 case 11300: size_tmps = gpu_blocks * sizeof (bitcoin_wallet_tmp_t); break;
12943 case 11600: size_tmps = gpu_blocks * sizeof (seven_zip_tmp_t); break;
12944 case 11900: size_tmps = gpu_blocks * sizeof (pbkdf2_md5_tmp_t); break;
12945 case 12000: size_tmps = gpu_blocks * sizeof (pbkdf2_sha1_tmp_t); break;
12946 case 12100: size_tmps = gpu_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
12947 case 12200: size_tmps = gpu_blocks * sizeof (ecryptfs_tmp_t); break;
12948 case 12300: size_tmps = gpu_blocks * sizeof (oraclet_tmp_t); break;
12949 case 12400: size_tmps = gpu_blocks * sizeof (bsdicrypt_tmp_t); break;
12950 case 12500: size_tmps = gpu_blocks * sizeof (rar3_tmp_t); break;
12951 case 12700: size_tmps = gpu_blocks * sizeof (mywallet_tmp_t); break;
12952 case 12800: size_tmps = gpu_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
12953 };
12954
12955 uint size_hooks = 4;
12956
12957 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
12958 {
12959 // insert correct hook size
12960 }
12961
12962 // we can optimize some stuff here...
12963
12964 device_param->size_pws = size_pws;
12965 device_param->size_tmps = size_tmps;
12966 device_param->size_hooks = size_hooks;
12967
12968 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
12969 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
12970
12971 device_param->size_root_css = size_root_css;
12972 device_param->size_markov_css = size_markov_css;
12973
12974 uint size_results = GPU_THREADS * sizeof (uint);
12975
12976 device_param->size_results = size_results;
12977
12978 uint size_rules = gpu_rules_cnt * sizeof (gpu_rule_t);
12979 uint size_rules_c = GPU_RULES * sizeof (gpu_rule_t);
12980 uint size_plains = digests_cnt * sizeof (plain_t);
12981 uint size_salts = salts_cnt * sizeof (salt_t);
12982 uint size_esalts = salts_cnt * esalt_size;
12983
12984 device_param->size_plains = size_plains;
12985 device_param->size_digests = size_digests;
12986 device_param->size_shown = size_shown;
12987 device_param->size_salts = size_salts;
12988
12989 uint size_combs = GPU_COMBS * sizeof (comb_t);
12990 uint size_bfs = GPU_BFS * sizeof (bf_t);
12991 uint size_tm = 32 * sizeof (bs_word_t);
12992
12993 uint64_t size_scryptV = 1;
12994
12995 if ((hash_mode == 8900) || (hash_mode == 9300))
12996 {
12997 uint tmto_start = 0;
12998 uint tmto_stop = 10;
12999
13000 if (scrypt_tmto)
13001 {
13002 tmto_start = scrypt_tmto;
13003 }
13004 else
13005 {
13006 // in case the user did not specify the tmto manually
13007 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13008 // but set the lower end only in case the user has a gpu with too less memory
13009
13010 if (hash_mode == 8900)
13011 {
13012 if (vendor_id == VENDOR_ID_AMD)
13013 {
13014 tmto_start = 1;
13015 }
13016 else if (vendor_id == VENDOR_ID_NV)
13017 {
13018 tmto_start = 3;
13019 }
13020 }
13021 else if (hash_mode == 9300)
13022 {
13023 if (vendor_id == VENDOR_ID_AMD)
13024 {
13025 tmto_start = 3;
13026 }
13027 else if (vendor_id == VENDOR_ID_NV)
13028 {
13029 tmto_start = 5;
13030 }
13031 }
13032 }
13033
13034 if (quiet == 0) log_info ("");
13035
13036 uint shader_per_mp = 1;
13037
13038 if (vendor_id == VENDOR_ID_AMD)
13039 {
13040 shader_per_mp = 8;
13041 }
13042
13043 if (vendor_id == VENDOR_ID_NV)
13044 {
13045 shader_per_mp = 32;
13046 }
13047
13048 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13049 {
13050 // TODO: in theory the following calculation needs to be done per salt, not global
13051 // we assume all hashes have the same scrypt settings
13052
13053 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13054
13055 size_scryptV /= 1 << tmto;
13056
13057 size_scryptV *= gpu_processors * gpu_processor_cores * shader_per_mp;
13058
13059 if (size_scryptV > device_param->gpu_maxmem_alloc)
13060 {
13061 if (quiet == 0) log_info ("WARNING: not enough GPU memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13062
13063 continue;
13064 }
13065
13066 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13067 {
13068 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13069 data.salts_buf[salts_pos].scrypt_phy = gpu_processors * gpu_processor_cores * shader_per_mp;
13070 }
13071
13072 break;
13073 }
13074
13075 if (data.salts_buf[0].scrypt_phy == 0)
13076 {
13077 log_error ("ERROR: can't allocate enough GPU memory");
13078
13079 return -1;
13080 }
13081
13082 if (quiet == 0) log_info ("");
13083 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13084 }
13085
13086 /**
13087 * default building options
13088 */
13089
13090 char build_opts[1024];
13091
13092 // we don't have sm_* on AMD but it doesn't matter
13093
13094 sprintf (build_opts, "-I. -IOpenCL/ -DVENDOR_ID=%d -DCUDA_ARCH=%d", vendor_id, (device_param->sm_major * 100) + device_param->sm_minor);
13095
13096 /**
13097 * main kernel
13098 */
13099
13100 {
13101 /**
13102 * kernel source filename
13103 */
13104
13105 char source_file[256];
13106
13107 memset (source_file, 0, sizeof (source_file));
13108
13109 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, install_dir, source_file);
13110
13111 struct stat sst;
13112
13113 if (stat (source_file, &sst) == -1)
13114 {
13115 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13116
13117 return -1;
13118 }
13119
13120 /**
13121 * kernel cached filename
13122 */
13123
13124 char cached_file[256];
13125
13126 memset (cached_file, 0, sizeof (cached_file));
13127
13128 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, install_dir, device_name, device_version, driver_version, vendor_id, cached_file);
13129
13130 int cached = 1;
13131
13132 struct stat cst;
13133
13134 if (stat (cached_file, &cst) == -1)
13135 {
13136 cached = 0;
13137 }
13138
13139 /**
13140 * kernel compile or load
13141 */
13142
13143 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13144
13145 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13146
13147 if (force_jit_compilation == 0)
13148 {
13149 if (cached == 0)
13150 {
13151 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13152
13153 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13154
13155 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13156
13157 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13158
13159 size_t binary_size;
13160
13161 clGetProgramInfo (device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13162
13163 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13164
13165 clGetProgramInfo (device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13166
13167 writeProgramBin (cached_file, binary, binary_size);
13168
13169 local_free (binary);
13170 }
13171 else
13172 {
13173 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13174
13175 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13176
13177 device_param->program = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13178
13179 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13180 }
13181 }
13182 else
13183 {
13184 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13185
13186 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13187
13188 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13189
13190 if (force_jit_compilation == 1500)
13191 {
13192 sprintf (build_opts, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13193 }
13194 else if (force_jit_compilation == 8900)
13195 {
13196 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, 1 << data.salts_buf[0].scrypt_tmto);
13197 }
13198
13199 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13200 }
13201
13202 local_free (kernel_lengths);
13203 local_free (kernel_sources[0]);
13204 local_free (kernel_sources);
13205
13206 // this is mostly for debug
13207
13208 size_t ret_val_size = 0;
13209
13210 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13211
13212 if (ret_val_size > 2)
13213 {
13214 char *build_log = (char *) mymalloc (ret_val_size + 1);
13215
13216 memset (build_log, 0, ret_val_size + 1);
13217
13218 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13219
13220 puts (build_log);
13221
13222 myfree (build_log);
13223 }
13224 }
13225
13226 /**
13227 * word generator kernel
13228 */
13229
13230 if (attack_mode != ATTACK_MODE_STRAIGHT)
13231 {
13232 /**
13233 * kernel mp source filename
13234 */
13235
13236 char source_file[256];
13237
13238 memset (source_file, 0, sizeof (source_file));
13239
13240 generate_source_kernel_mp_filename (opti_type, opts_type, install_dir, source_file);
13241
13242 struct stat sst;
13243
13244 if (stat (source_file, &sst) == -1)
13245 {
13246 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13247
13248 return -1;
13249 }
13250
13251 /**
13252 * kernel mp cached filename
13253 */
13254
13255 char cached_file[256];
13256
13257 memset (cached_file, 0, sizeof (cached_file));
13258
13259 generate_cached_kernel_mp_filename (opti_type, opts_type, install_dir, device_name, device_version, driver_version, vendor_id, cached_file);
13260
13261 int cached = 1;
13262
13263 struct stat cst;
13264
13265 if (stat (cached_file, &cst) == -1)
13266 {
13267 cached = 0;
13268 }
13269
13270 /**
13271 * kernel compile or load
13272 */
13273
13274 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13275
13276 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13277
13278 if (cached == 0)
13279 {
13280 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13281
13282 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13283
13284 device_param->program_mp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13285
13286 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13287
13288 size_t binary_size;
13289
13290 clGetProgramInfo (device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13291
13292 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13293
13294 clGetProgramInfo (device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13295
13296 writeProgramBin (cached_file, binary, binary_size);
13297
13298 local_free (binary);
13299 }
13300 else
13301 {
13302 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13303
13304 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13305
13306 device_param->program_mp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13307
13308 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13309 }
13310
13311 local_free (kernel_lengths);
13312 local_free (kernel_sources[0]);
13313 local_free (kernel_sources);
13314
13315 // this is mostly for debug
13316
13317 size_t ret_val_size = 0;
13318
13319 clGetProgramBuildInfo (device_param->program_mp, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13320
13321 if (ret_val_size > 2)
13322 {
13323 char *build_log = (char *) mymalloc (ret_val_size + 1);
13324
13325 memset (build_log, 0, ret_val_size + 1);
13326
13327 clGetProgramBuildInfo (device_param->program_mp, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13328
13329 puts (build_log);
13330
13331 myfree (build_log);
13332 }
13333 }
13334
13335 /**
13336 * amplifier kernel
13337 */
13338
13339 if (attack_exec == ATTACK_EXEC_ON_GPU)
13340 {
13341
13342 }
13343 else
13344 {
13345 /**
13346 * kernel amp source filename
13347 */
13348
13349 char source_file[256];
13350
13351 memset (source_file, 0, sizeof (source_file));
13352
13353 generate_source_kernel_amp_filename (attack_kern, install_dir, source_file);
13354
13355 struct stat sst;
13356
13357 if (stat (source_file, &sst) == -1)
13358 {
13359 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13360
13361 return -1;
13362 }
13363
13364 /**
13365 * kernel amp cached filename
13366 */
13367
13368 char cached_file[256];
13369
13370 memset (cached_file, 0, sizeof (cached_file));
13371
13372 generate_cached_kernel_amp_filename (attack_kern, install_dir, device_name, device_version, driver_version, vendor_id, cached_file);
13373
13374 int cached = 1;
13375
13376 struct stat cst;
13377
13378 if (stat (cached_file, &cst) == -1)
13379 {
13380 cached = 0;
13381 }
13382
13383 /**
13384 * kernel compile or load
13385 */
13386
13387 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13388
13389 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13390
13391 if (cached == 0)
13392 {
13393 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13394
13395 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13396
13397 device_param->program_amp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13398
13399 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13400
13401 size_t binary_size;
13402
13403 clGetProgramInfo (device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13404
13405 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13406
13407 clGetProgramInfo (device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13408
13409 writeProgramBin (cached_file, binary, binary_size);
13410
13411 local_free (binary);
13412 }
13413 else
13414 {
13415 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13416
13417 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13418
13419 device_param->program_amp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13420
13421 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13422 }
13423
13424 local_free (kernel_lengths);
13425 local_free (kernel_sources[0]);
13426 local_free (kernel_sources);
13427
13428 // this is mostly for debug
13429
13430 size_t ret_val_size = 0;
13431
13432 clGetProgramBuildInfo (device_param->program_amp, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13433
13434 if (ret_val_size > 2)
13435 {
13436 char *build_log = (char *) mymalloc (ret_val_size + 1);
13437
13438 memset (build_log, 0, ret_val_size + 1);
13439
13440 clGetProgramBuildInfo (device_param->program_amp, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13441
13442 puts (build_log);
13443
13444 myfree (build_log);
13445 }
13446 }
13447
13448 /**
13449 * global buffers
13450 */
13451
13452 device_param->d_pws_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13453 device_param->d_pws_amp_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13454 device_param->d_tmps = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
13455 device_param->d_hooks = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
13456 device_param->d_bitmap_s1_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13457 device_param->d_bitmap_s1_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13458 device_param->d_bitmap_s1_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13459 device_param->d_bitmap_s1_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13460 device_param->d_bitmap_s2_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13461 device_param->d_bitmap_s2_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13462 device_param->d_bitmap_s2_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13463 device_param->d_bitmap_s2_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13464 device_param->d_plain_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
13465 device_param->d_digests_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
13466 device_param->d_digests_shown = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
13467 device_param->d_salt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
13468 device_param->d_result = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
13469 device_param->d_scryptV_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
13470
13471 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_a, CL_TRUE, 0, bitmap_size, bitmap_s1_a, 0, NULL, NULL);
13472 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_b, CL_TRUE, 0, bitmap_size, bitmap_s1_b, 0, NULL, NULL);
13473 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_c, CL_TRUE, 0, bitmap_size, bitmap_s1_c, 0, NULL, NULL);
13474 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_d, CL_TRUE, 0, bitmap_size, bitmap_s1_d, 0, NULL, NULL);
13475 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_a, CL_TRUE, 0, bitmap_size, bitmap_s2_a, 0, NULL, NULL);
13476 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_b, CL_TRUE, 0, bitmap_size, bitmap_s2_b, 0, NULL, NULL);
13477 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_c, CL_TRUE, 0, bitmap_size, bitmap_s2_c, 0, NULL, NULL);
13478 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_d, CL_TRUE, 0, bitmap_size, bitmap_s2_d, 0, NULL, NULL);
13479 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
13480 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
13481 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
13482
13483 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
13484 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
13485 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
13486 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
13487 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
13488 run_kernel_bzero (device_param, device_param->d_result, size_results);
13489
13490 /**
13491 * special buffers
13492 */
13493
13494 if (attack_kern == ATTACK_KERN_STRAIGHT)
13495 {
13496 device_param->d_rules = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
13497 device_param->d_rules_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
13498
13499 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, gpu_rules_buf, 0, NULL, NULL);
13500
13501 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
13502 }
13503 else if (attack_kern == ATTACK_KERN_COMBI)
13504 {
13505 device_param->d_combs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13506 device_param->d_combs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13507 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13508 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13509
13510 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
13511 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
13512 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13513 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13514 }
13515 else if (attack_kern == ATTACK_KERN_BF)
13516 {
13517 device_param->d_bfs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13518 device_param->d_bfs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13519 device_param->d_tm_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
13520 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13521 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13522
13523 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
13524 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
13525 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
13526 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13527 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13528 }
13529
13530 if (size_esalts)
13531 {
13532 device_param->d_esalt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
13533
13534 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
13535 }
13536
13537 /**
13538 * main host data
13539 */
13540
13541 uint *result = (uint *) mymalloc (size_results);
13542
13543 memset (result, 0, size_results);
13544
13545 device_param->result = result;
13546
13547 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
13548
13549 memset (pws_buf, 0, size_pws);
13550
13551 device_param->pws_buf = pws_buf;
13552
13553 pw_cache_t *pw_caches = (pw_cache_t *) mycalloc (64, sizeof (pw_cache_t));
13554
13555 for (int i = 0; i < 64; i++)
13556 {
13557 pw_caches[i].pw_buf.pw_len = i;
13558 pw_caches[i].cnt = 0;
13559 }
13560
13561 device_param->pw_caches = pw_caches;
13562
13563 comb_t *combs_buf = (comb_t *) mycalloc (GPU_COMBS, sizeof (comb_t));
13564
13565 device_param->combs_buf = combs_buf;
13566
13567 void *hooks_buf = mymalloc (size_hooks);
13568
13569 device_param->hooks_buf = hooks_buf;
13570
13571 device_param->pw_transpose = pw_transpose_to_hi1;
13572 device_param->pw_add = pw_add_to_hc1;
13573
13574 /**
13575 * kernel args
13576 */
13577
13578 device_param->kernel_params_buf32[21] = bitmap_mask;
13579 device_param->kernel_params_buf32[22] = bitmap_shift1;
13580 device_param->kernel_params_buf32[23] = bitmap_shift2;
13581 device_param->kernel_params_buf32[24] = 0; // salt_pos
13582 device_param->kernel_params_buf32[25] = 0; // loop_pos
13583 device_param->kernel_params_buf32[26] = 0; // loop_cnt
13584 device_param->kernel_params_buf32[27] = 0; // gpu_rules_cnt
13585 device_param->kernel_params_buf32[28] = 0; // digests_cnt
13586 device_param->kernel_params_buf32[29] = 0; // digests_offset
13587 device_param->kernel_params_buf32[30] = 0; // combs_mode
13588 device_param->kernel_params_buf32[31] = 0; // gid_max
13589
13590 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_ON_GPU)
13591 ? &device_param->d_pws_buf
13592 : &device_param->d_pws_amp_buf;
13593 device_param->kernel_params[ 1] = &device_param->d_rules_c;
13594 device_param->kernel_params[ 2] = &device_param->d_combs_c;
13595 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
13596 device_param->kernel_params[ 4] = &device_param->d_tmps;
13597 device_param->kernel_params[ 5] = &device_param->d_hooks;
13598 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
13599 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
13600 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
13601 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
13602 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
13603 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
13604 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
13605 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
13606 device_param->kernel_params[14] = &device_param->d_plain_bufs;
13607 device_param->kernel_params[15] = &device_param->d_digests_buf;
13608 device_param->kernel_params[16] = &device_param->d_digests_shown;
13609 device_param->kernel_params[17] = &device_param->d_salt_bufs;
13610 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
13611 device_param->kernel_params[19] = &device_param->d_result;
13612 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
13613 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
13614 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
13615 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
13616 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
13617 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
13618 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
13619 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
13620 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
13621 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
13622 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
13623 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
13624
13625 device_param->kernel_params_mp_buf64[3] = 0;
13626 device_param->kernel_params_mp_buf32[4] = 0;
13627 device_param->kernel_params_mp_buf32[5] = 0;
13628 device_param->kernel_params_mp_buf32[6] = 0;
13629 device_param->kernel_params_mp_buf32[7] = 0;
13630 device_param->kernel_params_mp_buf32[8] = 0;
13631
13632 device_param->kernel_params_mp[0] = NULL;
13633 device_param->kernel_params_mp[1] = NULL;
13634 device_param->kernel_params_mp[2] = NULL;
13635 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
13636 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
13637 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
13638 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
13639 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
13640 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
13641
13642 device_param->kernel_params_mp_l_buf64[3] = 0;
13643 device_param->kernel_params_mp_l_buf32[4] = 0;
13644 device_param->kernel_params_mp_l_buf32[5] = 0;
13645 device_param->kernel_params_mp_l_buf32[6] = 0;
13646 device_param->kernel_params_mp_l_buf32[7] = 0;
13647 device_param->kernel_params_mp_l_buf32[8] = 0;
13648 device_param->kernel_params_mp_l_buf32[9] = 0;
13649
13650 device_param->kernel_params_mp_l[0] = NULL;
13651 device_param->kernel_params_mp_l[1] = NULL;
13652 device_param->kernel_params_mp_l[2] = NULL;
13653 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
13654 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
13655 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
13656 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
13657 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
13658 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
13659 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
13660
13661 device_param->kernel_params_mp_r_buf64[3] = 0;
13662 device_param->kernel_params_mp_r_buf32[4] = 0;
13663 device_param->kernel_params_mp_r_buf32[5] = 0;
13664 device_param->kernel_params_mp_r_buf32[6] = 0;
13665 device_param->kernel_params_mp_r_buf32[7] = 0;
13666 device_param->kernel_params_mp_r_buf32[8] = 0;
13667
13668 device_param->kernel_params_mp_r[0] = NULL;
13669 device_param->kernel_params_mp_r[1] = NULL;
13670 device_param->kernel_params_mp_r[2] = NULL;
13671 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
13672 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
13673 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
13674 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
13675 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
13676 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
13677
13678 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
13679 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
13680
13681 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
13682 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
13683 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
13684 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
13685 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
13686 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
13687 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
13688
13689 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
13690
13691 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
13692 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
13693
13694 /**
13695 * kernel name
13696 */
13697
13698 char kernel_name[64];
13699
13700 memset (kernel_name, 0, sizeof (kernel_name));
13701
13702 if (attack_exec == ATTACK_EXEC_ON_GPU)
13703 {
13704 if (opti_type & OPTI_TYPE_SINGLE_HASH)
13705 {
13706 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
13707
13708 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
13709
13710 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
13711
13712 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
13713
13714 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
13715
13716 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
13717 }
13718 else
13719 {
13720 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
13721
13722 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
13723
13724 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
13725
13726 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
13727
13728 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
13729
13730 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
13731 }
13732
13733 if (data.attack_mode == ATTACK_MODE_BF)
13734 {
13735 if (opts_type & OPTS_TYPE_PT_BITSLICE)
13736 {
13737 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
13738
13739 device_param->kernel_tb = hc_clCreateKernel (device_param->program, kernel_name);
13740
13741 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
13742
13743 device_param->kernel_tm = hc_clCreateKernel (device_param->program, kernel_name);
13744 }
13745 }
13746 }
13747 else
13748 {
13749 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
13750
13751 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
13752
13753 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
13754
13755 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
13756
13757 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
13758
13759 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
13760
13761 if (opts_type & OPTS_TYPE_HOOK12)
13762 {
13763 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
13764
13765 device_param->kernel12 = hc_clCreateKernel (device_param->program, kernel_name);
13766 }
13767
13768 if (opts_type & OPTS_TYPE_HOOK23)
13769 {
13770 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
13771
13772 device_param->kernel23 = hc_clCreateKernel (device_param->program, kernel_name);
13773 }
13774 }
13775
13776 for (uint i = 0; i <= 20; i++)
13777 {
13778 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
13779 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
13780 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
13781
13782 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
13783 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
13784 }
13785
13786 for (uint i = 21; i <= 31; i++)
13787 {
13788 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
13789 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
13790 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
13791
13792 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
13793 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
13794 }
13795
13796 if (attack_mode == ATTACK_MODE_BF)
13797 {
13798 device_param->kernel_mp_l = hc_clCreateKernel (device_param->program_mp, "l_markov");
13799 device_param->kernel_mp_r = hc_clCreateKernel (device_param->program_mp, "r_markov");
13800
13801 if (opts_type & OPTS_TYPE_PT_BITSLICE)
13802 {
13803 hc_clSetKernelArg (device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
13804
13805 hc_clSetKernelArg (device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
13806 hc_clSetKernelArg (device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
13807 }
13808 }
13809 else if (attack_mode == ATTACK_MODE_HYBRID1)
13810 {
13811 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
13812 }
13813 else if (attack_mode == ATTACK_MODE_HYBRID2)
13814 {
13815 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
13816 }
13817
13818 if (attack_exec == ATTACK_EXEC_ON_GPU)
13819 {
13820 // nothing to do
13821 }
13822 else
13823 {
13824 device_param->kernel_amp = hc_clCreateKernel (device_param->program_amp, "amp");
13825 }
13826
13827 if (attack_exec == ATTACK_EXEC_ON_GPU)
13828 {
13829 // nothing to do
13830 }
13831 else
13832 {
13833 for (uint i = 0; i < 5; i++)
13834 {
13835 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
13836 }
13837
13838 for (uint i = 5; i < 7; i++)
13839 {
13840 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
13841 }
13842 }
13843
13844 /**
13845 * Store initial fanspeed if gpu_temp_retain is enabled
13846 */
13847
13848 int gpu_temp_retain_set = 0;
13849
13850 if (gpu_temp_disable == 0)
13851 {
13852 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
13853 {
13854 hc_thread_mutex_lock (mux_adl);
13855
13856 if (data.hm_device[device_id].fan_supported == 1)
13857 {
13858 if (gpu_temp_retain_chgd == 0)
13859 {
13860 uint cur_temp = 0;
13861 uint default_temp = 0;
13862
13863 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);
13864
13865 if (ADL_rc == ADL_OK)
13866 {
13867 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
13868
13869 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
13870
13871 // special case with multi gpu setups: always use minimum retain
13872
13873 if (gpu_temp_retain_set == 0)
13874 {
13875 gpu_temp_retain = gpu_temp_retain_target;
13876 gpu_temp_retain_set = 1;
13877 }
13878 else
13879 {
13880 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
13881 }
13882
13883 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
13884 }
13885 }
13886
13887 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
13888
13889 temp_retain_fanspeed_value[device_id] = fan_speed;
13890
13891 if (fan_speed == -1)
13892 {
13893 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
13894
13895 temp_retain_fanspeed_value[device_id] = 0;
13896 }
13897 }
13898
13899 hc_thread_mutex_unlock (mux_adl);
13900 }
13901 }
13902
13903 /**
13904 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
13905 */
13906
13907 if (powertune_enable == 1) // VENDOR_ID_AMD implied
13908 {
13909 hc_thread_mutex_lock (mux_adl);
13910
13911 if (data.hm_device[device_id].od_version == 6)
13912 {
13913 int ADL_rc;
13914
13915 // check powertune capabilities first, if not available then skip device
13916
13917 int powertune_supported = 0;
13918
13919 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13920 {
13921 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13922
13923 return (-1);
13924 }
13925
13926 if (powertune_supported != 0)
13927 {
13928 // powercontrol settings
13929
13930 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13931
13932 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
13933 {
13934 ADL_rc = hc_ADL_Overdrive_PowerControl_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
13935 }
13936
13937 if (ADL_rc != ADL_OK)
13938 {
13939 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13940
13941 return (-1);
13942 }
13943
13944 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13945 {
13946 log_error ("ERROR: Failed to set new ADL PowerControl values");
13947
13948 return (-1);
13949 }
13950
13951 // clocks
13952
13953 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
13954
13955 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
13956
13957 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)
13958 {
13959 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
13960
13961 return (-1);
13962 }
13963
13964 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
13965
13966 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
13967
13968 if ((ADL_rc = hc_ADL_Overdrive_Capabilities_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
13969 {
13970 log_error ("ERROR: Failed to get ADL device capabilities");
13971
13972 return (-1);
13973 }
13974
13975 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
13976 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
13977
13978 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
13979 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
13980
13981 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
13982 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
13983
13984 // warning if profile has to low max values
13985
13986 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
13987 {
13988 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
13989 }
13990
13991 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
13992 {
13993 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
13994 }
13995
13996 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
13997
13998 performance_state->iNumberOfPerformanceLevels = 2;
13999
14000 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14001 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14002 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14003 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14004
14005 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)
14006 {
14007 log_info ("ERROR: Failed to set ADL performance state");
14008
14009 return (-1);
14010 }
14011
14012 local_free (performance_state);
14013 }
14014 }
14015
14016 hc_thread_mutex_unlock (mux_adl);
14017 }
14018 }
14019
14020 data.gpu_blocks_all = gpu_blocks_all;
14021
14022 if (data.quiet == 0) log_info ("");
14023
14024 /**
14025 * Inform user which algorithm is checked and at which workload setting
14026 */
14027
14028 if (benchmark == 1)
14029 {
14030 quiet = 0;
14031
14032 data.quiet = quiet;
14033
14034 char *hash_type = strhashtype (data.hash_mode); // not a bug
14035
14036 log_info ("Hashtype: %s", hash_type);
14037 log_info ("Workload: %u loops, %u accel", gpu_loops, gpu_accel);
14038 log_info ("");
14039 }
14040
14041 /**
14042 * keep track of the progress
14043 */
14044
14045 data.words_progress_done = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
14046 data.words_progress_rejected = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
14047 data.words_progress_restored = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
14048
14049 /**
14050 * open filehandles
14051 */
14052
14053 #if _WIN
14054 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14055 {
14056 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14057
14058 return (-1);
14059 }
14060
14061 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14062 {
14063 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14064
14065 return (-1);
14066 }
14067
14068 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14069 {
14070 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14071
14072 return (-1);
14073 }
14074 #endif
14075
14076 /**
14077 * dictionary pad
14078 */
14079
14080 segment_size *= (1024 * 1024);
14081
14082 data.segment_size = segment_size;
14083
14084 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14085
14086 wl_data->buf = (char *) mymalloc (segment_size);
14087 wl_data->avail = segment_size;
14088 wl_data->incr = segment_size;
14089 wl_data->cnt = 0;
14090 wl_data->pos = 0;
14091
14092 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14093
14094 data.wordlist_mode = wordlist_mode;
14095
14096 cs_t *css_buf = NULL;
14097 uint css_cnt = 0;
14098 uint dictcnt = 0;
14099 uint maskcnt = 1;
14100 char **masks = NULL;
14101 char **dictfiles = NULL;
14102
14103 uint mask_from_file = 0;
14104
14105 if (attack_mode == ATTACK_MODE_STRAIGHT)
14106 {
14107 if (wordlist_mode == WL_MODE_FILE)
14108 {
14109 int wls_left = myargc - (optind + 1);
14110
14111 for (int i = 0; i < wls_left; i++)
14112 {
14113 char *l0_filename = myargv[optind + 1 + i];
14114
14115 struct stat l0_stat;
14116
14117 if (stat (l0_filename, &l0_stat) == -1)
14118 {
14119 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14120
14121 return (-1);
14122 }
14123
14124 uint is_dir = S_ISDIR (l0_stat.st_mode);
14125
14126 if (is_dir == 0)
14127 {
14128 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14129
14130 dictcnt++;
14131
14132 dictfiles[dictcnt - 1] = l0_filename;
14133 }
14134 else
14135 {
14136 // do not allow --keyspace w/ a directory
14137
14138 if (keyspace == 1)
14139 {
14140 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14141
14142 return (-1);
14143 }
14144
14145 char **dictionary_files = NULL;
14146
14147 dictionary_files = scan_directory (l0_filename);
14148
14149 if (dictionary_files != NULL)
14150 {
14151 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14152
14153 for (int d = 0; dictionary_files[d] != NULL; d++)
14154 {
14155 char *l1_filename = dictionary_files[d];
14156
14157 struct stat l1_stat;
14158
14159 if (stat (l1_filename, &l1_stat) == -1)
14160 {
14161 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14162
14163 return (-1);
14164 }
14165
14166 if (S_ISREG (l1_stat.st_mode))
14167 {
14168 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14169
14170 dictcnt++;
14171
14172 dictfiles[dictcnt - 1] = strdup (l1_filename);
14173 }
14174 }
14175 }
14176
14177 local_free (dictionary_files);
14178 }
14179 }
14180
14181 if (dictcnt < 1)
14182 {
14183 log_error ("ERROR: No usable dictionary file found.");
14184
14185 return (-1);
14186 }
14187 }
14188 else if (wordlist_mode == WL_MODE_STDIN)
14189 {
14190 dictcnt = 1;
14191 }
14192 }
14193 else if (attack_mode == ATTACK_MODE_COMBI)
14194 {
14195 // display
14196
14197 char *dictfile1 = myargv[optind + 1 + 0];
14198 char *dictfile2 = myargv[optind + 1 + 1];
14199
14200 // find the bigger dictionary and use as base
14201
14202 FILE *fp1;
14203 FILE *fp2;
14204
14205 struct stat tmp_stat;
14206
14207 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14208 {
14209 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14210
14211 return (-1);
14212 }
14213
14214 if (stat (dictfile1, &tmp_stat) == -1)
14215 {
14216 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14217
14218 fclose (fp1);
14219
14220 return (-1);
14221 }
14222
14223 if (S_ISDIR (tmp_stat.st_mode))
14224 {
14225 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14226
14227 fclose (fp1);
14228
14229 return (-1);
14230 }
14231
14232 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14233 {
14234 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14235
14236 fclose (fp1);
14237
14238 return (-1);
14239 }
14240
14241 if (stat (dictfile2, &tmp_stat) == -1)
14242 {
14243 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14244
14245 fclose (fp1);
14246 fclose (fp2);
14247
14248 return (-1);
14249 }
14250
14251 if (S_ISDIR (tmp_stat.st_mode))
14252 {
14253 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14254
14255 fclose (fp1);
14256 fclose (fp2);
14257
14258 return (-1);
14259 }
14260
14261 data.combs_cnt = 1;
14262
14263 data.quiet = 1;
14264
14265 const uint64_t words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14266
14267 data.quiet = quiet;
14268
14269 if (words1_cnt == 0)
14270 {
14271 log_error ("ERROR: %s: empty file", dictfile1);
14272
14273 fclose (fp1);
14274 fclose (fp2);
14275
14276 return (-1);
14277 }
14278
14279 data.combs_cnt = 1;
14280
14281 data.quiet = 1;
14282
14283 const uint64_t words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14284
14285 data.quiet = quiet;
14286
14287 if (words2_cnt == 0)
14288 {
14289 log_error ("ERROR: %s: empty file", dictfile2);
14290
14291 fclose (fp1);
14292 fclose (fp2);
14293
14294 return (-1);
14295 }
14296
14297 fclose (fp1);
14298 fclose (fp2);
14299
14300 data.dictfile = dictfile1;
14301 data.dictfile2 = dictfile2;
14302
14303 if (words1_cnt >= words2_cnt)
14304 {
14305 data.combs_cnt = words2_cnt;
14306 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14307
14308 dictfiles = &data.dictfile;
14309
14310 dictcnt = 1;
14311 }
14312 else
14313 {
14314 data.combs_cnt = words1_cnt;
14315 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14316
14317 dictfiles = &data.dictfile2;
14318
14319 dictcnt = 1;
14320
14321 // we also have to switch wordlist related rules!
14322
14323 char *tmpc = data.rule_buf_l;
14324
14325 data.rule_buf_l = data.rule_buf_r;
14326 data.rule_buf_r = tmpc;
14327
14328 int tmpi = data.rule_len_l;
14329
14330 data.rule_len_l = data.rule_len_r;
14331 data.rule_len_r = tmpi;
14332 }
14333 }
14334 else if (attack_mode == ATTACK_MODE_BF)
14335 {
14336 char *mask = NULL;
14337
14338 maskcnt = 0;
14339
14340 if (benchmark == 0)
14341 {
14342 mask = myargv[optind + 1];
14343
14344 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
14345
14346 if ((optind + 2) <= myargc)
14347 {
14348 struct stat file_stat;
14349
14350 if (stat (mask, &file_stat) == -1)
14351 {
14352 maskcnt = 1;
14353
14354 masks[maskcnt - 1] = mystrdup (mask);
14355 }
14356 else
14357 {
14358 int wls_left = myargc - (optind + 1);
14359
14360 uint masks_avail = INCR_MASKS;
14361
14362 for (int i = 0; i < wls_left; i++)
14363 {
14364 if (i != 0)
14365 {
14366 mask = myargv[optind + 1 + i];
14367
14368 if (stat (mask, &file_stat) == -1)
14369 {
14370 log_error ("ERROR: %s: %s", mask, strerror (errno));
14371
14372 return (-1);
14373 }
14374 }
14375
14376 uint is_file = S_ISREG (file_stat.st_mode);
14377
14378 if (is_file == 1)
14379 {
14380 FILE *mask_fp;
14381
14382 if ((mask_fp = fopen (mask, "r")) == NULL)
14383 {
14384 log_error ("ERROR: %s: %s", mask, strerror (errno));
14385
14386 return (-1);
14387 }
14388
14389 char line_buf[BUFSIZ];
14390
14391 while (!feof (mask_fp))
14392 {
14393 memset (line_buf, 0, BUFSIZ);
14394
14395 int line_len = fgetl (mask_fp, line_buf);
14396
14397 if (line_len == 0) continue;
14398
14399 if (line_buf[0] == '#') continue;
14400
14401 if (masks_avail == maskcnt)
14402 {
14403 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14404
14405 masks_avail += INCR_MASKS;
14406 }
14407
14408 masks[maskcnt] = mystrdup (line_buf);
14409
14410 maskcnt++;
14411 }
14412
14413 fclose (mask_fp);
14414 }
14415 else
14416 {
14417 log_error ("ERROR: %s: unsupported file-type", mask);
14418
14419 return (-1);
14420 }
14421 }
14422
14423 mask_from_file = 1;
14424 }
14425 }
14426 else
14427 {
14428 custom_charset_1 = (char *) "?l?d?u";
14429 custom_charset_2 = (char *) "?l?d";
14430 custom_charset_3 = (char *) "?l?d*!$@_";
14431
14432 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
14433 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
14434 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
14435
14436 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
14437
14438 wordlist_mode = WL_MODE_MASK;
14439
14440 data.wordlist_mode = wordlist_mode;
14441
14442 increment = 1;
14443
14444 maskcnt = 1;
14445 }
14446 }
14447 else
14448 {
14449 /**
14450 * generate full masks and charsets
14451 */
14452
14453 masks = (char **) mymalloc (sizeof (char *));
14454
14455 switch (hash_mode)
14456 {
14457 case 1731: pw_min = 5;
14458 pw_max = 5;
14459 mask = mystrdup ("?b?b?b?b?b");
14460 break;
14461 case 12500: pw_min = 5;
14462 pw_max = 5;
14463 mask = mystrdup ("?b?b?b?b?b");
14464 break;
14465 default: pw_min = 7;
14466 pw_max = 7;
14467 mask = mystrdup ("?b?b?b?b?b?b?b");
14468 break;
14469 }
14470
14471 maskcnt = 1;
14472
14473 masks[maskcnt - 1] = mystrdup (mask);
14474
14475 wordlist_mode = WL_MODE_MASK;
14476
14477 data.wordlist_mode = wordlist_mode;
14478
14479 increment = 1;
14480 }
14481
14482 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
14483
14484 if (increment)
14485 {
14486 if (increment_min > pw_min) pw_min = increment_min;
14487
14488 if (increment_max < pw_max) pw_max = increment_max;
14489 }
14490 }
14491 else if (attack_mode == ATTACK_MODE_HYBRID1)
14492 {
14493 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14494
14495 // display
14496
14497 char *mask = myargv[myargc - 1];
14498
14499 maskcnt = 0;
14500
14501 masks = (char **) mymalloc (1 * sizeof (char *));
14502
14503 // mod
14504
14505 struct stat file_stat;
14506
14507 if (stat (mask, &file_stat) == -1)
14508 {
14509 maskcnt = 1;
14510
14511 masks[maskcnt - 1] = mystrdup (mask);
14512 }
14513 else
14514 {
14515 uint is_file = S_ISREG (file_stat.st_mode);
14516
14517 if (is_file == 1)
14518 {
14519 FILE *mask_fp;
14520
14521 if ((mask_fp = fopen (mask, "r")) == NULL)
14522 {
14523 log_error ("ERROR: %s: %s", mask, strerror (errno));
14524
14525 return (-1);
14526 }
14527
14528 char line_buf[BUFSIZ];
14529
14530 uint masks_avail = 1;
14531
14532 while (!feof (mask_fp))
14533 {
14534 memset (line_buf, 0, BUFSIZ);
14535
14536 int line_len = fgetl (mask_fp, line_buf);
14537
14538 if (line_len == 0) continue;
14539
14540 if (line_buf[0] == '#') continue;
14541
14542 if (masks_avail == maskcnt)
14543 {
14544 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14545
14546 masks_avail += INCR_MASKS;
14547 }
14548
14549 masks[maskcnt] = mystrdup (line_buf);
14550
14551 maskcnt++;
14552 }
14553
14554 fclose (mask_fp);
14555
14556 mask_from_file = 1;
14557 }
14558 else
14559 {
14560 maskcnt = 1;
14561
14562 masks[maskcnt - 1] = mystrdup (mask);
14563 }
14564 }
14565
14566 // base
14567
14568 int wls_left = myargc - (optind + 2);
14569
14570 for (int i = 0; i < wls_left; i++)
14571 {
14572 char *filename = myargv[optind + 1 + i];
14573
14574 struct stat file_stat;
14575
14576 if (stat (filename, &file_stat) == -1)
14577 {
14578 log_error ("ERROR: %s: %s", filename, strerror (errno));
14579
14580 return (-1);
14581 }
14582
14583 uint is_dir = S_ISDIR (file_stat.st_mode);
14584
14585 if (is_dir == 0)
14586 {
14587 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14588
14589 dictcnt++;
14590
14591 dictfiles[dictcnt - 1] = filename;
14592 }
14593 else
14594 {
14595 // do not allow --keyspace w/ a directory
14596
14597 if (keyspace == 1)
14598 {
14599 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14600
14601 return (-1);
14602 }
14603
14604 char **dictionary_files = NULL;
14605
14606 dictionary_files = scan_directory (filename);
14607
14608 if (dictionary_files != NULL)
14609 {
14610 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14611
14612 for (int d = 0; dictionary_files[d] != NULL; d++)
14613 {
14614 char *l1_filename = dictionary_files[d];
14615
14616 struct stat l1_stat;
14617
14618 if (stat (l1_filename, &l1_stat) == -1)
14619 {
14620 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14621
14622 return (-1);
14623 }
14624
14625 if (S_ISREG (l1_stat.st_mode))
14626 {
14627 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14628
14629 dictcnt++;
14630
14631 dictfiles[dictcnt - 1] = strdup (l1_filename);
14632 }
14633 }
14634 }
14635
14636 local_free (dictionary_files);
14637 }
14638 }
14639
14640 if (dictcnt < 1)
14641 {
14642 log_error ("ERROR: No usable dictionary file found.");
14643
14644 return (-1);
14645 }
14646
14647 if (increment)
14648 {
14649 maskcnt = 0;
14650
14651 uint mask_min = increment_min; // we can't reject smaller masks here
14652 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
14653
14654 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
14655 {
14656 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
14657
14658 if (cur_mask == NULL) break;
14659
14660 masks[maskcnt] = cur_mask;
14661
14662 maskcnt++;
14663
14664 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
14665 }
14666 }
14667 }
14668 else if (attack_mode == ATTACK_MODE_HYBRID2)
14669 {
14670 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14671
14672 // display
14673
14674 char *mask = myargv[optind + 1 + 0];
14675
14676 maskcnt = 0;
14677
14678 masks = (char **) mymalloc (1 * sizeof (char *));
14679
14680 // mod
14681
14682 struct stat file_stat;
14683
14684 if (stat (mask, &file_stat) == -1)
14685 {
14686 maskcnt = 1;
14687
14688 masks[maskcnt - 1] = mystrdup (mask);
14689 }
14690 else
14691 {
14692 uint is_file = S_ISREG (file_stat.st_mode);
14693
14694 if (is_file == 1)
14695 {
14696 FILE *mask_fp;
14697
14698 if ((mask_fp = fopen (mask, "r")) == NULL)
14699 {
14700 log_error ("ERROR: %s: %s", mask, strerror (errno));
14701
14702 return (-1);
14703 }
14704
14705 char line_buf[BUFSIZ];
14706
14707 uint masks_avail = 1;
14708
14709 while (!feof (mask_fp))
14710 {
14711 memset (line_buf, 0, BUFSIZ);
14712
14713 int line_len = fgetl (mask_fp, line_buf);
14714
14715 if (line_len == 0) continue;
14716
14717 if (line_buf[0] == '#') continue;
14718
14719 if (masks_avail == maskcnt)
14720 {
14721 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14722
14723 masks_avail += INCR_MASKS;
14724 }
14725
14726 masks[maskcnt] = mystrdup (line_buf);
14727
14728 maskcnt++;
14729 }
14730
14731 fclose (mask_fp);
14732
14733 mask_from_file = 1;
14734 }
14735 else
14736 {
14737 maskcnt = 1;
14738
14739 masks[maskcnt - 1] = mystrdup (mask);
14740 }
14741 }
14742
14743 // base
14744
14745 int wls_left = myargc - (optind + 2);
14746
14747 for (int i = 0; i < wls_left; i++)
14748 {
14749 char *filename = myargv[optind + 2 + i];
14750
14751 struct stat file_stat;
14752
14753 if (stat (filename, &file_stat) == -1)
14754 {
14755 log_error ("ERROR: %s: %s", filename, strerror (errno));
14756
14757 return (-1);
14758 }
14759
14760 uint is_dir = S_ISDIR (file_stat.st_mode);
14761
14762 if (is_dir == 0)
14763 {
14764 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14765
14766 dictcnt++;
14767
14768 dictfiles[dictcnt - 1] = filename;
14769 }
14770 else
14771 {
14772 // do not allow --keyspace w/ a directory
14773
14774 if (keyspace == 1)
14775 {
14776 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14777
14778 return (-1);
14779 }
14780
14781 char **dictionary_files = NULL;
14782
14783 dictionary_files = scan_directory (filename);
14784
14785 if (dictionary_files != NULL)
14786 {
14787 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14788
14789 for (int d = 0; dictionary_files[d] != NULL; d++)
14790 {
14791 char *l1_filename = dictionary_files[d];
14792
14793 struct stat l1_stat;
14794
14795 if (stat (l1_filename, &l1_stat) == -1)
14796 {
14797 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14798
14799 return (-1);
14800 }
14801
14802 if (S_ISREG (l1_stat.st_mode))
14803 {
14804 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14805
14806 dictcnt++;
14807
14808 dictfiles[dictcnt - 1] = strdup (l1_filename);
14809 }
14810 }
14811 }
14812
14813 local_free (dictionary_files);
14814 }
14815 }
14816
14817 if (dictcnt < 1)
14818 {
14819 log_error ("ERROR: No usable dictionary file found.");
14820
14821 return (-1);
14822 }
14823
14824 if (increment)
14825 {
14826 maskcnt = 0;
14827
14828 uint mask_min = increment_min; // we can't reject smaller masks here
14829 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
14830
14831 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
14832 {
14833 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
14834
14835 if (cur_mask == NULL) break;
14836
14837 masks[maskcnt] = cur_mask;
14838
14839 maskcnt++;
14840
14841 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
14842 }
14843 }
14844 }
14845
14846 data.pw_min = pw_min;
14847 data.pw_max = pw_max;
14848
14849 /**
14850 * weak hash check
14851 */
14852
14853 if (weak_hash_threshold >= salts_cnt)
14854 {
14855 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
14856
14857 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
14858 {
14859 weak_hash_check (&data.devices_param[0], salt_pos, gpu_loops);
14860 }
14861 }
14862
14863 // Display hack, guarantee that there is at least one \r before real start
14864
14865 if (data.quiet == 0) log_info_nn ("");
14866
14867 /**
14868 * status and monitor threads
14869 */
14870
14871 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
14872
14873 hc_thread_t i_thread = 0;
14874
14875 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
14876 {
14877 hc_thread_create (i_thread, thread_keypress, &benchmark);
14878 }
14879
14880 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
14881
14882 uint ni_threads_cnt = 0;
14883
14884 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
14885
14886 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
14887
14888 ni_threads_cnt++;
14889
14890 /**
14891 * Outfile remove
14892 */
14893
14894 if (keyspace == 0)
14895 {
14896 if (outfile_check_timer != 0)
14897 {
14898 if (data.outfile_check_directory != NULL)
14899 {
14900 if ((hash_mode != 5200) &&
14901 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
14902 (hash_mode != 9000))
14903 {
14904 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
14905
14906 ni_threads_cnt++;
14907 }
14908 else
14909 {
14910 outfile_check_timer = 0;
14911 }
14912 }
14913 else
14914 {
14915 outfile_check_timer = 0;
14916 }
14917 }
14918 }
14919
14920 /**
14921 * Inform the user if we got some hashes remove because of the pot file remove feature
14922 */
14923
14924 if (data.quiet == 0)
14925 {
14926 if (potfile_remove_cracks > 0)
14927 {
14928 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
14929 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
14930 }
14931 }
14932
14933 data.outfile_check_timer = outfile_check_timer;
14934
14935 /**
14936 * main loop
14937 */
14938
14939 char **induction_dictionaries = NULL;
14940
14941 int induction_dictionaries_cnt = 0;
14942
14943 hcstat_table_t *root_table_buf = NULL;
14944 hcstat_table_t *markov_table_buf = NULL;
14945
14946 uint initial_restore_done = 0;
14947
14948 data.maskcnt = maskcnt;
14949
14950 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
14951 {
14952 if (data.devices_status == STATUS_CRACKED) break;
14953
14954 data.devices_status = STATUS_INIT;
14955
14956 if (maskpos > rd->maskpos)
14957 {
14958 rd->dictpos = 0;
14959 }
14960
14961 rd->maskpos = maskpos;
14962 data.maskpos = maskpos;
14963
14964 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
14965 {
14966 char *mask = masks[maskpos];
14967
14968 if (mask_from_file == 1)
14969 {
14970 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
14971
14972 char *str_ptr;
14973 uint str_pos;
14974
14975 uint mask_offset = 0;
14976
14977 uint separator_cnt;
14978
14979 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
14980 {
14981 str_ptr = strstr (mask + mask_offset, ",");
14982
14983 if (str_ptr == NULL) break;
14984
14985 str_pos = str_ptr - mask;
14986
14987 // escaped separator, i.e. "\,"
14988
14989 if (str_pos > 0)
14990 {
14991 if (mask[str_pos - 1] == '\\')
14992 {
14993 separator_cnt --;
14994
14995 mask_offset = str_pos + 1;
14996
14997 continue;
14998 }
14999 }
15000
15001 // reset the offset
15002
15003 mask_offset = 0;
15004
15005 mask[str_pos] = '\0';
15006
15007 switch (separator_cnt)
15008 {
15009 case 0:
15010 mp_reset_usr (mp_usr, 0);
15011
15012 custom_charset_1 = mask;
15013 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15014 break;
15015
15016 case 1:
15017 mp_reset_usr (mp_usr, 1);
15018
15019 custom_charset_2 = mask;
15020 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15021 break;
15022
15023 case 2:
15024 mp_reset_usr (mp_usr, 2);
15025
15026 custom_charset_3 = mask;
15027 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15028 break;
15029
15030 case 3:
15031 mp_reset_usr (mp_usr, 3);
15032
15033 custom_charset_4 = mask;
15034 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15035 break;
15036 }
15037
15038 mask = mask + str_pos + 1;
15039 }
15040 }
15041
15042 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15043 {
15044 if (maskpos > 0)
15045 {
15046 local_free (css_buf);
15047 local_free (data.root_css_buf);
15048 local_free (data.markov_css_buf);
15049
15050 local_free (masks[maskpos - 1]);
15051 }
15052
15053 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15054
15055 data.mask = mask;
15056 data.css_cnt = css_cnt;
15057 data.css_buf = css_buf;
15058
15059 uint uniq_tbls[SP_PW_MAX][CHARSIZ];
15060
15061 memset (uniq_tbls, 0, sizeof (uniq_tbls));
15062
15063 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15064
15065 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15066 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15067
15068 sp_setup_tbl (install_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15069
15070 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15071
15072 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15073 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15074
15075 data.root_css_buf = root_css_buf;
15076 data.markov_css_buf = markov_css_buf;
15077
15078 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15079
15080 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15081
15082 local_free (root_table_buf);
15083 local_free (markov_table_buf);
15084
15085 // args
15086
15087 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15088 {
15089 hc_device_param_t *device_param = &data.devices_param[device_id];
15090
15091 device_param->kernel_params_mp[0] = &device_param->d_combs;
15092 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15093 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15094
15095 device_param->kernel_params_mp_buf64[3] = 0;
15096 device_param->kernel_params_mp_buf32[4] = css_cnt;
15097 device_param->kernel_params_mp_buf32[5] = 0;
15098 device_param->kernel_params_mp_buf32[6] = 0;
15099 device_param->kernel_params_mp_buf32[7] = 0;
15100
15101 if (attack_mode == ATTACK_MODE_HYBRID1)
15102 {
15103 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15104 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15105 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15106 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15107 }
15108 else if (attack_mode == ATTACK_MODE_HYBRID2)
15109 {
15110 device_param->kernel_params_mp_buf32[5] = 0;
15111 device_param->kernel_params_mp_buf32[6] = 0;
15112 device_param->kernel_params_mp_buf32[7] = 0;
15113 }
15114
15115 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp[i]);
15116 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp[i]);
15117 for (uint i = 4; i < 8; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp[i]);
15118
15119 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);
15120 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);
15121 }
15122 }
15123 else if (attack_mode == ATTACK_MODE_BF)
15124 {
15125 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15126
15127 if (increment)
15128 {
15129 for (uint i = 0; i < dictcnt; i++)
15130 {
15131 local_free (dictfiles[i]);
15132 }
15133
15134 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15135 {
15136 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15137
15138 if (l1_filename == NULL) break;
15139
15140 dictcnt++;
15141
15142 dictfiles[dictcnt - 1] = l1_filename;
15143 }
15144 }
15145 else
15146 {
15147 dictcnt++;
15148
15149 dictfiles[dictcnt - 1] = mask;
15150 }
15151
15152 if (dictcnt == 0)
15153 {
15154 log_error ("ERROR: Mask is too small");
15155
15156 return (-1);
15157 }
15158 }
15159 }
15160
15161 free (induction_dictionaries);
15162
15163 // induction_dictionaries_cnt = 0; // implied
15164
15165 if (attack_mode != ATTACK_MODE_BF)
15166 {
15167 if (keyspace == 0)
15168 {
15169 induction_dictionaries = scan_directory (induction_directory);
15170
15171 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15172 }
15173 }
15174
15175 if (induction_dictionaries_cnt)
15176 {
15177 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15178 }
15179
15180 /**
15181 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15182 */
15183 if (keyspace == 1)
15184 {
15185 if ((maskcnt > 1) || (dictcnt > 1))
15186 {
15187 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15188
15189 return (-1);
15190 }
15191 }
15192
15193 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15194 {
15195 char *subid = logfile_generate_subid ();
15196
15197 data.subid = subid;
15198
15199 logfile_sub_msg ("START");
15200
15201 data.devices_status = STATUS_INIT;
15202
15203 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (uint64_t));
15204 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (uint64_t));
15205 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (uint64_t));
15206
15207 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15208
15209 data.cpt_pos = 0;
15210
15211 data.cpt_start = time (NULL);
15212
15213 data.cpt_total = 0;
15214
15215 if (data.restore == 0)
15216 {
15217 rd->words_cur = skip;
15218
15219 skip = 0;
15220
15221 data.skip = 0;
15222 }
15223
15224 data.ms_paused = 0;
15225
15226 data.words_cur = rd->words_cur;
15227
15228 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15229 {
15230 hc_device_param_t *device_param = &data.devices_param[device_id];
15231
15232 device_param->speed_pos = 0;
15233
15234 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (uint64_t));
15235 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15236 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15237
15238 device_param->gpu_power = device_param->gpu_power_user;
15239 device_param->gpu_blocks = device_param->gpu_blocks_user;
15240
15241 device_param->outerloop_pos = 0;
15242 device_param->outerloop_left = 0;
15243 device_param->innerloop_pos = 0;
15244 device_param->innerloop_left = 0;
15245
15246 // some more resets:
15247
15248 memset (device_param->pw_caches, 0, 64 * sizeof (pw_cache_t));
15249
15250 memset (device_param->pws_buf, 0, device_param->size_pws);
15251
15252 device_param->pw_cnt = 0;
15253 device_param->pws_cnt = 0;
15254
15255 device_param->words_off = 0;
15256 device_param->words_done = 0;
15257 }
15258
15259 data.gpu_blocks_div = 0;
15260
15261 // figure out some workload
15262
15263 if (attack_mode == ATTACK_MODE_STRAIGHT)
15264 {
15265 if (data.wordlist_mode == WL_MODE_FILE)
15266 {
15267 char *dictfile = NULL;
15268
15269 if (induction_dictionaries_cnt)
15270 {
15271 dictfile = induction_dictionaries[0];
15272 }
15273 else
15274 {
15275 dictfile = dictfiles[dictpos];
15276 }
15277
15278 data.dictfile = dictfile;
15279
15280 logfile_sub_string (dictfile);
15281
15282 for (uint i = 0; i < rp_files_cnt; i++)
15283 {
15284 logfile_sub_var_string ("rulefile", rp_files[i]);
15285 }
15286
15287 FILE *fd2 = fopen (dictfile, "rb");
15288
15289 if (fd2 == NULL)
15290 {
15291 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15292
15293 return (-1);
15294 }
15295
15296 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15297
15298 fclose (fd2);
15299
15300 if (data.words_cnt == 0)
15301 {
15302 if (data.devices_status == STATUS_CRACKED) break;
15303 if (data.devices_status == STATUS_ABORTED) break;
15304
15305 dictpos++;
15306
15307 continue;
15308 }
15309 }
15310 }
15311 else if (attack_mode == ATTACK_MODE_COMBI)
15312 {
15313 char *dictfile = data.dictfile;
15314 char *dictfile2 = data.dictfile2;
15315
15316 logfile_sub_string (dictfile);
15317 logfile_sub_string (dictfile2);
15318
15319 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
15320 {
15321 FILE *fd2 = fopen (dictfile, "rb");
15322
15323 if (fd2 == NULL)
15324 {
15325 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15326
15327 return (-1);
15328 }
15329
15330 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15331
15332 fclose (fd2);
15333 }
15334 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
15335 {
15336 FILE *fd2 = fopen (dictfile2, "rb");
15337
15338 if (fd2 == NULL)
15339 {
15340 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15341
15342 return (-1);
15343 }
15344
15345 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
15346
15347 fclose (fd2);
15348 }
15349
15350 if (data.words_cnt == 0)
15351 {
15352 if (data.devices_status == STATUS_CRACKED) break;
15353 if (data.devices_status == STATUS_ABORTED) break;
15354
15355 dictpos++;
15356
15357 continue;
15358 }
15359 }
15360 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15361 {
15362 char *dictfile = NULL;
15363
15364 if (induction_dictionaries_cnt)
15365 {
15366 dictfile = induction_dictionaries[0];
15367 }
15368 else
15369 {
15370 dictfile = dictfiles[dictpos];
15371 }
15372
15373 data.dictfile = dictfile;
15374
15375 char *mask = data.mask;
15376
15377 logfile_sub_string (dictfile);
15378 logfile_sub_string (mask);
15379
15380 FILE *fd2 = fopen (dictfile, "rb");
15381
15382 if (fd2 == NULL)
15383 {
15384 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15385
15386 return (-1);
15387 }
15388
15389 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15390
15391 fclose (fd2);
15392
15393 if (data.words_cnt == 0)
15394 {
15395 if (data.devices_status == STATUS_CRACKED) break;
15396 if (data.devices_status == STATUS_ABORTED) break;
15397
15398 dictpos++;
15399
15400 continue;
15401 }
15402 }
15403 else if (attack_mode == ATTACK_MODE_BF)
15404 {
15405 local_free (css_buf);
15406 local_free (data.root_css_buf);
15407 local_free (data.markov_css_buf);
15408
15409 char *mask = dictfiles[dictpos];
15410
15411 logfile_sub_string (mask);
15412
15413 // base
15414
15415 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15416
15417 if (opts_type & OPTS_TYPE_PT_UNICODE)
15418 {
15419 uint css_cnt_unicode = css_cnt * 2;
15420
15421 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
15422
15423 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
15424 {
15425 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
15426
15427 css_buf_unicode[j + 1].cs_buf[0] = 0;
15428 css_buf_unicode[j + 1].cs_len = 1;
15429 }
15430
15431 free (css_buf);
15432
15433 css_buf = css_buf_unicode;
15434 css_cnt = css_cnt_unicode;
15435 }
15436
15437 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
15438
15439 uint mask_min = pw_min;
15440 uint mask_max = pw_max;
15441
15442 if (opts_type & OPTS_TYPE_PT_UNICODE)
15443 {
15444 mask_min *= 2;
15445 mask_max *= 2;
15446 }
15447
15448 if ((css_cnt < mask_min) || (css_cnt > mask_max))
15449 {
15450 if (css_cnt < mask_min)
15451 {
15452 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
15453 }
15454
15455 if (css_cnt > mask_max)
15456 {
15457 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
15458 }
15459
15460 // skip to next mask
15461
15462 dictpos++;
15463
15464 rd->dictpos = dictpos;
15465
15466 logfile_sub_msg ("STOP");
15467
15468 continue;
15469 }
15470
15471 uint save_css_cnt = css_cnt;
15472
15473 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15474 {
15475 if (opti_type & OPTI_TYPE_APPENDED_SALT)
15476 {
15477 uint salt_len = (uint) data.salts_buf[0].salt_len;
15478 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
15479
15480 uint css_cnt_salt = css_cnt + salt_len;
15481
15482 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
15483
15484 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
15485
15486 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
15487 {
15488 css_buf_salt[j].cs_buf[0] = salt_buf[i];
15489 css_buf_salt[j].cs_len = 1;
15490 }
15491
15492 free (css_buf);
15493
15494 css_buf = css_buf_salt;
15495 css_cnt = css_cnt_salt;
15496 }
15497 }
15498
15499 data.mask = mask;
15500 data.css_cnt = css_cnt;
15501 data.css_buf = css_buf;
15502
15503 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
15504
15505 uint uniq_tbls[SP_PW_MAX][CHARSIZ];
15506
15507 memset (uniq_tbls, 0, sizeof (uniq_tbls));
15508
15509 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15510
15511 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15512 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15513
15514 sp_setup_tbl (install_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15515
15516 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15517
15518 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15519 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15520
15521 data.root_css_buf = root_css_buf;
15522 data.markov_css_buf = markov_css_buf;
15523
15524 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15525
15526 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15527
15528 local_free (root_table_buf);
15529 local_free (markov_table_buf);
15530
15531 // copy + args
15532
15533 uint css_cnt_l = css_cnt;
15534 uint css_cnt_r;
15535
15536 if (attack_exec == ATTACK_EXEC_ON_GPU)
15537 {
15538 if (save_css_cnt < 6)
15539 {
15540 css_cnt_r = 1;
15541 }
15542 else if (save_css_cnt == 6)
15543 {
15544 css_cnt_r = 2;
15545 }
15546 else
15547 {
15548 if (opts_type & OPTS_TYPE_PT_UNICODE)
15549 {
15550 if (save_css_cnt == 8 || save_css_cnt == 10)
15551 {
15552 css_cnt_r = 2;
15553 }
15554 else
15555 {
15556 css_cnt_r = 4;
15557 }
15558 }
15559 else
15560 {
15561 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
15562 {
15563 css_cnt_r = 3;
15564 }
15565 else
15566 {
15567 css_cnt_r = 4;
15568 }
15569 }
15570 }
15571 }
15572 else
15573 {
15574 css_cnt_r = 1;
15575
15576 /* unfinished code?
15577 int sum = css_buf[css_cnt_r - 1].cs_len;
15578
15579 for (uint i = 1; i < 4 && i < css_cnt; i++)
15580 {
15581 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
15582
15583 css_cnt_r++;
15584
15585 sum *= css_buf[css_cnt_r - 1].cs_len;
15586 }
15587 */
15588 }
15589
15590 css_cnt_l -= css_cnt_r;
15591
15592 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
15593
15594 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15595 {
15596 hc_device_param_t *device_param = &data.devices_param[device_id];
15597
15598 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
15599 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
15600 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
15601
15602 device_param->kernel_params_mp_l_buf64[3] = 0;
15603 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
15604 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
15605 device_param->kernel_params_mp_l_buf32[6] = 0;
15606 device_param->kernel_params_mp_l_buf32[7] = 0;
15607 device_param->kernel_params_mp_l_buf32[8] = 0;
15608
15609 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
15610 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
15611 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
15612 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
15613
15614 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
15615 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
15616 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
15617
15618 device_param->kernel_params_mp_r_buf64[3] = 0;
15619 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
15620 device_param->kernel_params_mp_r_buf32[5] = 0;
15621 device_param->kernel_params_mp_r_buf32[6] = 0;
15622 device_param->kernel_params_mp_r_buf32[7] = 0;
15623
15624 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]);
15625 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]);
15626 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]);
15627
15628 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]);
15629 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]);
15630 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]);
15631
15632 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);
15633 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);
15634 }
15635 }
15636
15637 uint64_t words_base = data.words_cnt;
15638
15639 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
15640 {
15641 if (data.gpu_rules_cnt)
15642 {
15643 words_base /= data.gpu_rules_cnt;
15644 }
15645 }
15646 else if (data.attack_kern == ATTACK_KERN_COMBI)
15647 {
15648 if (data.combs_cnt)
15649 {
15650 words_base /= data.combs_cnt;
15651 }
15652 }
15653 else if (data.attack_kern == ATTACK_KERN_BF)
15654 {
15655 if (data.bfs_cnt)
15656 {
15657 words_base /= data.bfs_cnt;
15658 }
15659 }
15660
15661 data.words_base = words_base;
15662
15663 if (keyspace == 1)
15664 {
15665 log_info ("%llu", (unsigned long long int) words_base);
15666
15667 return (0);
15668 }
15669
15670 if (data.words_cur > data.words_base)
15671 {
15672 log_error ("ERROR: restore value greater keyspace");
15673
15674 return (-1);
15675 }
15676
15677 if (data.words_cur)
15678 {
15679 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
15680 {
15681 for (uint i = 0; i < data.salts_cnt; i++)
15682 {
15683 data.words_progress_restored[i] = data.words_cur * data.gpu_rules_cnt;
15684 }
15685 }
15686 else if (data.attack_kern == ATTACK_KERN_COMBI)
15687 {
15688 for (uint i = 0; i < data.salts_cnt; i++)
15689 {
15690 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
15691 }
15692 }
15693 else if (data.attack_kern == ATTACK_KERN_BF)
15694 {
15695 for (uint i = 0; i < data.salts_cnt; i++)
15696 {
15697 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
15698 }
15699 }
15700 }
15701
15702 /*
15703 * Inform user about possible slow speeds
15704 */
15705
15706 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
15707 {
15708 if (data.words_base < gpu_blocks_all)
15709 {
15710 if (quiet == 0)
15711 {
15712 log_info ("");
15713 log_info ("ATTENTION!");
15714 log_info (" The wordlist or mask you are using is too small.");
15715 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your GPU(s).");
15716 log_info (" The cracking speed will drop.");
15717 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
15718 log_info ("");
15719 }
15720 }
15721 }
15722
15723 /*
15724 * Update loopback file
15725 */
15726
15727 if (loopback == 1)
15728 {
15729 time_t now;
15730
15731 time (&now);
15732
15733 uint random_num = get_random_num (0, 9999);
15734
15735 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
15736
15737 data.loopback_file = loopback_file;
15738 }
15739
15740 /*
15741 * Update dictionary statistic
15742 */
15743
15744 if (keyspace == 0)
15745 {
15746 dictstat_fp = fopen (dictstat, "wb");
15747
15748 if (dictstat_fp)
15749 {
15750 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
15751
15752 fclose (dictstat_fp);
15753 }
15754 }
15755
15756 data.devices_status = STATUS_RUNNING;
15757
15758 if (initial_restore_done == 0)
15759 {
15760 if (data.restore_disable == 0) cycle_restore ();
15761
15762 initial_restore_done = 1;
15763 }
15764
15765 hc_timer_set (&data.timer_running);
15766
15767 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
15768 {
15769 if ((quiet == 0) && (status == 0) && (benchmark == 0))
15770 {
15771 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
15772 if (quiet == 0) fflush (stdout);
15773 }
15774 }
15775 else if (wordlist_mode == WL_MODE_STDIN)
15776 {
15777 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
15778 if (data.quiet == 0) log_info ("");
15779 }
15780
15781 time_t runtime_start;
15782
15783 time (&runtime_start);
15784
15785 data.runtime_start = runtime_start;
15786
15787 /**
15788 * create cracker threads
15789 */
15790
15791 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (devices_cnt, sizeof (hc_thread_t));
15792
15793 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15794 {
15795 hc_device_param_t *device_param = &devices_param[device_id];
15796
15797 device_param->device_id = device_id;
15798
15799 if (wordlist_mode == WL_MODE_STDIN)
15800 {
15801 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
15802 }
15803 else
15804 {
15805 hc_thread_create (c_threads[device_id], thread_calc, device_param);
15806 }
15807 }
15808
15809 // wait for crack threads to exit
15810
15811 hc_thread_wait (devices_cnt, c_threads);
15812
15813 local_free (c_threads);
15814
15815 data.restore = 0;
15816
15817 // finalize task
15818
15819 logfile_sub_var_uint ("status-after-work", data.devices_status);
15820
15821 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
15822
15823 if (data.devices_status == STATUS_CRACKED) break;
15824 if (data.devices_status == STATUS_ABORTED) break;
15825
15826 if (data.devices_status == STATUS_BYPASS)
15827 {
15828 data.devices_status = STATUS_RUNNING;
15829 }
15830
15831 if (induction_dictionaries_cnt)
15832 {
15833 unlink (induction_dictionaries[0]);
15834 }
15835
15836 free (induction_dictionaries);
15837
15838 if (attack_mode != ATTACK_MODE_BF)
15839 {
15840 induction_dictionaries = scan_directory (induction_directory);
15841
15842 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15843 }
15844
15845 if (benchmark == 0)
15846 {
15847 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
15848 {
15849 if (quiet == 0) clear_prompt ();
15850
15851 if (quiet == 0) log_info ("");
15852
15853 if (status == 1)
15854 {
15855 status_display ();
15856 }
15857 else
15858 {
15859 if (quiet == 0) status_display ();
15860 }
15861
15862 if (quiet == 0) log_info ("");
15863 }
15864 }
15865
15866 if (attack_mode == ATTACK_MODE_BF)
15867 {
15868 dictpos++;
15869
15870 rd->dictpos = dictpos;
15871 }
15872 else
15873 {
15874 if (induction_dictionaries_cnt)
15875 {
15876 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15877 }
15878 else
15879 {
15880 dictpos++;
15881
15882 rd->dictpos = dictpos;
15883 }
15884 }
15885
15886 time_t runtime_stop;
15887
15888 time (&runtime_stop);
15889
15890 data.runtime_stop = runtime_stop;
15891
15892 logfile_sub_uint (runtime_start);
15893 logfile_sub_uint (runtime_stop);
15894
15895 logfile_sub_msg ("STOP");
15896
15897 global_free (subid);
15898 }
15899
15900 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
15901
15902 if (data.devices_status == STATUS_CRACKED) break;
15903 if (data.devices_status == STATUS_ABORTED) break;
15904 if (data.devices_status == STATUS_QUIT) break;
15905
15906 if (data.devices_status == STATUS_BYPASS)
15907 {
15908 data.devices_status = STATUS_RUNNING;
15909 }
15910 }
15911
15912 // 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
15913
15914 if (attack_mode == ATTACK_MODE_STRAIGHT)
15915 {
15916 if (data.wordlist_mode == WL_MODE_FILE)
15917 {
15918 if (data.dictfile == NULL)
15919 {
15920 if (dictfiles != NULL)
15921 {
15922 data.dictfile = dictfiles[0];
15923
15924 hc_timer_set (&data.timer_running);
15925 }
15926 }
15927 }
15928 }
15929 // NOTE: combi is okay because it is already set beforehand
15930 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
15931 {
15932 if (data.dictfile == NULL)
15933 {
15934 if (dictfiles != NULL)
15935 {
15936 hc_timer_set (&data.timer_running);
15937
15938 data.dictfile = dictfiles[0];
15939 }
15940 }
15941 }
15942 else if (attack_mode == ATTACK_MODE_BF)
15943 {
15944 if (data.mask == NULL)
15945 {
15946 hc_timer_set (&data.timer_running);
15947
15948 data.mask = masks[0];
15949 }
15950 }
15951
15952 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
15953 {
15954 data.devices_status = STATUS_EXHAUSTED;
15955 }
15956
15957 // if cracked / aborted remove last induction dictionary
15958
15959 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
15960 {
15961 struct stat induct_stat;
15962
15963 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
15964 {
15965 unlink (induction_dictionaries[file_pos]);
15966 }
15967 }
15968
15969 // wait for non-interactive threads
15970
15971 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
15972 {
15973 hc_thread_wait (1, &ni_threads[thread_idx]);
15974 }
15975
15976 local_free (ni_threads);
15977
15978 // wait for interactive threads
15979
15980 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15981 {
15982 hc_thread_wait (1, &i_thread);
15983 }
15984
15985 // we dont need restore file anymore
15986 if (data.restore_disable == 0)
15987 {
15988 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
15989 {
15990 unlink (eff_restore_file);
15991 unlink (new_restore_file);
15992 }
15993 else
15994 {
15995 cycle_restore ();
15996 }
15997 }
15998
15999 // finally save left hashes
16000
16001 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16002 {
16003 save_hash ();
16004 }
16005
16006 /**
16007 * Clean up
16008 */
16009
16010 if (benchmark == 1)
16011 {
16012 status_benchmark ();
16013
16014 log_info ("");
16015 }
16016 else
16017 {
16018 if (quiet == 0) clear_prompt ();
16019
16020 if (quiet == 0) log_info ("");
16021
16022 if (status == 1)
16023 {
16024 status_display ();
16025 }
16026 else
16027 {
16028 if (quiet == 0) status_display ();
16029 }
16030
16031 if (quiet == 0) log_info ("");
16032 }
16033
16034 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16035 {
16036 hc_device_param_t *device_param = &data.devices_param[device_id];
16037
16038 local_free (device_param->result);
16039
16040 local_free (device_param->pw_caches);
16041
16042 local_free (device_param->combs_buf);
16043
16044 local_free (device_param->hooks_buf);
16045
16046 local_free (device_param->device_name);
16047
16048 local_free (device_param->device_version);
16049
16050 local_free (device_param->driver_version);
16051
16052 if (device_param->pws_buf) myfree (device_param->pws_buf);
16053 if (device_param->d_pws_buf) hc_clReleaseMemObject (device_param->d_pws_buf);
16054 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (device_param->d_pws_amp_buf);
16055 if (device_param->d_rules) hc_clReleaseMemObject (device_param->d_rules);
16056 if (device_param->d_rules_c) hc_clReleaseMemObject (device_param->d_rules_c);
16057 if (device_param->d_combs) hc_clReleaseMemObject (device_param->d_combs);
16058 if (device_param->d_combs_c) hc_clReleaseMemObject (device_param->d_combs_c);
16059 if (device_param->d_bfs) hc_clReleaseMemObject (device_param->d_bfs);
16060 if (device_param->d_bfs_c) hc_clReleaseMemObject (device_param->d_bfs_c);
16061 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (device_param->d_bitmap_s1_a);
16062 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (device_param->d_bitmap_s1_b);
16063 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (device_param->d_bitmap_s1_c);
16064 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (device_param->d_bitmap_s1_d);
16065 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (device_param->d_bitmap_s2_a);
16066 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (device_param->d_bitmap_s2_b);
16067 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (device_param->d_bitmap_s2_c);
16068 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (device_param->d_bitmap_s2_d);
16069 if (device_param->d_plain_bufs) hc_clReleaseMemObject (device_param->d_plain_bufs);
16070 if (device_param->d_digests_buf) hc_clReleaseMemObject (device_param->d_digests_buf);
16071 if (device_param->d_digests_shown) hc_clReleaseMemObject (device_param->d_digests_shown);
16072 if (device_param->d_salt_bufs) hc_clReleaseMemObject (device_param->d_salt_bufs);
16073 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (device_param->d_esalt_bufs);
16074 if (device_param->d_tmps) hc_clReleaseMemObject (device_param->d_tmps);
16075 if (device_param->d_hooks) hc_clReleaseMemObject (device_param->d_hooks);
16076 if (device_param->d_result) hc_clReleaseMemObject (device_param->d_result);
16077 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (device_param->d_scryptV_buf);
16078 if (device_param->d_root_css_buf) hc_clReleaseMemObject (device_param->d_root_css_buf);
16079 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (device_param->d_markov_css_buf);
16080 if (device_param->d_tm_c) hc_clReleaseMemObject (device_param->d_tm_c);
16081
16082 if (device_param->kernel1) hc_clReleaseKernel (device_param->kernel1);
16083 if (device_param->kernel12) hc_clReleaseKernel (device_param->kernel12);
16084 if (device_param->kernel2) hc_clReleaseKernel (device_param->kernel2);
16085 if (device_param->kernel23) hc_clReleaseKernel (device_param->kernel23);
16086 if (device_param->kernel3) hc_clReleaseKernel (device_param->kernel3);
16087 if (device_param->kernel_mp) hc_clReleaseKernel (device_param->kernel_mp);
16088 if (device_param->kernel_mp_l) hc_clReleaseKernel (device_param->kernel_mp_l);
16089 if (device_param->kernel_mp_r) hc_clReleaseKernel (device_param->kernel_mp_r);
16090 if (device_param->kernel_tb) hc_clReleaseKernel (device_param->kernel_tb);
16091 if (device_param->kernel_tm) hc_clReleaseKernel (device_param->kernel_tm);
16092 if (device_param->kernel_amp) hc_clReleaseKernel (device_param->kernel_amp);
16093
16094 if (device_param->program) hc_clReleaseProgram (device_param->program);
16095 if (device_param->program_mp) hc_clReleaseProgram (device_param->program_mp);
16096 if (device_param->program_amp) hc_clReleaseProgram (device_param->program_amp);
16097 if (device_param->command_queue) hc_clReleaseCommandQueue (device_param->command_queue);
16098 if (device_param->context) hc_clReleaseContext (device_param->context);
16099 }
16100
16101 // reset default fan speed
16102
16103 if (gpu_temp_disable == 0)
16104 {
16105 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16106 {
16107 hc_thread_mutex_lock (mux_adl);
16108
16109 for (uint i = 0; i < data.devices_cnt; i++)
16110 {
16111 if (data.hm_device[i].fan_supported == 1)
16112 {
16113 int fanspeed = temp_retain_fanspeed_value[i];
16114
16115 if (fanspeed == -1) continue;
16116
16117 int rc = hm_set_fanspeed_with_device_id_amd (i, fanspeed);
16118
16119 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", i);
16120 }
16121 }
16122
16123 hc_thread_mutex_unlock (mux_adl);
16124 }
16125 }
16126
16127 // reset power tuning
16128
16129 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16130 {
16131 hc_thread_mutex_lock (mux_adl);
16132
16133 for (uint i = 0; i < data.devices_cnt; i++)
16134 {
16135 if (data.hm_device[i].od_version == 6)
16136 {
16137 // check powertune capabilities first, if not available then skip device
16138
16139 int powertune_supported = 0;
16140
16141 if ((hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll, data.hm_device[i].adapter_index.amd, &powertune_supported)) != ADL_OK)
16142 {
16143 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16144
16145 return (-1);
16146 }
16147
16148 if (powertune_supported != 0)
16149 {
16150 // powercontrol settings
16151
16152 if ((hc_ADL_Overdrive_PowerControl_Set (data.hm_dll, data.hm_device[i].adapter_index.amd, od_power_control_status[i])) != ADL_OK)
16153 {
16154 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16155
16156 return (-1);
16157 }
16158
16159 // clocks
16160
16161 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16162
16163 performance_state->iNumberOfPerformanceLevels = 2;
16164
16165 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[i].state.aLevels[0].iEngineClock;
16166 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[i].state.aLevels[1].iEngineClock;
16167 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[i].state.aLevels[0].iMemoryClock;
16168 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[i].state.aLevels[1].iMemoryClock;
16169
16170 if ((hc_ADL_Overdrive_State_Set (data.hm_dll, data.hm_device[i].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
16171 {
16172 log_info ("ERROR: Failed to restore ADL performance state");
16173
16174 return (-1);
16175 }
16176
16177 local_free (performance_state);
16178 }
16179 }
16180 }
16181
16182 hc_thread_mutex_unlock (mux_adl);
16183 }
16184
16185 if (gpu_temp_disable == 0)
16186 {
16187 if (vendor_id == VENDOR_ID_NV)
16188 {
16189 #ifdef LINUX
16190 hc_NVML_nvmlShutdown (data.hm_dll);
16191 #endif
16192
16193 #ifdef WIN
16194 NvAPI_Unload ();
16195 #endif
16196 }
16197
16198 if (vendor_id == VENDOR_ID_AMD)
16199 {
16200 hc_ADL_Main_Control_Destroy (data.hm_dll);
16201
16202 hm_close (data.hm_dll);
16203 }
16204
16205 #ifdef LINUX
16206 if (vendor_id == VENDOR_ID_NV)
16207 {
16208 hm_close (data.hm_dll);
16209 }
16210 #endif
16211 }
16212
16213 // free memory
16214
16215 local_free (masks);
16216
16217 local_free (dictstat_base);
16218
16219 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16220 {
16221 pot_t *pot_ptr = &pot[pot_pos];
16222
16223 hash_t *hash = &pot_ptr->hash;
16224
16225 local_free (hash->digest);
16226
16227 if (isSalted)
16228 {
16229 local_free (hash->salt);
16230 }
16231 }
16232
16233 local_free (pot);
16234
16235 local_free (all_gpu_rules_cnt);
16236 local_free (all_gpu_rules_buf);
16237
16238 local_free (wl_data->buf);
16239 local_free (wl_data);
16240
16241 local_free (bitmap_s1_a);
16242 local_free (bitmap_s1_b);
16243 local_free (bitmap_s1_c);
16244 local_free (bitmap_s1_d);
16245 local_free (bitmap_s2_a);
16246 local_free (bitmap_s2_b);
16247 local_free (bitmap_s2_c);
16248 local_free (bitmap_s2_d);
16249
16250 local_free (temp_retain_fanspeed_value);
16251 local_free (od_clock_mem_status);
16252 local_free (od_power_control_status);
16253
16254 global_free (devices_param);
16255
16256 global_free (gpu_rules_buf);
16257
16258 global_free (root_css_buf);
16259 global_free (markov_css_buf);
16260
16261 global_free (digests_buf);
16262 global_free (digests_shown);
16263 global_free (digests_shown_tmp);
16264
16265 global_free (salts_buf);
16266 global_free (salts_shown);
16267
16268 global_free (esalts_buf);
16269
16270 global_free (words_progress_done);
16271 global_free (words_progress_rejected);
16272 global_free (words_progress_restored);
16273
16274 if (pot_fp) fclose (pot_fp);
16275
16276 if (data.devices_status == STATUS_QUIT) break;
16277 }
16278
16279 // destroy others mutex
16280
16281 hc_thread_mutex_delete (mux_dispatcher);
16282 hc_thread_mutex_delete (mux_counter);
16283 hc_thread_mutex_delete (mux_display);
16284 hc_thread_mutex_delete (mux_adl);
16285
16286 // free memory
16287
16288 local_free (eff_restore_file);
16289 local_free (new_restore_file);
16290
16291 local_free (rd);
16292
16293 // loopback
16294
16295 local_free (loopback_file);
16296
16297 if (loopback == 1) unlink (loopback_file);
16298
16299 // induction directory
16300
16301 if (induction_dir == NULL)
16302 {
16303 if (attack_mode != ATTACK_MODE_BF)
16304 {
16305 if (rmdir (induction_directory) == -1)
16306 {
16307 if (errno == ENOENT)
16308 {
16309 // good, we can ignore
16310 }
16311 else if (errno == ENOTEMPTY)
16312 {
16313 // good, we can ignore
16314 }
16315 else
16316 {
16317 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
16318
16319 return (-1);
16320 }
16321 }
16322
16323 local_free (induction_directory);
16324 }
16325 }
16326
16327 // outfile-check directory
16328
16329 if (outfile_check_dir == NULL)
16330 {
16331 if (rmdir (outfile_check_directory) == -1)
16332 {
16333 if (errno == ENOENT)
16334 {
16335 // good, we can ignore
16336 }
16337 else if (errno == ENOTEMPTY)
16338 {
16339 // good, we can ignore
16340 }
16341 else
16342 {
16343 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
16344
16345 return (-1);
16346 }
16347 }
16348
16349 local_free (outfile_check_directory);
16350 }
16351
16352 time_t proc_stop;
16353
16354 time (&proc_stop);
16355
16356 logfile_top_uint (proc_start);
16357 logfile_top_uint (proc_stop);
16358
16359 logfile_top_msg ("STOP");
16360
16361 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
16362 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
16363
16364 if (data.devices_status == STATUS_ABORTED) return 2;
16365 if (data.devices_status == STATUS_QUIT) return 2;
16366 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
16367 if (data.devices_status == STATUS_EXHAUSTED) return 1;
16368 if (data.devices_status == STATUS_CRACKED) return 0;
16369
16370 return -1;
16371 }
Hashcat additions to support pwdhash