projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Prepare for some HSM updates related to device_type
[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_kernel_on_cpu.h>
9 #include <getopt.h>
10
11 const char *PROGNAME = "oclHashcat";
12 const char *VERSION_TXT = "2.10";
13 const uint VERSION_BIN = 210;
14 const uint RESTORE_MIN = 210;
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 KERNEL_ACCEL 0
75 #define KERNEL_LOOPS 0
76 #define KERNEL_RULES 1024
77 #define KERNEL_COMBS 1024
78 #define KERNEL_BFS 1024
79 #define KERNEL_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_OUTSIDE_KERNEL 10
119 #define ATTACK_EXEC_INSIDE_KERNEL 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 130
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 13000,
253 6211,
254 6221,
255 6231,
256 6241,
257 8800,
258 12900,
259 12200,
260 9700,
261 9710,
262 9800,
263 9810,
264 9400,
265 9500,
266 9600,
267 10400,
268 10410,
269 10500,
270 10600,
271 10700,
272 9000,
273 5200,
274 6800,
275 6600,
276 8200,
277 11300,
278 12700
279 };
280
281 /**
282 * types
283 */
284
285 static void (*get_next_word_func) (char *, uint32_t, uint32_t *, uint32_t *);
286
287 /**
288 * globals
289 */
290
291 static unsigned int full01 = 0x01010101;
292 static unsigned int full80 = 0x80808080;
293
294 int SUPPRESS_OUTPUT = 0;
295
296 hc_thread_mutex_t mux_adl;
297 hc_thread_mutex_t mux_counter;
298 hc_thread_mutex_t mux_dispatcher;
299 hc_thread_mutex_t mux_display;
300
301 hc_global_data_t data;
302
303 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
304
305 const char *USAGE_MINI[] =
306 {
307 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
308 "",
309 "Try --help for more help.",
310 NULL
311 };
312
313 const char *USAGE_BIG[] =
314 {
315 "%s, advanced password recovery",
316 "",
317 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
318 "",
319 "=======",
320 "Options",
321 "=======",
322 "",
323 "* General:",
324 "",
325 " -m, --hash-type=NUM Hash-type, see references below",
326 " -a, --attack-mode=NUM Attack-mode, see references below",
327 " -V, --version Print version",
328 " -h, --help Print help",
329 " --quiet Suppress output",
330 "",
331 "* Benchmark:",
332 "",
333 " -b, --benchmark Run benchmark",
334 " --benchmark-mode=NUM Benchmark-mode, see references below",
335 "",
336 "* Misc:",
337 "",
338 " --hex-charset Assume charset is given in hex",
339 " --hex-salt Assume salt is given in hex",
340 " --hex-wordlist Assume words in wordlist is given in hex",
341 " --force Ignore warnings",
342 " --status Enable automatic update of the status-screen",
343 " --status-timer=NUM Seconds between status-screen update",
344 " --status-automat Display the status view in a machine readable format",
345 " --loopback Add new plains to induct directory",
346 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
347 "",
348 "* Markov:",
349 "",
350 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
351 " --markov-disable Disables markov-chains, emulates classic brute-force",
352 " --markov-classic Enables classic markov-chains, no per-position enhancement",
353 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
354 "",
355 "* Session:",
356 "",
357 " --runtime=NUM Abort session after NUM seconds of runtime",
358 " --session=STR Define specific session name",
359 " --restore Restore session from --session",
360 " --restore-disable Do not write restore file",
361 "",
362 "* Files:",
363 "",
364 " -o, --outfile=FILE Define outfile for recovered hash",
365 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
366 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
367 " --outfile-check-timer=NUM Seconds between outfile checks",
368 " -p, --separator=CHAR Separator char for hashlists and outfile",
369 " --show Show cracked passwords only",
370 " --left Show un-cracked passwords only",
371 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
372 " --remove Enable remove of hash once it is cracked",
373 " --remove-timer=NUM Update input hash file each NUM seconds",
374 " --potfile-disable Do not write potfile",
375 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
376 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
377 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
378 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
379 " --logfile-disable Disable the logfile",
380 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
381 "",
382 "* Resources:",
383 "",
384 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
385 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
386 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
387 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
388 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
389 " --opencl-platform=NUM OpenCL platform to use, in case multiple platforms are present",
390 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
391 " -n, --kernel-accel=NUM Workload tuning: 1, 8, 40, 80, 160",
392 " -u, --kernel-loops=NUM Workload fine-tuning: 8 - 1024",
393 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
394 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
395 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
396 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
397 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
398 "",
399 "* Distributed:",
400 "",
401 " -s, --skip=NUM Skip number of words",
402 " -l, --limit=NUM Limit number of words",
403 " --keyspace Show keyspace base:mod values and quit",
404 "",
405 "* Rules:",
406 "",
407 " -j, --rule-left=RULE Single rule applied to each word from left dict",
408 " -k, --rule-right=RULE Single rule applied to each word from right dict",
409 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
410 " -g, --generate-rules=NUM Generate NUM random rules",
411 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
412 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
413 " --generate-rules-seed=NUM Force RNG seed to NUM",
414 "",
415 "* Custom charsets:",
416 "",
417 " -1, --custom-charset1=CS User-defined charsets",
418 " -2, --custom-charset2=CS Example:",
419 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
420 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
421 "",
422 "* Increment:",
423 "",
424 " -i, --increment Enable increment mode",
425 " --increment-min=NUM Start incrementing at NUM",
426 " --increment-max=NUM Stop incrementing at NUM",
427 "",
428 "==========",
429 "References",
430 "==========",
431 "",
432 "* Workload Profile:",
433 "",
434 " 1 = Reduced performance profile (low latency desktop)",
435 " 2 = Default performance profile",
436 " 3 = Tuned performance profile (high latency desktop)",
437 "",
438 "* Benchmark Settings:",
439 "",
440 " 0 = Manual Tuning",
441 " 1 = Performance Tuning, default",
442 "",
443 "* Outfile Formats:",
444 "",
445 " 1 = hash[:salt]",
446 " 2 = plain",
447 " 3 = hash[:salt]:plain",
448 " 4 = hex_plain",
449 " 5 = hash[:salt]:hex_plain",
450 " 6 = plain:hex_plain",
451 " 7 = hash[:salt]:plain:hex_plain",
452 " 8 = crackpos",
453 " 9 = hash[:salt]:crackpos",
454 " 10 = plain:crackpos",
455 " 11 = hash[:salt]:plain:crackpos",
456 " 12 = hex_plain:crackpos",
457 " 13 = hash[:salt]:hex_plain:crackpos",
458 " 14 = plain:hex_plain:crackpos",
459 " 15 = hash[:salt]:plain:hex_plain:crackpos",
460 "",
461 "* Debug mode output formats (for hybrid mode only, by using rules):",
462 "",
463 " 1 = save finding rule",
464 " 2 = save original word",
465 " 3 = save original word and finding rule",
466 " 4 = save original word, finding rule and modified plain",
467 "",
468 "* Built-in charsets:",
469 "",
470 " ?l = abcdefghijklmnopqrstuvwxyz",
471 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
472 " ?d = 0123456789",
473 " ?s = !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~",
474 " ?a = ?l?u?d?s",
475 " ?b = 0x00 - 0xff",
476 "",
477 "* Attack modes:",
478 "",
479 " 0 = Straight",
480 " 1 = Combination",
481 " 3 = Brute-force",
482 " 6 = Hybrid dict + mask",
483 " 7 = Hybrid mask + dict",
484 "",
485 "* Hash types:",
486 "",
487 "[[ Roll-your-own: Raw Hashes ]]",
488 "",
489 " 900 = MD4",
490 " 0 = MD5",
491 " 5100 = Half MD5",
492 " 100 = SHA1",
493 " 10800 = SHA-384",
494 " 1400 = SHA-256",
495 " 1700 = SHA-512",
496 " 5000 = SHA-3(Keccak)",
497 " 10100 = SipHash",
498 " 6000 = RipeMD160",
499 " 6100 = Whirlpool",
500 " 6900 = GOST R 34.11-94",
501 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
502 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
503 "",
504 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
505 "",
506 " 10 = md5($pass.$salt)",
507 " 20 = md5($salt.$pass)",
508 " 30 = md5(unicode($pass).$salt)",
509 " 40 = md5($salt.unicode($pass))",
510 " 3800 = md5($salt.$pass.$salt)",
511 " 3710 = md5($salt.md5($pass))",
512 " 2600 = md5(md5($pass)",
513 " 4300 = md5(strtoupper(md5($pass)))",
514 " 4400 = md5(sha1($pass))",
515 " 110 = sha1($pass.$salt)",
516 " 120 = sha1($salt.$pass)",
517 " 130 = sha1(unicode($pass).$salt)",
518 " 140 = sha1($salt.unicode($pass))",
519 " 4500 = sha1(sha1($pass)",
520 " 4700 = sha1(md5($pass))",
521 " 4900 = sha1($salt.$pass.$salt)",
522 " 1410 = sha256($pass.$salt)",
523 " 1420 = sha256($salt.$pass)",
524 " 1430 = sha256(unicode($pass).$salt)",
525 " 1440 = sha256($salt.unicode($pass))",
526 " 1710 = sha512($pass.$salt)",
527 " 1720 = sha512($salt.$pass)",
528 " 1730 = sha512(unicode($pass).$salt)",
529 " 1740 = sha512($salt.unicode($pass))",
530 "",
531 "[[ Roll-your-own: Authenticated Hashes ]]",
532 "",
533 " 50 = HMAC-MD5 (key = $pass)",
534 " 60 = HMAC-MD5 (key = $salt)",
535 " 150 = HMAC-SHA1 (key = $pass)",
536 " 160 = HMAC-SHA1 (key = $salt)",
537 " 1450 = HMAC-SHA256 (key = $pass)",
538 " 1460 = HMAC-SHA256 (key = $salt)",
539 " 1750 = HMAC-SHA512 (key = $pass)",
540 " 1760 = HMAC-SHA512 (key = $salt)",
541 "",
542 "[[ Generic KDF ]]",
543 "",
544 " 400 = phpass",
545 " 8900 = scrypt",
546 " 11900 = PBKDF2-HMAC-MD5",
547 " 12000 = PBKDF2-HMAC-SHA1",
548 " 10900 = PBKDF2-HMAC-SHA256",
549 " 12100 = PBKDF2-HMAC-SHA512",
550 "",
551 "[[ Network protocols, Challenge-Response ]]",
552 "",
553 " 23 = Skype",
554 " 2500 = WPA/WPA2",
555 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
556 " 5300 = IKE-PSK MD5",
557 " 5400 = IKE-PSK SHA1",
558 " 5500 = NetNTLMv1",
559 " 5500 = NetNTLMv1 + ESS",
560 " 5600 = NetNTLMv2",
561 " 7300 = IPMI2 RAKP HMAC-SHA1",
562 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
563 " 8300 = DNSSEC (NSEC3)",
564 " 10200 = Cram MD5",
565 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
566 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
567 " 11400 = SIP digest authentication (MD5)",
568 "",
569 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
570 "",
571 " 121 = SMF (Simple Machines Forum)",
572 " 400 = phpBB3",
573 " 2611 = vBulletin < v3.8.5",
574 " 2711 = vBulletin > v3.8.5",
575 " 2811 = MyBB",
576 " 2811 = IPB (Invison Power Board)",
577 " 8400 = WBB3 (Woltlab Burning Board)",
578 " 11 = Joomla < 2.5.18",
579 " 400 = Joomla > 2.5.18",
580 " 400 = Wordpress",
581 " 2612 = PHPS",
582 " 7900 = Drupal7",
583 " 21 = osCommerce",
584 " 21 = xt:Commerce",
585 " 11000 = PrestaShop",
586 " 124 = Django (SHA-1)",
587 " 10000 = Django (PBKDF2-SHA256)",
588 " 3711 = Mediawiki B type",
589 " 7600 = Redmine",
590 "",
591 "[[ Database Server ]]",
592 "",
593 " 12 = PostgreSQL",
594 " 131 = MSSQL(2000)",
595 " 132 = MSSQL(2005)",
596 " 1731 = MSSQL(2012)",
597 " 1731 = MSSQL(2014)",
598 " 200 = MySQL323",
599 " 300 = MySQL4.1/MySQL5",
600 " 3100 = Oracle H: Type (Oracle 7+)",
601 " 112 = Oracle S: Type (Oracle 11+)",
602 " 12300 = Oracle T: Type (Oracle 12+)",
603 " 8000 = Sybase ASE",
604 "",
605 "[[ HTTP, SMTP, LDAP Server ]]",
606 "",
607 " 141 = EPiServer 6.x < v4",
608 " 1441 = EPiServer 6.x > v4",
609 " 1600 = Apache $apr1$",
610 " 12600 = ColdFusion 10+",
611 " 1421 = hMailServer",
612 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
613 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
614 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
615 "",
616 "[[ Checksums ]]",
617 "",
618 " 11500 = CRC32",
619 "",
620 "[[ Operating-Systems ]]",
621 "",
622 " 3000 = LM",
623 " 1000 = NTLM",
624 " 1100 = Domain Cached Credentials (DCC), MS Cache",
625 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
626 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
627 " 1500 = descrypt, DES(Unix), Traditional DES",
628 " 12400 = BSDiCrypt, Extended DES",
629 " 500 = md5crypt $1$, MD5(Unix)",
630 " 3200 = bcrypt $2*$, Blowfish(Unix)",
631 " 7400 = sha256crypt $5$, SHA256(Unix)",
632 " 1800 = sha512crypt $6$, SHA512(Unix)",
633 " 122 = OSX v10.4",
634 " 122 = OSX v10.5",
635 " 122 = OSX v10.6",
636 " 1722 = OSX v10.7",
637 " 7100 = OSX v10.8",
638 " 7100 = OSX v10.9",
639 " 7100 = OSX v10.10",
640 " 6300 = AIX {smd5}",
641 " 6700 = AIX {ssha1}",
642 " 6400 = AIX {ssha256}",
643 " 6500 = AIX {ssha512}",
644 " 2400 = Cisco-PIX",
645 " 2410 = Cisco-ASA",
646 " 500 = Cisco-IOS $1$",
647 " 5700 = Cisco-IOS $4$",
648 " 9200 = Cisco-IOS $8$",
649 " 9300 = Cisco-IOS $9$",
650 " 22 = Juniper Netscreen/SSG (ScreenOS)",
651 " 501 = Juniper IVE",
652 " 5800 = Android PIN",
653 " 8100 = Citrix Netscaler",
654 " 8500 = RACF",
655 " 7200 = GRUB 2",
656 " 9900 = Radmin2",
657 "",
658 "[[ Enterprise Application Software (EAS) ]]",
659 "",
660 " 7700 = SAP CODVN B (BCODE)",
661 " 7800 = SAP CODVN F/G (PASSCODE)",
662 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
663 " 8600 = Lotus Notes/Domino 5",
664 " 8700 = Lotus Notes/Domino 6",
665 " 9100 = Lotus Notes/Domino 8",
666 " 133 = PeopleSoft",
667 "",
668 "[[ Archives ]]",
669 "",
670 " 11600 = 7-Zip",
671 " 12500 = RAR3-hp",
672 " 13000 = RAR5",
673 "",
674 "[[ Full-Disk encryptions (FDE) ]]",
675 "",
676 " 62XY = TrueCrypt 5.0+",
677 " X = 1 = PBKDF2-HMAC-RipeMD160",
678 " X = 2 = PBKDF2-HMAC-SHA512",
679 " X = 3 = PBKDF2-HMAC-Whirlpool",
680 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
681 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
682 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
683 " Y = 3 = XTS 1536 bit (Ciphers: All)",
684 " 8800 = Android FDE < v4.3",
685 " 12900 = Android FDE (Samsung DEK)",
686 " 12200 = eCryptfs",
687 "",
688 "[[ Documents ]]",
689 "",
690 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
691 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
692 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
693 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
694 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
695 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
696 " 9400 = MS Office 2007",
697 " 9500 = MS Office 2010",
698 " 9600 = MS Office 2013",
699 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
700 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
701 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
702 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
703 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
704 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
705 "",
706 "[[ Password Managers ]]",
707 "",
708 " 9000 = Password Safe v2",
709 " 5200 = Password Safe v3",
710 " 6800 = Lastpass",
711 " 6600 = 1Password, agilekeychain",
712 " 8200 = 1Password, cloudkeychain",
713 " 11300 = Bitcoin/Litecoin wallet.dat",
714 " 12700 = Blockchain, My Wallet",
715 "",
716 NULL
717 };
718
719 /**
720 * oclHashcat specific functions
721 */
722
723 void status_display_automat ()
724 {
725 FILE *out = stdout;
726
727 fprintf (out, "STATUS\t%u\t", data.devices_status);
728
729 /**
730 * speed new
731 */
732
733 fprintf (out, "SPEED\t");
734
735 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
736 {
737 hc_device_param_t *device_param = &data.devices_param[device_id];
738
739 uint64_t speed_cnt = 0;
740 float speed_ms = 0;
741
742 for (int i = 0; i < SPEED_CACHE; i++)
743 {
744 float rec_ms;
745
746 hc_timer_get (device_param->speed_rec[i], rec_ms);
747
748 if (rec_ms > SPEED_MAXAGE) continue;
749
750 speed_cnt += device_param->speed_cnt[i];
751 speed_ms += device_param->speed_ms[i];
752 }
753
754 speed_cnt /= SPEED_CACHE;
755 speed_ms /= SPEED_CACHE;
756
757 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
758 }
759
760 /**
761 * words_cur
762 */
763
764 uint64_t words_cur = get_lowest_words_done ();
765
766 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
767
768 /**
769 * counter
770 */
771
772 uint salts_left = data.salts_cnt - data.salts_done;
773
774 if (salts_left == 0) salts_left = 1;
775
776 uint64_t progress_total = data.words_cnt * salts_left;
777
778 uint64_t all_done = 0;
779 uint64_t all_rejected = 0;
780 uint64_t all_restored = 0;
781
782 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
783 {
784 if (salts_left > 1)
785 {
786 // otherwise the final cracked status shows 0/XXX progress
787
788 if (data.salts_shown[salt_pos] == 1) continue;
789 }
790
791 all_done += data.words_progress_done[salt_pos];
792 all_rejected += data.words_progress_rejected[salt_pos];
793 all_restored += data.words_progress_restored[salt_pos];
794 }
795
796 uint64_t progress_cur = all_restored + all_done + all_rejected;
797 uint64_t progress_end = progress_total;
798
799 uint64_t progress_skip = 0;
800
801 if (data.skip)
802 {
803 progress_skip = MIN (data.skip, data.words_base) * salts_left;
804
805 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
806 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
807 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
808 }
809
810 if (data.limit)
811 {
812 progress_end = MIN (data.limit, data.words_base) * salts_left;
813
814 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
815 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
816 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
817 }
818
819 uint64_t progress_cur_relative_skip = progress_cur - progress_skip;
820 uint64_t progress_end_relative_skip = progress_end - progress_skip;
821
822 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
823
824 /**
825 * cracks
826 */
827
828 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
829 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
830
831 /**
832 * temperature
833 */
834
835 if (data.gpu_temp_disable == 0)
836 {
837 fprintf (out, "TEMP\t");
838
839 hc_thread_mutex_lock (mux_adl);
840
841 for (uint i = 0; i < data.devices_cnt; i++)
842 {
843 int temp = hm_get_temperature_with_device_id (i);
844
845 fprintf (out, "%d\t", temp);
846 }
847
848 hc_thread_mutex_unlock (mux_adl);
849 }
850
851 #ifdef _WIN
852 fputc ('\r', out);
853 fputc ('\n', out);
854 #endif
855
856 #ifdef _POSIX
857 fputc ('\n', out);
858 #endif
859
860 fflush (out);
861 }
862
863 void status_display ()
864 {
865 if (data.devices_status == STATUS_INIT) return;
866 if (data.devices_status == STATUS_STARTING) return;
867 if (data.devices_status == STATUS_BYPASS) return;
868
869 if (data.status_automat == 1)
870 {
871 status_display_automat ();
872
873 return;
874 }
875
876 char tmp_buf[1000];
877
878 uint tmp_len = 0;
879
880 log_info ("Session.Name...: %s", data.session);
881
882 char *status_type = strstatus (data.devices_status);
883
884 uint hash_mode = data.hash_mode;
885
886 char *hash_type = strhashtype (hash_mode); // not a bug
887
888 log_info ("Status.........: %s", status_type);
889
890 /**
891 * show rules
892 */
893
894 if (data.rp_files_cnt)
895 {
896 uint i;
897
898 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
899 {
900 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
901 }
902
903 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
904
905 log_info ("Rules.Type.....: %s", tmp_buf);
906
907 tmp_len = 0;
908 }
909
910 if (data.rp_gen)
911 {
912 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
913
914 if (data.rp_gen_seed)
915 {
916 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
917 }
918 }
919
920 /**
921 * show input
922 */
923
924 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
925 {
926 if (data.wordlist_mode == WL_MODE_FILE)
927 {
928 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
929 }
930 else if (data.wordlist_mode == WL_MODE_STDIN)
931 {
932 log_info ("Input.Mode.....: Pipe");
933 }
934 }
935 else if (data.attack_mode == ATTACK_MODE_COMBI)
936 {
937 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
938 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
939 }
940 else if (data.attack_mode == ATTACK_MODE_BF)
941 {
942 char *mask = data.mask;
943
944 if (mask != NULL)
945 {
946 uint mask_len = data.css_cnt;
947
948 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
949
950 if (mask_len > 0)
951 {
952 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
953 {
954 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
955 {
956 mask_len -= data.salts_buf[0].salt_len;
957 }
958 }
959
960 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
961
962 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
963 }
964
965 if (data.maskcnt > 1)
966 {
967 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
968
969 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
970 }
971
972 log_info ("Input.Mode.....: %s", tmp_buf);
973 }
974
975 tmp_len = 0;
976 }
977 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
978 {
979 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
980 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
981 }
982 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
983 {
984 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
985 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
986 }
987
988 if (data.digests_cnt == 1)
989 {
990 if (data.hash_mode == 2500)
991 {
992 wpa_t *wpa = (wpa_t *) data.esalts_buf;
993
994 uint pke[25];
995
996 char *pke_ptr = (char *) pke;
997
998 for (uint i = 0; i < 25; i++)
999 {
1000 pke[i] = byte_swap_32 (wpa->pke[i]);
1001 }
1002
1003 char mac1[6];
1004 char mac2[6];
1005
1006 memcpy (mac1, pke_ptr + 23, 6);
1007 memcpy (mac2, pke_ptr + 29, 6);
1008
1009 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1010 (char *) data.salts_buf[0].salt_buf,
1011 mac1[0] & 0xff,
1012 mac1[1] & 0xff,
1013 mac1[2] & 0xff,
1014 mac1[3] & 0xff,
1015 mac1[4] & 0xff,
1016 mac1[5] & 0xff,
1017 mac2[0] & 0xff,
1018 mac2[1] & 0xff,
1019 mac2[2] & 0xff,
1020 mac2[3] & 0xff,
1021 mac2[4] & 0xff,
1022 mac2[5] & 0xff);
1023 }
1024 else if (data.hash_mode == 5200)
1025 {
1026 log_info ("Hash.Target....: File (%s)", data.hashfile);
1027 }
1028 else if (data.hash_mode == 9000)
1029 {
1030 log_info ("Hash.Target....: File (%s)", data.hashfile);
1031 }
1032 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1033 {
1034 log_info ("Hash.Target....: File (%s)", data.hashfile);
1035 }
1036 else
1037 {
1038 char out_buf[4096];
1039
1040 ascii_digest (out_buf, 0, 0);
1041
1042 // limit length
1043 if (strlen (out_buf) > 40)
1044 {
1045 out_buf[41] = '.';
1046 out_buf[42] = '.';
1047 out_buf[43] = '.';
1048 out_buf[44] = 0;
1049 }
1050
1051 log_info ("Hash.Target....: %s", out_buf);
1052 }
1053 }
1054 else
1055 {
1056 if (data.hash_mode == 3000)
1057 {
1058 char out_buf1[4096];
1059 char out_buf2[4096];
1060
1061 ascii_digest (out_buf1, 0, 0);
1062 ascii_digest (out_buf2, 0, 1);
1063
1064 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1065 }
1066 else
1067 {
1068 log_info ("Hash.Target....: File (%s)", data.hashfile);
1069 }
1070 }
1071
1072 log_info ("Hash.Type......: %s", hash_type);
1073
1074 /**
1075 * speed new
1076 */
1077
1078 uint64_t speed_cnt[DEVICES_MAX];
1079 float speed_ms[DEVICES_MAX];
1080
1081 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1082 {
1083 hc_device_param_t *device_param = &data.devices_param[device_id];
1084
1085 // we need to clear values (set to 0) because in case the device does
1086 // not get new candidates it idles around but speed display would
1087 // show it as working.
1088 // if we instantly set it to 0 after reading it happens that the
1089 // speed can be shown as zero if the users refreshs to fast.
1090 // therefore, we add a timestamp when a stat was recorded and if its
1091 // to old we will not use it
1092
1093 speed_cnt[device_id] = 0;
1094 speed_ms[device_id] = 0;
1095
1096 for (int i = 0; i < SPEED_CACHE; i++)
1097 {
1098 float rec_ms;
1099
1100 hc_timer_get (device_param->speed_rec[i], rec_ms);
1101
1102 if (rec_ms > SPEED_MAXAGE) continue;
1103
1104 speed_cnt[device_id] += device_param->speed_cnt[i];
1105 speed_ms[device_id] += device_param->speed_ms[i];
1106 }
1107
1108 speed_cnt[device_id] /= SPEED_CACHE;
1109 speed_ms[device_id] /= SPEED_CACHE;
1110 }
1111
1112 float hashes_all_ms = 0;
1113
1114 float hashes_dev_ms[DEVICES_MAX];
1115
1116 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1117 {
1118 hashes_dev_ms[device_id] = 0;
1119
1120 if (speed_ms[device_id])
1121 {
1122 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1123
1124 hashes_all_ms += hashes_dev_ms[device_id];
1125 }
1126 }
1127
1128 /**
1129 * timers
1130 */
1131
1132 float ms_running = 0;
1133
1134 hc_timer_get (data.timer_running, ms_running);
1135
1136 float ms_paused = data.ms_paused;
1137
1138 if (data.devices_status == STATUS_PAUSED)
1139 {
1140 float ms_paused_tmp = 0;
1141
1142 hc_timer_get (data.timer_paused, ms_paused_tmp);
1143
1144 ms_paused += ms_paused_tmp;
1145 }
1146
1147 #ifdef WIN
1148
1149 __time64_t sec_run = ms_running / 1000;
1150
1151 #else
1152
1153 time_t sec_run = ms_running / 1000;
1154
1155 #endif
1156
1157 if (sec_run)
1158 {
1159 char display_run[32];
1160
1161 struct tm tm_run;
1162
1163 struct tm *tmp;
1164
1165 #ifdef WIN
1166
1167 tmp = _gmtime64 (&sec_run);
1168
1169 #else
1170
1171 tmp = gmtime (&sec_run);
1172
1173 #endif
1174
1175 if (tmp != NULL)
1176 {
1177 memcpy (&tm_run, tmp, sizeof (struct tm));
1178
1179 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1180
1181 char *start = ctime (&data.proc_start);
1182
1183 size_t start_len = strlen (start);
1184
1185 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1186 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1187
1188 log_info ("Time.Started...: %s (%s)", start, display_run);
1189 }
1190 }
1191 else
1192 {
1193 log_info ("Time.Started...: 0 secs");
1194 }
1195
1196 /**
1197 * counters
1198 */
1199
1200 uint salts_left = data.salts_cnt - data.salts_done;
1201
1202 if (salts_left == 0) salts_left = 1;
1203
1204 uint64_t progress_total = data.words_cnt * salts_left;
1205
1206 uint64_t all_done = 0;
1207 uint64_t all_rejected = 0;
1208 uint64_t all_restored = 0;
1209
1210 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1211 {
1212 if (salts_left > 1)
1213 {
1214 // otherwise the final cracked status shows 0/XXX progress
1215
1216 if (data.salts_shown[salt_pos] == 1) continue;
1217 }
1218
1219 all_done += data.words_progress_done[salt_pos];
1220 all_rejected += data.words_progress_rejected[salt_pos];
1221 all_restored += data.words_progress_restored[salt_pos];
1222 }
1223
1224 uint64_t progress_cur = all_restored + all_done + all_rejected;
1225 uint64_t progress_end = progress_total;
1226
1227 uint64_t progress_skip = 0;
1228
1229 if (data.skip)
1230 {
1231 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1232
1233 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1234 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1235 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1236 }
1237
1238 if (data.limit)
1239 {
1240 progress_end = MIN (data.limit, data.words_base) * salts_left;
1241
1242 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1243 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1244 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1245 }
1246
1247 uint64_t progress_cur_relative_skip = progress_cur - progress_skip;
1248 uint64_t progress_end_relative_skip = progress_end - progress_skip;
1249
1250 float speed_ms_real = ms_running - ms_paused;
1251 uint64_t speed_plains_real = all_done;
1252
1253 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1254 {
1255 if (data.devices_status != STATUS_CRACKED)
1256 {
1257 uint64_t words_per_ms = 0;
1258
1259 if (speed_plains_real && speed_ms_real)
1260 {
1261 words_per_ms = speed_plains_real / speed_ms_real;
1262 }
1263
1264 #ifdef WIN
1265 __time64_t sec_etc = 0;
1266 #else
1267 time_t sec_etc = 0;
1268 #endif
1269
1270 if (words_per_ms)
1271 {
1272 uint64_t progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1273
1274 uint64_t ms_left = progress_left_relative_skip / words_per_ms;
1275
1276 sec_etc = ms_left / 1000;
1277 }
1278
1279 if (sec_etc == 0)
1280 {
1281 log_info ("Time.Estimated.: 0 secs");
1282 }
1283 else if ((uint64_t) sec_etc > ETC_MAX)
1284 {
1285 log_info ("Time.Estimated.: > 10 Years");
1286 }
1287 else
1288 {
1289 char display_etc[32];
1290
1291 struct tm tm_etc;
1292
1293 struct tm *tmp;
1294
1295 #ifdef WIN
1296
1297 tmp = _gmtime64 (&sec_etc);
1298
1299 #else
1300
1301 tmp = gmtime (&sec_etc);
1302
1303 #endif
1304
1305 if (tmp != NULL)
1306 {
1307 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1308
1309 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1310
1311 time_t now;
1312
1313 time (&now);
1314
1315 now += sec_etc;
1316
1317 char *etc = ctime (&now);
1318
1319 size_t etc_len = strlen (etc);
1320
1321 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1322 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1323
1324 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1325 }
1326 }
1327 }
1328 }
1329
1330 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1331 {
1332 char display_dev_cur[16];
1333
1334 memset (display_dev_cur, 0, sizeof (display_dev_cur));
1335
1336 strncpy (display_dev_cur, "0.00", 4);
1337
1338 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1339
1340 log_info ("Speed.Dev.#%d...: %9sH/s", device_id + 1, display_dev_cur);
1341 }
1342
1343 char display_all_cur[16];
1344
1345 memset (display_all_cur, 0, sizeof (display_all_cur));
1346
1347 strncpy (display_all_cur, "0.00", 4);
1348
1349 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1350
1351 if (data.devices_cnt > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1352
1353 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1354 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1355
1356 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);
1357
1358 // crack-per-time
1359
1360 if (data.digests_cnt > 100)
1361 {
1362 time_t now = time (NULL);
1363
1364 int cpt_cur_min = 0;
1365 int cpt_cur_hour = 0;
1366 int cpt_cur_day = 0;
1367
1368 for (int i = 0; i < CPT_BUF; i++)
1369 {
1370 const uint cracked = data.cpt_buf[i].cracked;
1371 const time_t timestamp = data.cpt_buf[i].timestamp;
1372
1373 if ((timestamp + 60) > now)
1374 {
1375 cpt_cur_min += cracked;
1376 }
1377
1378 if ((timestamp + 3600) > now)
1379 {
1380 cpt_cur_hour += cracked;
1381 }
1382
1383 if ((timestamp + 86400) > now)
1384 {
1385 cpt_cur_day += cracked;
1386 }
1387 }
1388
1389 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1390 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1391 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1392
1393 if ((data.cpt_start + 86400) < now)
1394 {
1395 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1396 cpt_cur_min,
1397 cpt_cur_hour,
1398 cpt_cur_day,
1399 cpt_avg_min,
1400 cpt_avg_hour,
1401 cpt_avg_day);
1402 }
1403 else if ((data.cpt_start + 3600) < now)
1404 {
1405 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1406 cpt_cur_min,
1407 cpt_cur_hour,
1408 cpt_avg_min,
1409 cpt_avg_hour,
1410 cpt_avg_day);
1411 }
1412 else if ((data.cpt_start + 60) < now)
1413 {
1414 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1415 cpt_cur_min,
1416 cpt_avg_min,
1417 cpt_avg_hour,
1418 cpt_avg_day);
1419 }
1420 else
1421 {
1422 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1423 cpt_avg_min,
1424 cpt_avg_hour,
1425 cpt_avg_day);
1426 }
1427 }
1428
1429 // Restore point
1430
1431 uint64_t restore_point = get_lowest_words_done ();
1432
1433 uint64_t restore_total = data.words_base;
1434
1435 float percent_restore = 0;
1436
1437 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1438
1439 if (progress_end_relative_skip)
1440 {
1441 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1442 {
1443 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1444 float percent_rejected = 0.0;
1445
1446 if (progress_cur)
1447 {
1448 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1449 }
1450
1451 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);
1452 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1453
1454 if (data.restore_disable == 0)
1455 {
1456 if (percent_finished != 1)
1457 {
1458 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1459 }
1460 }
1461 }
1462 }
1463 else
1464 {
1465 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1466 {
1467 log_info ("Progress.......: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1468 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1469
1470 if (data.restore_disable == 0)
1471 {
1472 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1473 }
1474 }
1475 else
1476 {
1477 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1478 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1479
1480 // --restore not allowed if stdin is used -- really? why?
1481
1482 //if (data.restore_disable == 0)
1483 //{
1484 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1485 //}
1486 }
1487 }
1488
1489 if (data.gpu_temp_disable == 0)
1490 {
1491 hc_thread_mutex_lock (mux_adl);
1492
1493 for (uint i = 0; i < data.devices_cnt; i++)
1494 {
1495 if (data.hm_device[i].fan_supported == 1)
1496 {
1497 const int temperature = hm_get_temperature_with_device_id (i);
1498 const int utilization = hm_get_utilization_with_device_id (i);
1499 const int fanspeed = hm_get_fanspeed_with_device_id (i);
1500
1501 if (data.vendor_id == VENDOR_ID_AMD)
1502 {
1503 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, %2d%% Fan", i + 1, utilization, temperature, fanspeed);
1504 }
1505
1506 if (data.vendor_id == VENDOR_ID_NV)
1507 {
1508 #ifdef LINUX
1509 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, %2d%% Fan", i + 1, utilization, temperature, fanspeed);
1510 #else
1511 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, %2drpm Fan", i + 1, utilization, temperature, fanspeed);
1512 #endif
1513 }
1514 }
1515 else
1516 {
1517 const int temperature = hm_get_temperature_with_device_id (i);
1518 const int utilization = hm_get_utilization_with_device_id (i);
1519
1520 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, N/A Fan", i + 1, utilization, temperature);
1521 }
1522 }
1523
1524 hc_thread_mutex_unlock (mux_adl);
1525 }
1526 }
1527
1528 static void status_benchmark ()
1529 {
1530 if (data.devices_status == STATUS_INIT) return;
1531 if (data.devices_status == STATUS_STARTING) return;
1532
1533 if (data.words_cnt == 0) return;
1534
1535 uint64_t speed_cnt[DEVICES_MAX];
1536 float speed_ms[DEVICES_MAX];
1537
1538 uint device_id;
1539
1540 for (device_id = 0; device_id < data.devices_cnt; device_id++)
1541 {
1542 hc_device_param_t *device_param = &data.devices_param[device_id];
1543
1544 speed_cnt[device_id] = 0;
1545 speed_ms[device_id] = 0;
1546
1547 for (int i = 0; i < SPEED_CACHE; i++)
1548 {
1549 speed_cnt[device_id] += device_param->speed_cnt[i];
1550 speed_ms[device_id] += device_param->speed_ms[i];
1551 }
1552
1553 speed_cnt[device_id] /= SPEED_CACHE;
1554 speed_ms[device_id] /= SPEED_CACHE;
1555 }
1556
1557 float hashes_all_ms = 0;
1558
1559 float hashes_dev_ms[DEVICES_MAX];
1560
1561 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1562 {
1563 hashes_dev_ms[device_id] = 0;
1564
1565 if (speed_ms[device_id])
1566 {
1567 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1568
1569 hashes_all_ms += hashes_dev_ms[device_id];
1570 }
1571 }
1572
1573 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1574 {
1575 char display_dev_cur[16];
1576
1577 memset (display_dev_cur, 0, sizeof (display_dev_cur));
1578
1579 strncpy (display_dev_cur, "0.00", 4);
1580
1581 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1582
1583 log_info ("Speed.Dev.#%d.: %9sH/s", device_id + 1, display_dev_cur);
1584 }
1585
1586 char display_all_cur[16];
1587
1588 memset (display_all_cur, 0, sizeof (display_all_cur));
1589
1590 strncpy (display_all_cur, "0.00", 4);
1591
1592 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1593
1594 if (data.devices_cnt > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1595 }
1596
1597 /**
1598 * oclHashcat -only- functions
1599 */
1600
1601 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1602 {
1603 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1604 {
1605 if (attack_kern == ATTACK_KERN_STRAIGHT)
1606 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1607 else if (attack_kern == ATTACK_KERN_COMBI)
1608 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1609 else if (attack_kern == ATTACK_KERN_BF)
1610 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1611 }
1612 else
1613 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1614 }
1615
1616 static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *profile_dir, char *device_name_chksum, int vendor_id, char *cached_file)
1617 {
1618 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1619 {
1620 if (attack_kern == ATTACK_KERN_STRAIGHT)
1621 snprintf (cached_file, 255, "%s/kernels/%d/m%05d_a0.%s.kernel", profile_dir, vendor_id, (int) kern_type, device_name_chksum);
1622 else if (attack_kern == ATTACK_KERN_COMBI)
1623 snprintf (cached_file, 255, "%s/kernels/%d/m%05d_a1.%s.kernel", profile_dir, vendor_id, (int) kern_type, device_name_chksum);
1624 else if (attack_kern == ATTACK_KERN_BF)
1625 snprintf (cached_file, 255, "%s/kernels/%d/m%05d_a3.%s.kernel", profile_dir, vendor_id, (int) kern_type, device_name_chksum);
1626 }
1627 else
1628 {
1629 snprintf (cached_file, 255, "%s/kernels/%d/m%05d.%s.kernel", profile_dir, vendor_id, (int) kern_type, device_name_chksum);
1630 }
1631 }
1632
1633 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1634 {
1635 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1636 {
1637 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1638 }
1639 else
1640 {
1641 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1642 }
1643 }
1644
1645 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, char *device_name_chksum, int vendor_id, char *cached_file)
1646 {
1647 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1648 {
1649 snprintf (cached_file, 255, "%s/kernels/%d/markov_be.%s.kernel", profile_dir, vendor_id, device_name_chksum);
1650 }
1651 else
1652 {
1653 snprintf (cached_file, 255, "%s/kernels/%d/markov_le.%s.kernel", profile_dir, vendor_id, device_name_chksum);
1654 }
1655 }
1656
1657 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1658 {
1659 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1660 }
1661
1662 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, char *device_name_chksum, int vendor_id, char *cached_file)
1663 {
1664 snprintf (cached_file, 255, "%s/kernels/%d/amp_a%d.%s.kernel", profile_dir, vendor_id, attack_kern, device_name_chksum);
1665 }
1666
1667 static uint convert_from_hex (char *line_buf, const uint line_len)
1668 {
1669 if (line_len & 1) return (line_len); // not in hex
1670
1671 if (data.hex_wordlist == 1)
1672 {
1673 uint i;
1674 uint j;
1675
1676 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1677 {
1678 line_buf[i] = hex_to_char (&line_buf[j]);
1679 }
1680
1681 memset (line_buf + i, 0, line_len - i);
1682
1683 return (i);
1684 }
1685 else if (line_len >= 6) // $HEX[] = 6
1686 {
1687 if (line_buf[0] != '$') return (line_len);
1688 if (line_buf[1] != 'H') return (line_len);
1689 if (line_buf[2] != 'E') return (line_len);
1690 if (line_buf[3] != 'X') return (line_len);
1691 if (line_buf[4] != '[') return (line_len);
1692 if (line_buf[line_len - 1] != ']') return (line_len);
1693
1694 uint i;
1695 uint j;
1696
1697 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1698 {
1699 line_buf[i] = hex_to_char (&line_buf[j]);
1700 }
1701
1702 memset (line_buf + i, 0, line_len - i);
1703
1704 return (i);
1705 }
1706
1707 return (line_len);
1708 }
1709
1710 static uint count_lines (FILE *fd)
1711 {
1712 uint cnt = 0;
1713
1714 char *buf = (char *) mymalloc (BUFSIZ);
1715
1716 size_t nread_tmp = 0;
1717
1718 char *ptr = buf;
1719
1720 while (!feof (fd))
1721 {
1722 size_t nread = fread (buf, sizeof (char), BUFSIZ, fd);
1723 nread_tmp = nread;
1724
1725 if (nread < 1) continue;
1726
1727 ptr = buf;
1728
1729 do
1730 {
1731 if (*ptr++ == '\n') cnt++;
1732
1733 } while (nread--);
1734 }
1735
1736 // special case (if last line did not contain a newline char ... at the very end of the file)
1737
1738 if (nread_tmp > 3)
1739 {
1740 ptr -= 2;
1741
1742 if (*ptr != '\n')
1743 {
1744 ptr--;
1745
1746 if (*ptr != '\n') // needed ? different on windows systems?
1747 {
1748 cnt++;
1749 }
1750 }
1751 }
1752
1753 myfree (buf);
1754
1755 return cnt;
1756 }
1757
1758 static void clear_prompt ()
1759 {
1760 fputc ('\r', stdout);
1761
1762 for (size_t i = 0; i < strlen (PROMPT); i++)
1763 {
1764 fputc (' ', stdout);
1765 }
1766
1767 fputc ('\r', stdout);
1768
1769 fflush (stdout);
1770 }
1771
1772 static void gidd_to_pw_t (hc_device_param_t *device_param, const uint64_t gidd, pw_t *pw)
1773 {
1774 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1775 }
1776
1777 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1778 {
1779 char *outfile = data.outfile;
1780 uint quiet = data.quiet;
1781 FILE *pot_fp = data.pot_fp;
1782 uint loopback = data.loopback;
1783 uint debug_mode = data.debug_mode;
1784 char *debug_file = data.debug_file;
1785
1786 char debug_rule_buf[BLOCK_SIZE];
1787 int debug_rule_len = 0; // -1 error
1788 uint debug_plain_len = 0;
1789
1790 unsigned char debug_plain_ptr[BLOCK_SIZE];
1791
1792 // hash
1793
1794 char out_buf[4096]; memset (out_buf, 0, sizeof (out_buf));
1795
1796 ascii_digest (out_buf, salt_pos, digest_pos);
1797
1798 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1799
1800 // plain
1801
1802 plain_t plain;
1803
1804 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, idx * sizeof (plain_t), sizeof (plain_t), &plain, 0, NULL, NULL);
1805
1806 uint gidvid = plain.gidvid;
1807 uint il_pos = plain.il_pos;
1808
1809 uint64_t crackpos = device_param->words_off;
1810
1811 uint plain_buf[16];
1812
1813 unsigned char *plain_ptr = (unsigned char *) plain_buf;
1814 unsigned int plain_len = 0;
1815
1816 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1817 {
1818 uint64_t gidd = gidvid;
1819 uint64_t gidm = 0;
1820
1821 pw_t pw;
1822
1823 gidd_to_pw_t (device_param, gidd, &pw);
1824
1825 for (int i = 0, j = gidm; i < 16; i++, j++)
1826 {
1827 plain_buf[i] = pw.hi1[0][j];
1828 }
1829
1830 plain_len = pw.pw_len;
1831
1832 const uint off = device_param->innerloop_pos + il_pos;
1833
1834 if (debug_mode > 0)
1835 {
1836 debug_rule_len = 0;
1837
1838 // save rule
1839 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1840 {
1841 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1842
1843 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1844 }
1845
1846 // save plain
1847 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1848 {
1849 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1850
1851 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1852
1853 debug_plain_len = plain_len;
1854 }
1855 }
1856
1857 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1858
1859 crackpos += gidvid;
1860 crackpos *= data.kernel_rules_cnt;
1861 crackpos += device_param->innerloop_pos + il_pos;
1862
1863 if (plain_len > data.pw_max) plain_len = data.pw_max;
1864 }
1865 else if (data.attack_mode == ATTACK_MODE_COMBI)
1866 {
1867 uint64_t gidd = gidvid;
1868 uint64_t gidm = 0;
1869
1870 pw_t pw;
1871
1872 gidd_to_pw_t (device_param, gidd, &pw);
1873
1874 for (int i = 0, j = gidm; i < 16; i++, j++)
1875 {
1876 plain_buf[i] = pw.hi1[0][j];
1877 }
1878
1879 plain_len = pw.pw_len;
1880
1881 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1882 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1883
1884 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1885 {
1886 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1887 }
1888 else
1889 {
1890 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1891
1892 memcpy (plain_ptr, comb_buf, comb_len);
1893 }
1894
1895 plain_len += comb_len;
1896
1897 crackpos += gidvid;
1898 crackpos *= data.combs_cnt;
1899 crackpos += device_param->innerloop_pos + il_pos;
1900
1901 if (data.pw_max != PW_DICTMAX1)
1902 {
1903 if (plain_len > data.pw_max) plain_len = data.pw_max;
1904 }
1905 }
1906 else if (data.attack_mode == ATTACK_MODE_BF)
1907 {
1908 uint64_t l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1909 uint64_t r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1910
1911 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1912 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1913
1914 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1915 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1916
1917 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1918 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1919
1920 plain_len = data.css_cnt;
1921
1922 crackpos += gidvid;
1923 crackpos *= data.bfs_cnt;
1924 crackpos += device_param->innerloop_pos + il_pos;
1925 }
1926 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1927 {
1928 uint64_t gidd = gidvid;
1929 uint64_t gidm = 0;
1930
1931 pw_t pw;
1932
1933 gidd_to_pw_t (device_param, gidd, &pw);
1934
1935 for (int i = 0, j = gidm; i < 16; i++, j++)
1936 {
1937 plain_buf[i] = pw.hi1[0][j];
1938 }
1939
1940 plain_len = pw.pw_len;
1941
1942 uint64_t off = device_param->kernel_params_mp_buf64[3] + il_pos;
1943
1944 uint start = 0;
1945 uint stop = device_param->kernel_params_mp_buf32[4];
1946
1947 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
1948
1949 plain_len += start + stop;
1950
1951 crackpos += gidvid;
1952 crackpos *= data.combs_cnt;
1953 crackpos += device_param->innerloop_pos + il_pos;
1954
1955 if (data.pw_max != PW_DICTMAX1)
1956 {
1957 if (plain_len > data.pw_max) plain_len = data.pw_max;
1958 }
1959 }
1960 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1961 {
1962 uint64_t gidd = gidvid;
1963 uint64_t gidm = 0;
1964
1965 pw_t pw;
1966
1967 gidd_to_pw_t (device_param, gidd, &pw);
1968
1969 for (int i = 0, j = gidm; i < 16; i++, j++)
1970 {
1971 plain_buf[i] = pw.hi1[0][j];
1972 }
1973
1974 plain_len = pw.pw_len;
1975
1976 uint64_t off = device_param->kernel_params_mp_buf64[3] + il_pos;
1977
1978 uint start = 0;
1979 uint stop = device_param->kernel_params_mp_buf32[4];
1980
1981 memmove (plain_ptr + stop, plain_ptr, plain_len);
1982
1983 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
1984
1985 plain_len += start + stop;
1986
1987 crackpos += gidvid;
1988 crackpos *= data.combs_cnt;
1989 crackpos += device_param->innerloop_pos + il_pos;
1990
1991 if (data.pw_max != PW_DICTMAX1)
1992 {
1993 if (plain_len > data.pw_max) plain_len = data.pw_max;
1994 }
1995 }
1996
1997 if (data.attack_mode == ATTACK_MODE_BF)
1998 {
1999 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2000 {
2001 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2002 {
2003 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2004 {
2005 plain_len = plain_len - data.salts_buf[0].salt_len;
2006 }
2007 }
2008
2009 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2010 {
2011 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2012 {
2013 plain_ptr[j] = plain_ptr[i];
2014 }
2015
2016 plain_len = plain_len / 2;
2017 }
2018 }
2019 }
2020
2021 // if enabled, update also the potfile
2022
2023 if (pot_fp)
2024 {
2025 fprintf (pot_fp, "%s:", out_buf);
2026
2027 format_plain (pot_fp, plain_ptr, plain_len, 1);
2028
2029 fputc ('\n', pot_fp);
2030
2031 fflush (pot_fp);
2032 }
2033
2034 // outfile
2035
2036 FILE *out_fp = NULL;
2037
2038 if (outfile != NULL)
2039 {
2040 if ((out_fp = fopen (outfile, "ab")) == NULL)
2041 {
2042 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2043
2044 out_fp = stdout;
2045 }
2046 }
2047 else
2048 {
2049 out_fp = stdout;
2050
2051 if (quiet == 0) clear_prompt ();
2052 }
2053
2054 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2055
2056 if (outfile != NULL)
2057 {
2058 if (out_fp != stdout)
2059 {
2060 fclose (out_fp);
2061 }
2062 }
2063 else
2064 {
2065 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2066 {
2067 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2068 {
2069 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2070 if (quiet == 0) fflush (stdout);
2071 }
2072 }
2073 }
2074
2075 // loopback
2076
2077 if (loopback)
2078 {
2079 char *loopback_file = data.loopback_file;
2080
2081 FILE *fb_fp = NULL;
2082
2083 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2084 {
2085 format_plain (fb_fp, plain_ptr, plain_len, 1);
2086
2087 fputc ('\n', fb_fp);
2088
2089 fclose (fb_fp);
2090 }
2091 }
2092
2093 // (rule) debug mode
2094
2095 // the next check implies that:
2096 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2097 // - debug_mode > 0
2098
2099 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2100 {
2101 if (debug_rule_len < 0) debug_rule_len = 0;
2102
2103 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2104
2105 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2106
2107 if ((quiet == 0) && (debug_file == NULL))
2108 {
2109 fprintf (stdout, "%s", PROMPT);
2110 fflush (stdout);
2111 }
2112 }
2113 }
2114
2115 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2116 {
2117 salt_t *salt_buf = &data.salts_buf[salt_pos];
2118
2119 int found = 0;
2120
2121 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2122
2123 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2124
2125 if (found == 1)
2126 {
2127 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2128
2129 log_info_nn ("");
2130
2131 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);
2132
2133 uint cpt_cracked = 0;
2134
2135 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2136 {
2137 uint idx = salt_buf->digests_offset + digest_pos;
2138
2139 if (data.digests_shown_tmp[idx] == 0) continue;
2140
2141 if (data.digests_shown[idx] == 1) continue;
2142
2143 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2144 {
2145 data.digests_shown[idx] = 1;
2146
2147 data.digests_done++;
2148
2149 cpt_cracked++;
2150
2151 salt_buf->digests_done++;
2152
2153 if (salt_buf->digests_done == salt_buf->digests_cnt)
2154 {
2155 data.salts_shown[salt_pos] = 1;
2156
2157 data.salts_done++;
2158 }
2159 }
2160
2161 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2162
2163 check_hash (device_param, salt_pos, digest_pos);
2164 }
2165
2166 if (cpt_cracked > 0)
2167 {
2168 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2169 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2170
2171 data.cpt_pos++;
2172
2173 data.cpt_total += cpt_cracked;
2174
2175 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2176 }
2177
2178 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2179 {
2180 // we need to reset cracked state on the device
2181 // otherwise host thinks again and again the hash was cracked
2182 // and returns invalid password each time
2183
2184 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2185
2186 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);
2187 }
2188
2189 memset (device_param->result, 0, device_param->size_results);
2190
2191 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2192 }
2193 }
2194
2195 static void save_hash ()
2196 {
2197 char *hashfile = data.hashfile;
2198
2199 char new_hashfile[256];
2200 char old_hashfile[256];
2201
2202 memset (new_hashfile, 0, sizeof (new_hashfile));
2203 memset (old_hashfile, 0, sizeof (old_hashfile));
2204
2205 snprintf (new_hashfile, 255, "%s.new", hashfile);
2206 snprintf (old_hashfile, 255, "%s.old", hashfile);
2207
2208 unlink (new_hashfile);
2209
2210 char separator = data.separator;
2211
2212 FILE *fp = fopen (new_hashfile, "wb");
2213
2214 if (fp == NULL)
2215 {
2216 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2217
2218 exit (-1);
2219 }
2220
2221 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2222 {
2223 if (data.salts_shown[salt_pos] == 1) continue;
2224
2225 salt_t *salt_buf = &data.salts_buf[salt_pos];
2226
2227 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2228 {
2229 uint idx = salt_buf->digests_offset + digest_pos;
2230
2231 if (data.digests_shown[idx] == 1) continue;
2232
2233 if (data.hash_mode != 2500)
2234 {
2235 char out_buf[4096];
2236
2237 memset (out_buf, 0, sizeof (out_buf));
2238
2239 if (data.username == 1)
2240 {
2241 user_t *user = data.hash_info[idx]->user;
2242
2243 uint i;
2244
2245 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2246
2247 fputc (separator, fp);
2248 }
2249
2250 ascii_digest (out_buf, salt_pos, digest_pos);
2251
2252 fputs (out_buf, fp);
2253
2254 log_out (fp, "");
2255 }
2256 else
2257 {
2258 hccap_t hccap;
2259
2260 to_hccap_t (&hccap, salt_pos, digest_pos);
2261
2262 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2263 }
2264 }
2265 }
2266
2267 fflush (fp);
2268
2269 fclose (fp);
2270
2271 unlink (old_hashfile);
2272
2273 if (rename (hashfile, old_hashfile) != 0)
2274 {
2275 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2276
2277 exit (-1);
2278 }
2279
2280 unlink (hashfile);
2281
2282 if (rename (new_hashfile, hashfile) != 0)
2283 {
2284 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2285
2286 exit (-1);
2287 }
2288
2289 unlink (old_hashfile);
2290 }
2291
2292 static float find_kernel_blocks_div (const uint64_t total_left, const uint kernel_blocks_all)
2293 {
2294 // function called only in case kernel_blocks_all > words_left)
2295
2296 float kernel_blocks_div = (float) (total_left) / kernel_blocks_all;
2297
2298 kernel_blocks_div += kernel_blocks_div / 100;
2299
2300 uint32_t kernel_blocks_new = (uint32_t) (kernel_blocks_all * kernel_blocks_div);
2301
2302 while (kernel_blocks_new < total_left)
2303 {
2304 kernel_blocks_div += kernel_blocks_div / 100;
2305
2306 kernel_blocks_new = (uint32_t) (kernel_blocks_all * kernel_blocks_div);
2307 }
2308
2309 if (data.quiet == 0)
2310 {
2311 clear_prompt ();
2312
2313 log_info ("");
2314
2315 log_info ("INFO: approaching final keyspace, workload adjusted");
2316
2317 log_info ("");
2318
2319 fprintf (stdout, "%s", PROMPT);
2320
2321 fflush (stdout);
2322 }
2323
2324 if ((kernel_blocks_all * kernel_blocks_div) < 8) return 1;
2325
2326 return kernel_blocks_div;
2327 }
2328
2329 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num)
2330 {
2331 uint num_elements = num;
2332
2333 device_param->kernel_params_buf32[30] = data.combs_mode;
2334 device_param->kernel_params_buf32[31] = num;
2335
2336 uint kernel_threads = device_param->kernel_threads;
2337
2338 while (num_elements % kernel_threads) num_elements++;
2339
2340 cl_kernel kernel = NULL;
2341
2342 switch (kern_run)
2343 {
2344 case KERN_RUN_1: kernel = device_param->kernel1; break;
2345 case KERN_RUN_12: kernel = device_param->kernel12; break;
2346 case KERN_RUN_2: kernel = device_param->kernel2; break;
2347 case KERN_RUN_23: kernel = device_param->kernel23; break;
2348 case KERN_RUN_3: kernel = device_param->kernel3; break;
2349 case KERN_RUN_WEAK: kernel = device_param->kernel_weak; break;
2350 }
2351
2352 hc_clSetKernelArg (kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2353 hc_clSetKernelArg (kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2354 hc_clSetKernelArg (kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2355 hc_clSetKernelArg (kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2356 hc_clSetKernelArg (kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2357 hc_clSetKernelArg (kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2358 hc_clSetKernelArg (kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2359 hc_clSetKernelArg (kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2360 hc_clSetKernelArg (kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2361 hc_clSetKernelArg (kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2362 hc_clSetKernelArg (kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2363
2364 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2365 {
2366 const size_t global_work_size[3] = { num_elements, 32, 1 };
2367 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2368
2369 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2370 }
2371 else
2372 {
2373 const size_t global_work_size[3] = { num_elements, 1, 1 };
2374 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2375
2376 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2377 }
2378
2379 hc_clFlush (device_param->command_queue);
2380
2381 hc_clFinish (device_param->command_queue);
2382 }
2383
2384 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2385 {
2386 uint num_elements = num;
2387
2388 switch (kern_run)
2389 {
2390 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2391 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2392 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2393 }
2394
2395 // causes problems with special threads like in bcrypt
2396 // const uint kernel_threads = device_param->kernel_threads;
2397
2398 const uint kernel_threads = KERNEL_THREADS;
2399
2400 while (num_elements % kernel_threads) num_elements++;
2401
2402 cl_kernel kernel = NULL;
2403
2404 switch (kern_run)
2405 {
2406 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2407 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2408 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2409 }
2410
2411 switch (kern_run)
2412 {
2413 case KERN_RUN_MP: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2414 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2415 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2416 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2417 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2418 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2419 break;
2420 case KERN_RUN_MP_R: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2421 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2422 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2423 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2424 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2425 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2426 break;
2427 case KERN_RUN_MP_L: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2428 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2429 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2430 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2431 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2432 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2433 hc_clSetKernelArg (kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2434 break;
2435 }
2436
2437 const size_t global_work_size[3] = { num_elements, 1, 1 };
2438 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2439
2440 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2441
2442 hc_clFlush (device_param->command_queue);
2443
2444 hc_clFinish (device_param->command_queue);
2445 }
2446
2447 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2448 {
2449 uint num_elements = num;
2450
2451 uint kernel_threads = device_param->kernel_threads;
2452
2453 while (num_elements % kernel_threads) num_elements++;
2454
2455 cl_kernel kernel = device_param->kernel_tb;
2456
2457 const size_t global_work_size[3] = { num_elements, 1, 1 };
2458 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2459
2460 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2461
2462 hc_clFlush (device_param->command_queue);
2463
2464 hc_clFinish (device_param->command_queue);
2465 }
2466
2467 static void run_kernel_tm (hc_device_param_t *device_param)
2468 {
2469 const uint num_elements = 1024; // fixed
2470
2471 const uint kernel_threads = 32;
2472
2473 cl_kernel kernel = device_param->kernel_tm;
2474
2475 const size_t global_work_size[3] = { num_elements, 1, 1 };
2476 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2477
2478 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2479
2480 hc_clFlush (device_param->command_queue);
2481
2482 hc_clFinish (device_param->command_queue);
2483 }
2484
2485 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2486 {
2487 uint num_elements = num;
2488
2489 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2490 device_param->kernel_params_amp_buf32[6] = num_elements;
2491
2492 // causes problems with special threads like in bcrypt
2493 // const uint kernel_threads = device_param->kernel_threads;
2494
2495 const uint kernel_threads = KERNEL_THREADS;
2496
2497 while (num_elements % kernel_threads) num_elements++;
2498
2499 cl_kernel kernel = device_param->kernel_amp;
2500
2501 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2502 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2503
2504 const size_t global_work_size[3] = { num_elements, 1, 1 };
2505 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2506
2507 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2508
2509 hc_clFlush (device_param->command_queue);
2510
2511 hc_clFinish (device_param->command_queue);
2512 }
2513
2514 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2515 {
2516 if (data.vendor_id == VENDOR_ID_AMD)
2517 {
2518 const cl_uchar zero = 0;
2519
2520 hc_clEnqueueFillBuffer (device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2521 }
2522
2523 if (data.vendor_id == VENDOR_ID_NV)
2524 {
2525 // NOTE: clEnqueueFillBuffer () always fails with -59
2526 // IOW, it's not supported by Nvidia ForceWare <= 352.21,
2527 // How's that possible, OpenCL 1.2 support is advertised??
2528 // We need to workaround...
2529
2530 #define FILLSZ 0x100000
2531
2532 char *tmp = (char *) mymalloc (FILLSZ);
2533
2534 memset (tmp, 0, FILLSZ);
2535
2536 for (uint i = 0; i < size; i += FILLSZ)
2537 {
2538 const int left = size - i;
2539
2540 const int fillsz = MIN (FILLSZ, left);
2541
2542 hc_clEnqueueWriteBuffer (device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2543 }
2544
2545 myfree (tmp);
2546 }
2547
2548 if (data.vendor_id == VENDOR_ID_GENERIC)
2549 {
2550 const cl_uchar zero = 0;
2551
2552 hc_clEnqueueFillBuffer (device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2553 }
2554 }
2555
2556 static int run_rule_engine (const int rule_len, const char *rule_buf)
2557 {
2558 if (rule_len == 0)
2559 {
2560 return 0;
2561 }
2562 else if (rule_len == 1)
2563 {
2564 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2565 }
2566
2567 return 1;
2568 }
2569
2570 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2571 {
2572 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2573 {
2574 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);
2575 }
2576 else if (data.attack_kern == ATTACK_KERN_COMBI)
2577 {
2578 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);
2579 }
2580 else if (data.attack_kern == ATTACK_KERN_BF)
2581 {
2582 const uint64_t off = device_param->words_off;
2583
2584 device_param->kernel_params_mp_l_buf64[3] = off;
2585
2586 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2587 }
2588 }
2589
2590 static void run_cracker (hc_device_param_t *device_param, const uint pw_cnt, const uint pws_cnt)
2591 {
2592 const uint kernel_loops = data.kernel_loops;
2593
2594 // init speed timer
2595
2596 uint speed_pos = device_param->speed_pos;
2597
2598 #ifdef _POSIX
2599 if (device_param->timer_speed.tv_sec == 0)
2600 {
2601 hc_timer_set (&device_param->timer_speed);
2602 }
2603 #endif
2604
2605 #ifdef _WIN
2606 if (device_param->timer_speed.QuadPart == 0)
2607 {
2608 hc_timer_set (&device_param->timer_speed);
2609 }
2610 #endif
2611
2612 // find higest password length, this is for optimization stuff
2613
2614 uint highest_pw_len = 0;
2615
2616 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2617 {
2618 }
2619 else if (data.attack_kern == ATTACK_KERN_COMBI)
2620 {
2621 }
2622 else if (data.attack_kern == ATTACK_KERN_BF)
2623 {
2624 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
2625 + device_param->kernel_params_mp_l_buf32[5];
2626 }
2627
2628 // bitslice optimization stuff
2629
2630 if (data.attack_mode == ATTACK_MODE_BF)
2631 {
2632 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2633 {
2634 run_kernel_tb (device_param, pws_cnt);
2635 }
2636 }
2637
2638 // iteration type
2639
2640 uint innerloop_step = 0;
2641 uint innerloop_cnt = 0;
2642
2643 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = kernel_loops;
2644 else innerloop_step = 1;
2645
2646 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
2647 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
2648 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
2649
2650 // loop start: most outer loop = salt iteration, then innerloops (if multi)
2651
2652 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2653 {
2654 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2655
2656 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2657
2658 if (data.devices_status == STATUS_CRACKED) break;
2659 if (data.devices_status == STATUS_ABORTED) break;
2660 if (data.devices_status == STATUS_QUIT) break;
2661 if (data.devices_status == STATUS_BYPASS) break;
2662
2663 if (data.salts_shown[salt_pos] == 1) continue;
2664
2665 salt_t *salt_buf = &data.salts_buf[salt_pos];
2666
2667 device_param->kernel_params_buf32[24] = salt_pos;
2668 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
2669 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
2670
2671 FILE *combs_fp = device_param->combs_fp;
2672
2673 if (data.attack_mode == ATTACK_MODE_COMBI)
2674 {
2675 rewind (combs_fp);
2676 }
2677
2678 // innerloops
2679
2680 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
2681 {
2682 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2683
2684 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2685
2686 if (data.devices_status == STATUS_CRACKED) break;
2687 if (data.devices_status == STATUS_ABORTED) break;
2688 if (data.devices_status == STATUS_QUIT) break;
2689 if (data.devices_status == STATUS_BYPASS) break;
2690
2691 uint innerloop_left = innerloop_cnt - innerloop_pos;
2692
2693 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
2694
2695 device_param->innerloop_pos = innerloop_pos;
2696 device_param->innerloop_left = innerloop_left;
2697
2698 device_param->kernel_params_buf32[27] = innerloop_left;
2699
2700 if (innerloop_left == 0) continue;
2701
2702 // initialize amplifiers
2703
2704 if (data.attack_mode == ATTACK_MODE_COMBI)
2705 {
2706 char line_buf[BUFSIZ];
2707
2708 uint i = 0;
2709
2710 while (i < innerloop_left)
2711 {
2712 if (feof (combs_fp)) break;
2713
2714 int line_len = fgetl (combs_fp, line_buf);
2715
2716 if (line_len >= PW_MAX1) continue;
2717
2718 line_len = convert_from_hex (line_buf, line_len);
2719
2720 char *line_buf_new = line_buf;
2721
2722 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
2723 {
2724 char rule_buf_out[BLOCK_SIZE];
2725
2726 memset (rule_buf_out, 0, sizeof (rule_buf_out));
2727
2728 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
2729
2730 if (rule_len_out < 0)
2731 {
2732 data.words_progress_rejected[salt_pos] += pw_cnt;
2733
2734 continue;
2735 }
2736
2737 line_len = rule_len_out;
2738
2739 line_buf_new = rule_buf_out;
2740 }
2741
2742 line_len = MIN (line_len, PW_DICTMAX);
2743
2744 char *ptr = (char *) device_param->combs_buf[i].i;
2745
2746 memcpy (ptr, line_buf_new, line_len);
2747
2748 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
2749
2750 if (data.opts_type & OPTS_TYPE_PT_UPPER)
2751 {
2752 uppercase (ptr, line_len);
2753 }
2754
2755 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2756 {
2757 if (data.opts_type & OPTS_TYPE_PT_ADD80)
2758 {
2759 ptr[line_len] = 0x80;
2760 }
2761
2762 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2763 {
2764 ptr[line_len] = 0x01;
2765 }
2766 }
2767
2768 device_param->combs_buf[i].pw_len = line_len;
2769
2770 i++;
2771 }
2772
2773 for (uint j = i; j < innerloop_left; j++)
2774 {
2775 device_param->combs_buf[j].i[0] = 0;
2776 device_param->combs_buf[j].i[1] = 0;
2777 device_param->combs_buf[j].i[2] = 0;
2778 device_param->combs_buf[j].i[3] = 0;
2779 device_param->combs_buf[j].i[4] = 0;
2780 device_param->combs_buf[j].i[5] = 0;
2781 device_param->combs_buf[j].i[6] = 0;
2782 device_param->combs_buf[j].i[7] = 0;
2783
2784 device_param->combs_buf[j].pw_len = 0;
2785 }
2786
2787 innerloop_left = i;
2788 }
2789 else if (data.attack_mode == ATTACK_MODE_BF)
2790 {
2791 uint64_t off = innerloop_pos;
2792
2793 device_param->kernel_params_mp_r_buf64[3] = off;
2794
2795 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
2796 }
2797 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2798 {
2799 uint64_t off = innerloop_pos;
2800
2801 device_param->kernel_params_mp_buf64[3] = off;
2802
2803 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2804 }
2805 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2806 {
2807 uint64_t off = innerloop_pos;
2808
2809 device_param->kernel_params_mp_buf64[3] = off;
2810
2811 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2812 }
2813
2814 // copy amplifiers
2815
2816 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2817 {
2818 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_rules, device_param->d_rules_c, innerloop_pos * sizeof (kernel_rule_t), 0, innerloop_left * sizeof (kernel_rule_t), 0, NULL, NULL);
2819 }
2820 else if (data.attack_mode == ATTACK_MODE_COMBI)
2821 {
2822 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);
2823 }
2824 else if (data.attack_mode == ATTACK_MODE_BF)
2825 {
2826 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);
2827 }
2828 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2829 {
2830 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);
2831 }
2832 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2833 {
2834 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);
2835 }
2836
2837 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2838 {
2839 if (data.attack_mode == ATTACK_MODE_BF)
2840 {
2841 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2842 {
2843 const uint size_tm = 32 * sizeof (bs_word_t);
2844
2845 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2846
2847 run_kernel_tm (device_param);
2848
2849 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2850 }
2851 }
2852
2853 if (highest_pw_len < 16)
2854 {
2855 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2856 }
2857 else if (highest_pw_len < 32)
2858 {
2859 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2860 }
2861 else
2862 {
2863 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2864 }
2865 }
2866 else
2867 {
2868 run_kernel_amp (device_param, pws_cnt);
2869
2870 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2871
2872 if (data.opts_type & OPTS_TYPE_HOOK12)
2873 {
2874 run_kernel (KERN_RUN_12, device_param, pws_cnt);
2875 }
2876
2877 uint iter = salt_buf->salt_iter;
2878
2879 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
2880 {
2881 uint loop_left = iter - loop_pos;
2882
2883 loop_left = MIN (loop_left, kernel_loops);
2884
2885 device_param->kernel_params_buf32[25] = loop_pos;
2886 device_param->kernel_params_buf32[26] = loop_left;
2887
2888 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2889
2890 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2891
2892 if (data.devices_status == STATUS_CRACKED) break;
2893 if (data.devices_status == STATUS_ABORTED) break;
2894 if (data.devices_status == STATUS_QUIT) break;
2895 }
2896
2897 if (data.opts_type & OPTS_TYPE_HOOK23)
2898 {
2899 run_kernel (KERN_RUN_23, device_param, pws_cnt);
2900
2901 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2902
2903 // do something with data
2904
2905 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2906 }
2907
2908 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2909 }
2910
2911 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2912
2913 if (data.devices_status == STATUS_CRACKED) break;
2914 if (data.devices_status == STATUS_ABORTED) break;
2915 if (data.devices_status == STATUS_QUIT) break;
2916
2917 /**
2918 * result
2919 */
2920
2921 hc_thread_mutex_lock (mux_display);
2922
2923 check_cracked (device_param, salt_pos);
2924
2925 hc_thread_mutex_unlock (mux_display);
2926
2927 /**
2928 * progress
2929 */
2930
2931 uint64_t perf_sum_all = (uint64_t) pw_cnt * (uint64_t) innerloop_left;
2932
2933 hc_thread_mutex_lock (mux_counter);
2934
2935 data.words_progress_done[salt_pos] += perf_sum_all;
2936
2937 hc_thread_mutex_unlock (mux_counter);
2938
2939 /**
2940 * speed
2941 */
2942
2943 float speed_ms;
2944
2945 hc_timer_get (device_param->timer_speed, speed_ms);
2946
2947 hc_timer_set (&device_param->timer_speed);
2948
2949 hc_thread_mutex_lock (mux_display);
2950
2951 device_param->speed_cnt[speed_pos] = perf_sum_all;
2952
2953 device_param->speed_ms[speed_pos] = speed_ms;
2954
2955 device_param->speed_rec[speed_pos] = device_param->timer_speed;
2956
2957 hc_thread_mutex_unlock (mux_display);
2958
2959 speed_pos++;
2960
2961 if (speed_pos == SPEED_CACHE)
2962 {
2963 speed_pos = 0;
2964 }
2965 }
2966 }
2967
2968 device_param->speed_pos = speed_pos;
2969 }
2970
2971 static void load_segment (wl_data_t *wl_data, FILE *fd)
2972 {
2973 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
2974
2975 wl_data->pos = 0;
2976
2977 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
2978
2979 wl_data->buf[wl_data->cnt] = 0;
2980
2981 if (wl_data->cnt == 0) return;
2982
2983 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
2984
2985 while (!feof (fd))
2986 {
2987 if (wl_data->cnt == wl_data->avail)
2988 {
2989 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
2990
2991 wl_data->avail += wl_data->incr;
2992 }
2993
2994 const int c = fgetc (fd);
2995
2996 if (c == EOF) break;
2997
2998 wl_data->buf[wl_data->cnt] = (char) c;
2999
3000 wl_data->cnt++;
3001
3002 if (c == '\n') break;
3003 }
3004
3005 // ensure stream ends with a newline
3006
3007 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3008 {
3009 wl_data->cnt++;
3010
3011 wl_data->buf[wl_data->cnt - 1] = '\n';
3012 }
3013
3014 return;
3015 }
3016
3017 static void get_next_word_lm (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
3018 {
3019 char *ptr = buf;
3020
3021 for (uint32_t i = 0; i < sz; i++, ptr++)
3022 {
3023 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3024
3025 if (i == 7)
3026 {
3027 *off = i;
3028 *len = i;
3029
3030 return;
3031 }
3032
3033 if (*ptr != '\n') continue;
3034
3035 *off = i + 1;
3036
3037 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3038
3039 *len = i;
3040
3041 return;
3042 }
3043
3044 *off = sz;
3045 *len = sz;
3046 }
3047
3048 static void get_next_word_uc (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
3049 {
3050 char *ptr = buf;
3051
3052 for (uint32_t i = 0; i < sz; i++, ptr++)
3053 {
3054 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3055
3056 if (*ptr != '\n') continue;
3057
3058 *off = i + 1;
3059
3060 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3061
3062 *len = i;
3063
3064 return;
3065 }
3066
3067 *off = sz;
3068 *len = sz;
3069 }
3070
3071 static void get_next_word_std (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
3072 {
3073 char *ptr = buf;
3074
3075 for (uint32_t i = 0; i < sz; i++, ptr++)
3076 {
3077 if (*ptr != '\n') continue;
3078
3079 *off = i + 1;
3080
3081 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3082
3083 *len = i;
3084
3085 return;
3086 }
3087
3088 *off = sz;
3089 *len = sz;
3090 }
3091
3092 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3093 {
3094 while (wl_data->pos < wl_data->cnt)
3095 {
3096 uint off;
3097 uint len;
3098
3099 char *ptr = wl_data->buf + wl_data->pos;
3100
3101 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3102
3103 wl_data->pos += off;
3104
3105 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3106 {
3107 char rule_buf_out[BLOCK_SIZE];
3108
3109 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3110
3111 int rule_len_out = -1;
3112
3113 if (len < BLOCK_SIZE)
3114 {
3115 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3116 }
3117
3118 if (rule_len_out < 0)
3119 {
3120 continue;
3121 }
3122
3123 if (rule_len_out > PW_MAX)
3124 {
3125 continue;
3126 }
3127 }
3128 else
3129 {
3130 if (len > PW_MAX)
3131 {
3132 continue;
3133 }
3134 }
3135
3136 *out_buf = ptr;
3137 *out_len = len;
3138
3139 return;
3140 }
3141
3142 if (feof (fd))
3143 {
3144 fprintf (stderr, "bug!!\n");
3145
3146 return;
3147 }
3148
3149 load_segment (wl_data, fd);
3150
3151 get_next_word (wl_data, fd, out_buf, out_len);
3152 }
3153
3154 #ifdef _POSIX
3155 static uint64_t count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3156 #endif
3157
3158 #ifdef _WIN
3159 static uint64_t count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3160 #endif
3161 {
3162 hc_signal (NULL);
3163
3164 dictstat_t d;
3165
3166 d.cnt = 0;
3167
3168 #ifdef _POSIX
3169 fstat (fileno (fd), &d.stat);
3170 #endif
3171
3172 #ifdef _WIN
3173 _fstat64 (fileno (fd), &d.stat);
3174 #endif
3175
3176 d.stat.st_mode = 0;
3177 d.stat.st_nlink = 0;
3178 d.stat.st_uid = 0;
3179 d.stat.st_gid = 0;
3180 d.stat.st_rdev = 0;
3181 d.stat.st_atime = 0;
3182
3183 #ifdef _POSIX
3184 d.stat.st_blksize = 0;
3185 d.stat.st_blocks = 0;
3186 #endif
3187
3188 if (d.stat.st_size == 0) return 0;
3189
3190 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3191
3192 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3193 {
3194 if (d_cache)
3195 {
3196 uint64_t cnt = d_cache->cnt;
3197
3198 uint64_t keyspace = cnt;
3199
3200 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3201 {
3202 keyspace *= data.kernel_rules_cnt;
3203 }
3204 else if (data.attack_kern == ATTACK_KERN_COMBI)
3205 {
3206 keyspace *= data.combs_cnt;
3207 }
3208
3209 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);
3210 if (data.quiet == 0) log_info ("");
3211
3212 hc_signal (sigHandler_default);
3213
3214 return (keyspace);
3215 }
3216 }
3217
3218 time_t now = 0;
3219 time_t prev = 0;
3220
3221 uint64_t comp = 0;
3222 uint64_t cnt = 0;
3223 uint64_t cnt2 = 0;
3224
3225 while (!feof (fd))
3226 {
3227 load_segment (wl_data, fd);
3228
3229 comp += wl_data->cnt;
3230
3231 uint32_t i = 0;
3232
3233 while (i < wl_data->cnt)
3234 {
3235 uint32_t len;
3236 uint32_t off;
3237
3238 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3239
3240 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3241 {
3242 char rule_buf_out[BLOCK_SIZE];
3243
3244 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3245
3246 int rule_len_out = -1;
3247
3248 if (len < BLOCK_SIZE)
3249 {
3250 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3251 }
3252
3253 if (rule_len_out < 0)
3254 {
3255 len = PW_MAX1;
3256 }
3257 else
3258 {
3259 len = rule_len_out;
3260 }
3261 }
3262
3263 if (len < PW_MAX1)
3264 {
3265 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3266 {
3267 cnt += data.kernel_rules_cnt;
3268 }
3269 else if (data.attack_kern == ATTACK_KERN_COMBI)
3270 {
3271 cnt += data.combs_cnt;
3272 }
3273
3274 d.cnt++;
3275 }
3276
3277 i += off;
3278
3279 cnt2++;
3280 }
3281
3282 time (&now);
3283
3284 if ((now - prev) == 0) continue;
3285
3286 float percent = (float) comp / (float) d.stat.st_size;
3287
3288 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);
3289
3290 time (&prev);
3291 }
3292
3293 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);
3294 if (data.quiet == 0) log_info ("");
3295
3296 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3297
3298 hc_signal (sigHandler_default);
3299
3300 return (cnt);
3301 }
3302
3303 static void pw_transpose_to_hi1 (const pw_t *p1, pw_t *p2)
3304 {
3305 memcpy (p2->hi1, p1->hi1, 64 * sizeof (uint));
3306 }
3307
3308 static uint pw_add_to_hc1 (hc_device_param_t *device_param, const uint8_t *pw_buf, const uint pw_len)
3309 {
3310 if (data.devices_status == STATUS_BYPASS) return 0;
3311
3312 pw_cache_t *pw_cache = device_param->pw_caches + pw_len;
3313
3314 uint cache_cnt = pw_cache->cnt;
3315
3316 uint8_t *pw_hc1 = pw_cache->pw_buf.hc1[cache_cnt];
3317
3318 memcpy (pw_hc1, pw_buf, pw_len);
3319
3320 memset (pw_hc1 + pw_len, 0, 256 - pw_len);
3321
3322 uint pws_cnt = device_param->pws_cnt;
3323
3324 cache_cnt++;
3325
3326 pw_t *pw = device_param->pws_buf + pws_cnt;
3327
3328 device_param->pw_transpose (&pw_cache->pw_buf, pw);
3329
3330 pw->pw_len = pw_len;
3331
3332 pws_cnt++;
3333
3334 device_param->pws_cnt = pws_cnt;
3335 device_param->pw_cnt = pws_cnt * 1;
3336
3337 cache_cnt = 0;
3338
3339 pw_cache->cnt = cache_cnt;
3340
3341 return pws_cnt;
3342 }
3343
3344 static void *thread_monitor (void *p)
3345 {
3346 uint runtime_check = 0;
3347 uint remove_check = 0;
3348 uint status_check = 0;
3349 uint hwmon_check = 0;
3350 uint restore_check = 0;
3351
3352 uint restore_left = data.restore_timer;
3353 uint remove_left = data.remove_timer;
3354 uint status_left = data.status_timer;
3355
3356 // these variables are mainly used for fan control (AMD only)
3357
3358 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3359
3360 // temperature controller "loopback" values
3361
3362 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3363 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3364
3365 int temp_threshold = 1; // degrees celcius
3366
3367 int fan_speed_min = 15; // in percentage
3368 int fan_speed_max = 100;
3369
3370 time_t last_temp_check_time;
3371
3372 uint sleep_time = 1;
3373
3374 if (data.runtime)
3375 {
3376 runtime_check = 1;
3377 }
3378
3379 if (data.restore_timer)
3380 {
3381 restore_check = 1;
3382 }
3383
3384 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3385 {
3386 remove_check = 1;
3387 }
3388
3389 if (data.status == 1)
3390 {
3391 status_check = 1;
3392 }
3393
3394 if (data.gpu_temp_disable == 0)
3395 {
3396 time (&last_temp_check_time);
3397
3398 hwmon_check = 1;
3399 }
3400
3401 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (hwmon_check == 0) && (restore_check == 0))
3402 {
3403 return (p);
3404 }
3405
3406 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3407 {
3408 hc_sleep (sleep_time);
3409
3410 if (data.devices_status != STATUS_RUNNING) continue;
3411
3412 if (hwmon_check == 1)
3413 {
3414 hc_thread_mutex_lock (mux_adl);
3415
3416 time_t temp_check_time;
3417
3418 time (&temp_check_time);
3419
3420 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3421
3422 if (Ta == 0) Ta = 1;
3423
3424 for (uint i = 0; i < data.devices_cnt; i++)
3425 {
3426 const int temperature = hm_get_temperature_with_device_id (i);
3427
3428 if (temperature > (int) data.gpu_temp_abort)
3429 {
3430 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", i + 1);
3431
3432 if (data.devices_status != STATUS_QUIT) myabort ();
3433
3434 break;
3435 }
3436
3437 const int gpu_temp_retain = data.gpu_temp_retain;
3438
3439 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3440 {
3441 if (data.hm_device[i].fan_supported == 1)
3442 {
3443 int temp_cur = temperature;
3444
3445 int temp_diff_new = gpu_temp_retain - temp_cur;
3446
3447 temp_diff_sum[i] = temp_diff_sum[i] + temp_diff_new;
3448
3449 // calculate Ta value (time difference in seconds between the last check and this check)
3450
3451 last_temp_check_time = temp_check_time;
3452
3453 float Kp = 1.8;
3454 float Ki = 0.005;
3455 float Kd = 6;
3456
3457 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3458
3459 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);
3460
3461 if (abs (fan_diff_required) >= temp_threshold)
3462 {
3463 const int fan_speed_cur = hm_get_fanspeed_with_device_id (i);
3464
3465 int fan_speed_level = fan_speed_cur;
3466
3467 if (fan_speed_chgd[i] == 0) fan_speed_level = temp_cur;
3468
3469 int fan_speed_new = fan_speed_level - fan_diff_required;
3470
3471 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3472 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3473
3474 if (fan_speed_new != fan_speed_cur)
3475 {
3476 int freely_change_fan_speed = (fan_speed_chgd[i] == 1);
3477 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3478
3479 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3480 {
3481 hm_set_fanspeed_with_device_id_amd (i, fan_speed_new);
3482
3483 fan_speed_chgd[i] = 1;
3484 }
3485
3486 temp_diff_old[i] = temp_diff_new;
3487 }
3488 }
3489 }
3490 }
3491 }
3492
3493 hc_thread_mutex_unlock (mux_adl);
3494 }
3495
3496 if (restore_check == 1)
3497 {
3498 restore_left--;
3499
3500 if (restore_left == 0)
3501 {
3502 if (data.restore_disable == 0) cycle_restore ();
3503
3504 restore_left = data.restore_timer;
3505 }
3506 }
3507
3508 if ((runtime_check == 1) && (data.runtime_start > 0))
3509 {
3510 time_t runtime_cur;
3511
3512 time (&runtime_cur);
3513
3514 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3515
3516 if (runtime_left <= 0)
3517 {
3518 if (data.benchmark == 0)
3519 {
3520 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3521 }
3522
3523 if (data.devices_status != STATUS_QUIT) myabort ();
3524 }
3525 }
3526
3527 if (remove_check == 1)
3528 {
3529 remove_left--;
3530
3531 if (remove_left == 0)
3532 {
3533 if (data.digests_saved != data.digests_done)
3534 {
3535 data.digests_saved = data.digests_done;
3536
3537 save_hash ();
3538 }
3539
3540 remove_left = data.remove_timer;
3541 }
3542 }
3543
3544 if (status_check == 1)
3545 {
3546 status_left--;
3547
3548 if (status_left == 0)
3549 {
3550 hc_thread_mutex_lock (mux_display);
3551
3552 if (data.quiet == 0) clear_prompt ();
3553
3554 if (data.quiet == 0) log_info ("");
3555
3556 status_display ();
3557
3558 if (data.quiet == 0) log_info ("");
3559
3560 hc_thread_mutex_unlock (mux_display);
3561
3562 status_left = data.status_timer;
3563 }
3564 }
3565 }
3566
3567 myfree (fan_speed_chgd);
3568
3569 myfree (temp_diff_old);
3570 myfree (temp_diff_sum);
3571
3572 p = NULL;
3573
3574 return (p);
3575 }
3576
3577 static void *thread_outfile_remove (void *p)
3578 {
3579 // some hash-dependent constants
3580 char *outfile_dir = data.outfile_check_directory;
3581 uint dgst_size = data.dgst_size;
3582 uint isSalted = data.isSalted;
3583 uint esalt_size = data.esalt_size;
3584 uint hash_mode = data.hash_mode;
3585
3586 uint outfile_check_timer = data.outfile_check_timer;
3587
3588 char separator = data.separator;
3589
3590 // some hash-dependent functions
3591 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3592 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3593
3594 // buffers
3595 hash_t hash_buf;
3596
3597 memset (&hash_buf, 0, sizeof (hash_buf));
3598
3599 hash_buf.digest = mymalloc (dgst_size);
3600
3601 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3602
3603 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3604
3605 uint digest_buf[64];
3606
3607 outfile_data_t *out_info = NULL;
3608
3609 char **out_files = NULL;
3610
3611 time_t folder_mtime = 0;
3612
3613 int out_cnt = 0;
3614
3615 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3616
3617 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3618 {
3619 hc_sleep (1);
3620
3621 if (data.devices_status != STATUS_RUNNING) continue;
3622
3623 check_left--;
3624
3625 if (check_left == 0)
3626 {
3627 struct stat outfile_check_stat;
3628
3629 if (stat (outfile_dir, &outfile_check_stat) == 0)
3630 {
3631 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3632
3633 if (is_dir == 1)
3634 {
3635 if (outfile_check_stat.st_mtime > folder_mtime)
3636 {
3637 char **out_files_new = scan_directory (outfile_dir);
3638
3639 int out_cnt_new = count_dictionaries (out_files_new);
3640
3641 outfile_data_t *out_info_new = NULL;
3642
3643 if (out_cnt_new > 0)
3644 {
3645 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3646
3647 for (int i = 0; i < out_cnt_new; i++)
3648 {
3649 out_info_new[i].file_name = out_files_new[i];
3650
3651 // check if there are files that we have seen/checked before (and not changed)
3652
3653 for (int j = 0; j < out_cnt; j++)
3654 {
3655 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
3656 {
3657 struct stat outfile_stat;
3658
3659 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
3660 {
3661 if (outfile_stat.st_ctime == out_info[j].ctime)
3662 {
3663 out_info_new[i].ctime = out_info[j].ctime;
3664 out_info_new[i].seek = out_info[j].seek;
3665 }
3666 }
3667 }
3668 }
3669 }
3670 }
3671
3672 local_free (out_info);
3673 local_free (out_files);
3674
3675 out_files = out_files_new;
3676 out_cnt = out_cnt_new;
3677 out_info = out_info_new;
3678
3679 folder_mtime = outfile_check_stat.st_mtime;
3680 }
3681
3682 for (int j = 0; j < out_cnt; j++)
3683 {
3684 FILE *fp = fopen (out_info[j].file_name, "rb");
3685
3686 if (fp != NULL)
3687 {
3688 //hc_thread_mutex_lock (mux_display);
3689
3690 #ifdef _POSIX
3691 struct stat outfile_stat;
3692
3693 fstat (fileno (fp), &outfile_stat);
3694 #endif
3695
3696 #ifdef _WIN
3697 struct stat64 outfile_stat;
3698
3699 _fstat64 (fileno (fp), &outfile_stat);
3700 #endif
3701
3702 if (outfile_stat.st_ctime > out_info[j].ctime)
3703 {
3704 out_info[j].ctime = outfile_stat.st_ctime;
3705 out_info[j].seek = 0;
3706 }
3707
3708 fseek (fp, out_info[j].seek, SEEK_SET);
3709
3710 while (!feof (fp))
3711 {
3712 char line_buf[BUFSIZ];
3713
3714 memset (line_buf, 0, BUFSIZ);
3715
3716 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
3717
3718 if (ptr == NULL) break;
3719
3720 int line_len = strlen (line_buf);
3721
3722 if (line_len <= 0) continue;
3723
3724 int iter = MAX_CUT_TRIES;
3725
3726 for (uint i = line_len - 1; i && iter; i--, line_len--)
3727 {
3728 if (line_buf[i] != separator) continue;
3729
3730 int parser_status = PARSER_OK;
3731
3732 if ((hash_mode != 2500) && (hash_mode != 6800))
3733 {
3734 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
3735 }
3736
3737 uint found = 0;
3738
3739 if (parser_status == PARSER_OK)
3740 {
3741 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
3742 {
3743 if (data.salts_shown[salt_pos] == 1) continue;
3744
3745 salt_t *salt_buf = &data.salts_buf[salt_pos];
3746
3747 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
3748 {
3749 uint idx = salt_buf->digests_offset + digest_pos;
3750
3751 if (data.digests_shown[idx] == 1) continue;
3752
3753 uint cracked = 0;
3754
3755 if (hash_mode == 6800)
3756 {
3757 if (i == salt_buf->salt_len)
3758 {
3759 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3760 }
3761 }
3762 else if (hash_mode == 2500)
3763 {
3764 // BSSID : MAC1 : MAC2 (:plain)
3765 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
3766 {
3767 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3768
3769 if (!cracked) continue;
3770
3771 // now compare MAC1 and MAC2 too, since we have this additional info
3772 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
3773 char *mac2_pos = mac1_pos + 12 + 1;
3774
3775 wpa_t *wpas = (wpa_t *) data.esalts_buf;
3776 wpa_t *wpa = &wpas[salt_pos];
3777
3778 uint pke[25];
3779
3780 char *pke_ptr = (char *) pke;
3781
3782 for (uint i = 0; i < 25; i++)
3783 {
3784 pke[i] = byte_swap_32 (wpa->pke[i]);
3785 }
3786
3787 unsigned char mac1[6];
3788 unsigned char mac2[6];
3789
3790 memcpy (mac1, pke_ptr + 23, 6);
3791 memcpy (mac2, pke_ptr + 29, 6);
3792
3793 // compare hex string(s) vs binary MAC address(es)
3794
3795 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3796 {
3797 if (mac1[i] != (unsigned char) hex_to_char (&mac1_pos[j]))
3798 {
3799 cracked = 0;
3800 break;
3801 }
3802 }
3803
3804 // early skip ;)
3805 if (!cracked) continue;
3806
3807 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3808 {
3809 if (mac2[i] != (unsigned char) hex_to_char (&mac2_pos[j]))
3810 {
3811 cracked = 0;
3812 break;
3813 }
3814 }
3815 }
3816 }
3817 else
3818 {
3819 char *digests_buf_ptr = (char *) data.digests_buf;
3820
3821 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
3822
3823 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
3824 }
3825
3826 if (cracked == 1)
3827 {
3828 found = 1;
3829
3830 data.digests_shown[idx] = 1;
3831
3832 data.digests_done++;
3833
3834 salt_buf->digests_done++;
3835
3836 if (salt_buf->digests_done == salt_buf->digests_cnt)
3837 {
3838 data.salts_shown[salt_pos] = 1;
3839
3840 data.salts_done++;
3841
3842 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
3843 }
3844 }
3845 }
3846
3847 if (data.devices_status == STATUS_CRACKED) break;
3848 }
3849 }
3850
3851 if (found) break;
3852
3853 if (data.devices_status == STATUS_CRACKED) break;
3854
3855 iter--;
3856 }
3857
3858 if (data.devices_status == STATUS_CRACKED) break;
3859 }
3860
3861 out_info[j].seek = ftell (fp);
3862
3863 //hc_thread_mutex_unlock (mux_display);
3864
3865 fclose (fp);
3866 }
3867 }
3868 }
3869 }
3870
3871 check_left = outfile_check_timer;
3872 }
3873 }
3874
3875 if (esalt_size) local_free (hash_buf.esalt);
3876
3877 if (isSalted) local_free (hash_buf.salt);
3878
3879 local_free (hash_buf.digest);
3880
3881 local_free (out_info);
3882
3883 local_free (out_files);
3884
3885 p = NULL;
3886
3887 return (p);
3888 }
3889
3890 static uint get_work (hc_device_param_t *device_param, const uint64_t max)
3891 {
3892 hc_thread_mutex_lock (mux_dispatcher);
3893
3894 const uint64_t words_cur = data.words_cur;
3895 const uint64_t words_base = (data.limit == 0) ? data.words_base : data.limit;
3896
3897 device_param->words_off = words_cur;
3898
3899 const uint64_t words_left = words_base - words_cur;
3900
3901 if (data.kernel_blocks_all > words_left)
3902 {
3903 if (data.kernel_blocks_div == 0)
3904 {
3905 data.kernel_blocks_div = find_kernel_blocks_div (words_left, data.kernel_blocks_all);
3906 }
3907 }
3908
3909 if (data.kernel_blocks_div)
3910 {
3911 if (device_param->kernel_blocks == device_param->kernel_blocks_user)
3912 {
3913 const uint32_t kernel_blocks_new = (float) device_param->kernel_blocks * data.kernel_blocks_div;
3914 const uint32_t kernel_power_new = kernel_blocks_new;
3915
3916 if (kernel_blocks_new < device_param->kernel_blocks)
3917 {
3918 device_param->kernel_blocks = kernel_blocks_new;
3919 device_param->kernel_power = kernel_power_new;
3920 }
3921 }
3922 }
3923
3924 const uint kernel_blocks = device_param->kernel_blocks;
3925
3926 uint work = MIN (words_left, kernel_blocks);
3927
3928 work = MIN (work, max);
3929
3930 data.words_cur += work;
3931
3932 hc_thread_mutex_unlock (mux_dispatcher);
3933
3934 return work;
3935 }
3936
3937 static void *thread_calc_stdin (void *p)
3938 {
3939 hc_device_param_t *device_param = (hc_device_param_t *) p;
3940
3941 const uint attack_kern = data.attack_kern;
3942
3943 const uint kernel_blocks = device_param->kernel_blocks;
3944
3945 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3946 {
3947 hc_thread_mutex_lock (mux_dispatcher);
3948
3949 if (feof (stdin) != 0)
3950 {
3951 hc_thread_mutex_unlock (mux_dispatcher);
3952
3953 break;
3954 }
3955
3956 uint words_cur = 0;
3957
3958 while (words_cur < kernel_blocks)
3959 {
3960 char buf[BUFSIZ];
3961
3962 char *line_buf = fgets (buf, sizeof (buf), stdin);
3963
3964 if (line_buf == NULL) break;
3965
3966 uint line_len = in_superchop (line_buf);
3967
3968 line_len = convert_from_hex (line_buf, line_len);
3969
3970 // post-process rule engine
3971
3972 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3973 {
3974 char rule_buf_out[BLOCK_SIZE];
3975
3976 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3977
3978 int rule_len_out = -1;
3979
3980 if (line_len < BLOCK_SIZE)
3981 {
3982 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
3983 }
3984
3985 if (rule_len_out < 0) continue;
3986
3987 line_buf = rule_buf_out;
3988 line_len = rule_len_out;
3989 }
3990
3991 if (line_len > PW_MAX)
3992 {
3993 continue;
3994 }
3995
3996 if (attack_kern == ATTACK_KERN_STRAIGHT)
3997 {
3998 if ((line_len < data.pw_min) || (line_len > data.pw_max))
3999 {
4000 hc_thread_mutex_lock (mux_counter);
4001
4002 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4003 {
4004 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4005 }
4006
4007 hc_thread_mutex_unlock (mux_counter);
4008
4009 continue;
4010 }
4011 }
4012 else if (attack_kern == ATTACK_KERN_COMBI)
4013 {
4014 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4015 // since we still need to combine the plains
4016
4017 if (line_len > data.pw_max)
4018 {
4019 hc_thread_mutex_lock (mux_counter);
4020
4021 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4022 {
4023 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4024 }
4025
4026 hc_thread_mutex_unlock (mux_counter);
4027
4028 continue;
4029 }
4030 }
4031
4032 device_param->pw_add (device_param, (uint8_t *) line_buf, line_len);
4033
4034 words_cur++;
4035
4036 if (data.devices_status == STATUS_CRACKED) break;
4037 if (data.devices_status == STATUS_ABORTED) break;
4038 if (data.devices_status == STATUS_QUIT) break;
4039 if (data.devices_status == STATUS_BYPASS) break;
4040 }
4041
4042 hc_thread_mutex_unlock (mux_dispatcher);
4043
4044 if (data.devices_status == STATUS_CRACKED) break;
4045 if (data.devices_status == STATUS_ABORTED) break;
4046 if (data.devices_status == STATUS_QUIT) break;
4047 if (data.devices_status == STATUS_BYPASS) break;
4048
4049 // we need 2 flushing because we have two independant caches and it can occur
4050 // that one buffer is already at threshold plus for that length also exists
4051 // more data in the 2nd buffer so it would overflow
4052
4053 // flush session 1
4054
4055 {
4056 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4057 {
4058 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4059
4060 const uint pw_cache_cnt = pw_cache->cnt;
4061
4062 if (pw_cache_cnt == 0) continue;
4063
4064 pw_cache->cnt = 0;
4065
4066 uint pws_cnt = device_param->pws_cnt;
4067
4068 pw_t *pw = device_param->pws_buf + pws_cnt;
4069
4070 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4071
4072 pw->pw_len = pw_len;
4073
4074 uint pw_cnt = device_param->pw_cnt;
4075
4076 pw_cnt += pw_cache_cnt;
4077
4078 device_param->pw_cnt = pw_cnt;
4079
4080 pws_cnt++;
4081
4082 device_param->pws_cnt = pws_cnt;
4083
4084 if (pws_cnt == device_param->kernel_power_user) break;
4085 }
4086
4087 const uint pw_cnt = device_param->pw_cnt;
4088 const uint pws_cnt = device_param->pws_cnt;
4089
4090 if (pws_cnt)
4091 {
4092 run_copy (device_param, pws_cnt);
4093
4094 run_cracker (device_param, pw_cnt, pws_cnt);
4095
4096 device_param->pw_cnt = 0;
4097 device_param->pws_cnt = 0;
4098 }
4099 }
4100
4101 // flush session 2
4102
4103 {
4104 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4105 {
4106 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4107
4108 const uint pw_cache_cnt = pw_cache->cnt;
4109
4110 if (pw_cache_cnt == 0) continue;
4111
4112 pw_cache->cnt = 0;
4113
4114 uint pws_cnt = device_param->pws_cnt;
4115
4116 pw_t *pw = device_param->pws_buf + pws_cnt;
4117
4118 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4119
4120 pw->pw_len = pw_len;
4121
4122 uint pw_cnt = device_param->pw_cnt;
4123
4124 pw_cnt += pw_cache_cnt;
4125
4126 device_param->pw_cnt = pw_cnt;
4127
4128 pws_cnt++;
4129
4130 device_param->pws_cnt = pws_cnt;
4131 }
4132
4133 const uint pw_cnt = device_param->pw_cnt;
4134 const uint pws_cnt = device_param->pws_cnt;
4135
4136 if (pws_cnt)
4137 {
4138 run_copy (device_param, pws_cnt);
4139
4140 run_cracker (device_param, pw_cnt, pws_cnt);
4141
4142 device_param->pw_cnt = 0;
4143 device_param->pws_cnt = 0;
4144 }
4145 }
4146 }
4147
4148 return NULL;
4149 }
4150
4151 static void *thread_calc (void *p)
4152 {
4153 hc_device_param_t *device_param = (hc_device_param_t *) p;
4154
4155 const uint attack_mode = data.attack_mode;
4156 const uint attack_kern = data.attack_kern;
4157
4158 if (attack_mode == ATTACK_MODE_BF)
4159 {
4160 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4161 {
4162 const uint work = get_work (device_param, -1);
4163
4164 if (work == 0) break;
4165
4166 const uint64_t words_off = device_param->words_off;
4167 const uint64_t words_fin = words_off + work;
4168
4169 const uint pw_cnt = work;
4170 const uint pws_cnt = work;
4171
4172 device_param->pw_cnt = pw_cnt;
4173 device_param->pws_cnt = pws_cnt;
4174
4175 if (pws_cnt)
4176 {
4177 run_copy (device_param, pws_cnt);
4178
4179 run_cracker (device_param, pw_cnt, pws_cnt);
4180
4181 device_param->pw_cnt = 0;
4182 device_param->pws_cnt = 0;
4183 }
4184
4185 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4186
4187 if (data.devices_status == STATUS_CRACKED) break;
4188 if (data.devices_status == STATUS_ABORTED) break;
4189 if (data.devices_status == STATUS_QUIT) break;
4190 if (data.devices_status == STATUS_BYPASS) break;
4191
4192 device_param->words_done = words_fin;
4193 }
4194 }
4195 else
4196 {
4197 const uint segment_size = data.segment_size;
4198
4199 char *dictfile = data.dictfile;
4200
4201 if (attack_mode == ATTACK_MODE_COMBI)
4202 {
4203 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4204 {
4205 dictfile = data.dictfile2;
4206 }
4207 }
4208
4209 FILE *fd = fopen (dictfile, "rb");
4210
4211 if (fd == NULL)
4212 {
4213 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4214
4215 return NULL;
4216 }
4217
4218 if (attack_mode == ATTACK_MODE_COMBI)
4219 {
4220 const uint combs_mode = data.combs_mode;
4221
4222 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4223 {
4224 const char *dictfilec = data.dictfile2;
4225
4226 FILE *combs_fp = fopen (dictfilec, "rb");
4227
4228 if (combs_fp == NULL)
4229 {
4230 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4231
4232 fclose (fd);
4233
4234 return NULL;
4235 }
4236
4237 device_param->combs_fp = combs_fp;
4238 }
4239 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4240 {
4241 const char *dictfilec = data.dictfile;
4242
4243 FILE *combs_fp = fopen (dictfilec, "rb");
4244
4245 if (combs_fp == NULL)
4246 {
4247 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4248
4249 fclose (fd);
4250
4251 return NULL;
4252 }
4253
4254 device_param->combs_fp = combs_fp;
4255 }
4256 }
4257
4258 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4259
4260 wl_data->buf = (char *) mymalloc (segment_size);
4261 wl_data->avail = segment_size;
4262 wl_data->incr = segment_size;
4263 wl_data->cnt = 0;
4264 wl_data->pos = 0;
4265
4266 uint64_t words_cur = 0;
4267
4268 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4269 {
4270 uint64_t words_off = 0;
4271 uint64_t words_fin = 0;
4272
4273 uint64_t max = -1;
4274
4275 while (max)
4276 {
4277 const uint work = get_work (device_param, max);
4278
4279 if (work == 0) break;
4280
4281 words_off = device_param->words_off;
4282 words_fin = words_off + work;
4283
4284 char *line_buf;
4285 uint line_len;
4286
4287 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4288
4289 max = 0;
4290
4291 for ( ; words_cur < words_fin; words_cur++)
4292 {
4293 get_next_word (wl_data, fd, &line_buf, &line_len);
4294
4295 line_len = convert_from_hex (line_buf, line_len);
4296
4297 // post-process rule engine
4298
4299 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4300 {
4301 char rule_buf_out[BLOCK_SIZE];
4302
4303 memset (rule_buf_out, 0, sizeof (rule_buf_out));
4304
4305 int rule_len_out = -1;
4306
4307 if (line_len < BLOCK_SIZE)
4308 {
4309 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4310 }
4311
4312 if (rule_len_out < 0) continue;
4313
4314 line_buf = rule_buf_out;
4315 line_len = rule_len_out;
4316 }
4317
4318 if (attack_kern == ATTACK_KERN_STRAIGHT)
4319 {
4320 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4321 {
4322 max++;
4323
4324 hc_thread_mutex_lock (mux_counter);
4325
4326 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4327 {
4328 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4329 }
4330
4331 hc_thread_mutex_unlock (mux_counter);
4332
4333 continue;
4334 }
4335 }
4336 else if (attack_kern == ATTACK_KERN_COMBI)
4337 {
4338 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4339 // since we still need to combine the plains
4340
4341 if (line_len > data.pw_max)
4342 {
4343 max++;
4344
4345 hc_thread_mutex_lock (mux_counter);
4346
4347 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4348 {
4349 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4350 }
4351
4352 hc_thread_mutex_unlock (mux_counter);
4353
4354 continue;
4355 }
4356 }
4357
4358 device_param->pw_add (device_param, (uint8_t *) line_buf, line_len);
4359
4360 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4361
4362 if (data.devices_status == STATUS_CRACKED) break;
4363 if (data.devices_status == STATUS_ABORTED) break;
4364 if (data.devices_status == STATUS_QUIT) break;
4365 if (data.devices_status == STATUS_BYPASS) break;
4366 }
4367
4368 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4369
4370 if (data.devices_status == STATUS_CRACKED) break;
4371 if (data.devices_status == STATUS_ABORTED) break;
4372 if (data.devices_status == STATUS_QUIT) break;
4373 if (data.devices_status == STATUS_BYPASS) break;
4374 }
4375
4376 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4377
4378 if (data.devices_status == STATUS_CRACKED) break;
4379 if (data.devices_status == STATUS_ABORTED) break;
4380 if (data.devices_status == STATUS_QUIT) break;
4381 if (data.devices_status == STATUS_BYPASS) break;
4382
4383 // we need 2 flushing because we have two independant caches and it can occur
4384 // that one buffer is already at threshold plus for that length also exists
4385 // more data in the 2nd buffer so it would overflow
4386
4387 //
4388 // flush session 1
4389 //
4390
4391 {
4392 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4393 {
4394 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4395
4396 const uint pw_cache_cnt = pw_cache->cnt;
4397
4398 if (pw_cache_cnt == 0) continue;
4399
4400 pw_cache->cnt = 0;
4401
4402 uint pws_cnt = device_param->pws_cnt;
4403
4404 pw_t *pw = device_param->pws_buf + pws_cnt;
4405
4406 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4407
4408 pw->pw_len = pw_len;
4409
4410 uint pw_cnt = device_param->pw_cnt;
4411
4412 pw_cnt += pw_cache_cnt;
4413
4414 device_param->pw_cnt = pw_cnt;
4415
4416 pws_cnt++;
4417
4418 device_param->pws_cnt = pws_cnt;
4419
4420 if (pws_cnt == device_param->kernel_power_user) break;
4421 }
4422
4423 const uint pw_cnt = device_param->pw_cnt;
4424 const uint pws_cnt = device_param->pws_cnt;
4425
4426 if (pws_cnt)
4427 {
4428 run_copy (device_param, pws_cnt);
4429
4430 run_cracker (device_param, pw_cnt, pws_cnt);
4431
4432 device_param->pw_cnt = 0;
4433 device_param->pws_cnt = 0;
4434 }
4435
4436 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4437
4438 if (data.devices_status == STATUS_CRACKED) break;
4439 if (data.devices_status == STATUS_ABORTED) break;
4440 if (data.devices_status == STATUS_QUIT) break;
4441 if (data.devices_status == STATUS_BYPASS) break;
4442 }
4443
4444 //
4445 // flush session 2
4446 //
4447
4448 {
4449 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4450 {
4451 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4452
4453 const uint pw_cache_cnt = pw_cache->cnt;
4454
4455 if (pw_cache_cnt == 0) continue;
4456
4457 pw_cache->cnt = 0;
4458
4459 uint pws_cnt = device_param->pws_cnt;
4460
4461 pw_t *pw = device_param->pws_buf + pws_cnt;
4462
4463 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4464
4465 pw->pw_len = pw_len;
4466
4467 uint pw_cnt = device_param->pw_cnt;
4468
4469 pw_cnt += pw_cache_cnt;
4470
4471 device_param->pw_cnt = pw_cnt;
4472
4473 pws_cnt++;
4474
4475 device_param->pws_cnt = pws_cnt;
4476 }
4477
4478 const uint pw_cnt = device_param->pw_cnt;
4479 const uint pws_cnt = device_param->pws_cnt;
4480
4481 if (pws_cnt)
4482 {
4483 run_copy (device_param, pws_cnt);
4484
4485 run_cracker (device_param, pw_cnt, pws_cnt);
4486
4487 device_param->pw_cnt = 0;
4488 device_param->pws_cnt = 0;
4489 }
4490
4491 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4492
4493 if (data.devices_status == STATUS_CRACKED) break;
4494 if (data.devices_status == STATUS_ABORTED) break;
4495 if (data.devices_status == STATUS_QUIT) break;
4496 if (data.devices_status == STATUS_BYPASS) break;
4497 }
4498
4499 if (words_fin == 0) break;
4500
4501 device_param->words_done = words_fin;
4502 }
4503
4504 if (attack_mode == ATTACK_MODE_COMBI)
4505 {
4506 fclose (device_param->combs_fp);
4507 }
4508
4509 free (wl_data->buf);
4510 free (wl_data);
4511
4512 fclose (fd);
4513 }
4514
4515 return NULL;
4516 }
4517
4518 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos, const uint kernel_loops)
4519 {
4520 salt_t *salt_buf = &data.salts_buf[salt_pos];
4521
4522 device_param->kernel_params_buf32[24] = salt_pos;
4523 device_param->kernel_params_buf32[27] = 1;
4524 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4525 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4526 device_param->kernel_params_buf32[30] = 0;
4527 device_param->kernel_params_buf32[31] = 1;
4528
4529 char *dictfile_old = data.dictfile;
4530 char *dictfile2_old = data.dictfile2;
4531 char *mask_old = data.mask;
4532 int attack_mode_old = data.attack_mode;
4533
4534 const char *weak_hash_check = "weak-hash-check";
4535
4536 data.dictfile = (char *) weak_hash_check;
4537 data.dictfile2 = (char *) weak_hash_check;
4538 data.mask = (char *) weak_hash_check;
4539 data.attack_mode = ATTACK_MODE_STRAIGHT;
4540
4541 /**
4542 * run the kernel
4543 */
4544
4545 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4546 {
4547 run_kernel (KERN_RUN_WEAK, device_param, 1);
4548 }
4549 else
4550 {
4551 run_kernel (KERN_RUN_1, device_param, 1);
4552
4553 const uint iter = salt_buf->salt_iter;
4554
4555 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
4556 {
4557 uint loop_left = iter - loop_pos;
4558
4559 loop_left = MIN (loop_left, kernel_loops);
4560
4561 device_param->kernel_params_buf32[25] = loop_pos;
4562 device_param->kernel_params_buf32[26] = loop_left;
4563
4564 run_kernel (KERN_RUN_2, device_param, 1);
4565 }
4566
4567 run_kernel (KERN_RUN_3, device_param, 1);
4568 }
4569
4570 /**
4571 * result
4572 */
4573
4574 check_cracked (device_param, salt_pos);
4575
4576 /**
4577 * cleanup
4578 */
4579
4580 device_param->kernel_params_buf32[24] = 0;
4581 device_param->kernel_params_buf32[25] = 0;
4582 device_param->kernel_params_buf32[26] = 0;
4583 device_param->kernel_params_buf32[27] = 0;
4584 device_param->kernel_params_buf32[28] = 0;
4585 device_param->kernel_params_buf32[29] = 0;
4586 device_param->kernel_params_buf32[30] = 0;
4587 device_param->kernel_params_buf32[31] = 0;
4588
4589 data.dictfile = dictfile_old;
4590 data.dictfile2 = dictfile2_old;
4591 data.mask = mask_old;
4592 data.attack_mode = attack_mode_old;
4593 }
4594
4595 // hlfmt hashcat
4596
4597 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4598 {
4599 if (data.username == 0)
4600 {
4601 *hashbuf_pos = line_buf;
4602 *hashbuf_len = line_len;
4603 }
4604 else
4605 {
4606 char *pos = line_buf;
4607 int len = line_len;
4608
4609 for (int i = 0; i < line_len; i++, pos++, len--)
4610 {
4611 if (line_buf[i] == data.separator)
4612 {
4613 pos++;
4614
4615 len--;
4616
4617 break;
4618 }
4619 }
4620
4621 *hashbuf_pos = pos;
4622 *hashbuf_len = len;
4623 }
4624 }
4625
4626 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4627 {
4628 char *pos = NULL;
4629 int len = 0;
4630
4631 int sep_cnt = 0;
4632
4633 for (int i = 0; i < line_len; i++)
4634 {
4635 if (line_buf[i] == data.separator)
4636 {
4637 sep_cnt++;
4638
4639 continue;
4640 }
4641
4642 if (sep_cnt == 0)
4643 {
4644 if (pos == NULL) pos = line_buf + i;
4645
4646 len++;
4647 }
4648 }
4649
4650 *userbuf_pos = pos;
4651 *userbuf_len = len;
4652 }
4653
4654 // hlfmt pwdump
4655
4656 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
4657 {
4658 int sep_cnt = 0;
4659
4660 int sep2_len = 0;
4661 int sep3_len = 0;
4662
4663 for (int i = 0; i < line_len; i++)
4664 {
4665 if (line_buf[i] == ':')
4666 {
4667 sep_cnt++;
4668
4669 continue;
4670 }
4671
4672 if (sep_cnt == 2) sep2_len++;
4673 if (sep_cnt == 3) sep3_len++;
4674 }
4675
4676 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4677
4678 return 0;
4679 }
4680
4681 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4682 {
4683 char *pos = NULL;
4684 int len = 0;
4685
4686 int sep_cnt = 0;
4687
4688 for (int i = 0; i < line_len; i++)
4689 {
4690 if (line_buf[i] == ':')
4691 {
4692 sep_cnt++;
4693
4694 continue;
4695 }
4696
4697 if (data.hash_mode == 1000)
4698 {
4699 if (sep_cnt == 3)
4700 {
4701 if (pos == NULL) pos = line_buf + i;
4702
4703 len++;
4704 }
4705 }
4706 else if (data.hash_mode == 3000)
4707 {
4708 if (sep_cnt == 2)
4709 {
4710 if (pos == NULL) pos = line_buf + i;
4711
4712 len++;
4713 }
4714 }
4715 }
4716
4717 *hashbuf_pos = pos;
4718 *hashbuf_len = len;
4719 }
4720
4721 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4722 {
4723 char *pos = NULL;
4724 int len = 0;
4725
4726 int sep_cnt = 0;
4727
4728 for (int i = 0; i < line_len; i++)
4729 {
4730 if (line_buf[i] == ':')
4731 {
4732 sep_cnt++;
4733
4734 continue;
4735 }
4736
4737 if (sep_cnt == 0)
4738 {
4739 if (pos == NULL) pos = line_buf + i;
4740
4741 len++;
4742 }
4743 }
4744
4745 *userbuf_pos = pos;
4746 *userbuf_len = len;
4747 }
4748
4749 // hlfmt passwd
4750
4751 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
4752 {
4753 int sep_cnt = 0;
4754
4755 char sep5_first = 0;
4756 char sep6_first = 0;
4757
4758 for (int i = 0; i < line_len; i++)
4759 {
4760 if (line_buf[i] == ':')
4761 {
4762 sep_cnt++;
4763
4764 continue;
4765 }
4766
4767 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
4768 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
4769 }
4770
4771 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
4772
4773 return 0;
4774 }
4775
4776 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4777 {
4778 char *pos = NULL;
4779 int len = 0;
4780
4781 int sep_cnt = 0;
4782
4783 for (int i = 0; i < line_len; i++)
4784 {
4785 if (line_buf[i] == ':')
4786 {
4787 sep_cnt++;
4788
4789 continue;
4790 }
4791
4792 if (sep_cnt == 1)
4793 {
4794 if (pos == NULL) pos = line_buf + i;
4795
4796 len++;
4797 }
4798 }
4799
4800 *hashbuf_pos = pos;
4801 *hashbuf_len = len;
4802 }
4803
4804 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4805 {
4806 char *pos = NULL;
4807 int len = 0;
4808
4809 int sep_cnt = 0;
4810
4811 for (int i = 0; i < line_len; i++)
4812 {
4813 if (line_buf[i] == ':')
4814 {
4815 sep_cnt++;
4816
4817 continue;
4818 }
4819
4820 if (sep_cnt == 0)
4821 {
4822 if (pos == NULL) pos = line_buf + i;
4823
4824 len++;
4825 }
4826 }
4827
4828 *userbuf_pos = pos;
4829 *userbuf_len = len;
4830 }
4831
4832 // hlfmt shadow
4833
4834 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
4835 {
4836 int sep_cnt = 0;
4837
4838 for (int i = 0; i < line_len; i++)
4839 {
4840 if (line_buf[i] == ':') sep_cnt++;
4841 }
4842
4843 if (sep_cnt == 8) return 1;
4844
4845 return 0;
4846 }
4847
4848 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4849 {
4850 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
4851 }
4852
4853 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4854 {
4855 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
4856 }
4857
4858 // hlfmt main
4859
4860 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4861 {
4862 switch (hashfile_format)
4863 {
4864 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4865 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4866 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4867 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4868 }
4869 }
4870
4871 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4872 {
4873 switch (hashfile_format)
4874 {
4875 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
4876 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
4877 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
4878 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
4879 }
4880 }
4881
4882 static uint hlfmt_detect (FILE *fp, uint max_check)
4883 {
4884 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
4885
4886 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
4887 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
4888
4889 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
4890
4891 uint num_check = 0;
4892
4893 while (!feof (fp))
4894 {
4895 char line_buf[BUFSIZ];
4896
4897 int line_len = fgetl (fp, line_buf);
4898
4899 if (line_len == 0) continue;
4900
4901 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
4902 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
4903 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
4904
4905 if (num_check == max_check) break;
4906
4907 num_check++;
4908 }
4909
4910 uint hashlist_format = HLFMT_HASHCAT;
4911
4912 for (int i = 1; i < HLFMTS_CNT; i++)
4913 {
4914 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
4915
4916 hashlist_format = i;
4917 }
4918
4919 free (formats_cnt);
4920
4921 return hashlist_format;
4922 }
4923
4924 /**
4925 * some further helper function
4926 */
4927
4928 // wrapper around mymalloc for ADL
4929
4930 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
4931 {
4932 return mymalloc (iSize);
4933 }
4934
4935 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)
4936 {
4937 uint64_t collisions = 0;
4938
4939 const uint dgst_pos0 = data.dgst_pos0;
4940 const uint dgst_pos1 = data.dgst_pos1;
4941 const uint dgst_pos2 = data.dgst_pos2;
4942 const uint dgst_pos3 = data.dgst_pos3;
4943
4944 memset (bitmap_a, 0, bitmap_size);
4945 memset (bitmap_b, 0, bitmap_size);
4946 memset (bitmap_c, 0, bitmap_size);
4947 memset (bitmap_d, 0, bitmap_size);
4948
4949 for (uint i = 0; i < digests_cnt; i++)
4950 {
4951 uint *digest_ptr = (uint *) digests_buf_ptr;
4952
4953 digests_buf_ptr += dgst_size;
4954
4955 const uint val0 = 1 << (digest_ptr[dgst_pos0] & 0x1f);
4956 const uint val1 = 1 << (digest_ptr[dgst_pos1] & 0x1f);
4957 const uint val2 = 1 << (digest_ptr[dgst_pos2] & 0x1f);
4958 const uint val3 = 1 << (digest_ptr[dgst_pos3] & 0x1f);
4959
4960 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
4961 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
4962 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
4963 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
4964
4965 if (bitmap_a[idx0] & val0) collisions++;
4966 if (bitmap_b[idx1] & val1) collisions++;
4967 if (bitmap_c[idx2] & val2) collisions++;
4968 if (bitmap_d[idx3] & val3) collisions++;
4969
4970 bitmap_a[idx0] |= val0;
4971 bitmap_b[idx1] |= val1;
4972 bitmap_c[idx2] |= val2;
4973 bitmap_d[idx3] |= val3;
4974
4975 if (collisions >= collisions_max) return 0x7fffffff;
4976 }
4977
4978 return collisions;
4979 }
4980
4981 /**
4982 * main
4983 */
4984
4985 int main (int argc, char **argv)
4986 {
4987 /**
4988 * To help users a bit
4989 */
4990
4991 char *compute = getenv ("COMPUTE");
4992
4993 if (compute)
4994 {
4995 char display[100];
4996
4997 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
4998
4999 putenv (display);
5000 }
5001 else
5002 {
5003 if (getenv ("DISPLAY") == NULL)
5004 putenv ((char *) "DISPLAY=:0");
5005 }
5006
5007 /*
5008 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5009 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5010
5011 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5012 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5013 */
5014
5015 /**
5016 * Real init
5017 */
5018
5019 memset (&data, 0, sizeof (hc_global_data_t));
5020
5021 time_t proc_start;
5022
5023 time (&proc_start);
5024
5025 data.proc_start = proc_start;
5026
5027 int myargc = argc;
5028 char **myargv = argv;
5029
5030 hc_thread_mutex_init (mux_dispatcher);
5031 hc_thread_mutex_init (mux_counter);
5032 hc_thread_mutex_init (mux_display);
5033 hc_thread_mutex_init (mux_adl);
5034
5035 /**
5036 * commandline parameters
5037 */
5038
5039 uint usage = USAGE;
5040 uint version = VERSION;
5041 uint quiet = QUIET;
5042 uint benchmark = BENCHMARK;
5043 uint benchmark_mode = BENCHMARK_MODE;
5044 uint show = SHOW;
5045 uint left = LEFT;
5046 uint username = USERNAME;
5047 uint remove = REMOVE;
5048 uint remove_timer = REMOVE_TIMER;
5049 uint64_t skip = SKIP;
5050 uint64_t limit = LIMIT;
5051 uint keyspace = KEYSPACE;
5052 uint potfile_disable = POTFILE_DISABLE;
5053 uint debug_mode = DEBUG_MODE;
5054 char *debug_file = NULL;
5055 char *induction_dir = NULL;
5056 char *outfile_check_dir = NULL;
5057 uint force = FORCE;
5058 uint runtime = RUNTIME;
5059 uint hash_mode = HASH_MODE;
5060 uint attack_mode = ATTACK_MODE;
5061 uint markov_disable = MARKOV_DISABLE;
5062 uint markov_classic = MARKOV_CLASSIC;
5063 uint markov_threshold = MARKOV_THRESHOLD;
5064 char *markov_hcstat = NULL;
5065 char *outfile = NULL;
5066 uint outfile_format = OUTFILE_FORMAT;
5067 uint outfile_autohex = OUTFILE_AUTOHEX;
5068 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5069 uint restore = RESTORE;
5070 uint restore_timer = RESTORE_TIMER;
5071 uint restore_disable = RESTORE_DISABLE;
5072 uint status = STATUS;
5073 uint status_timer = STATUS_TIMER;
5074 uint status_automat = STATUS_AUTOMAT;
5075 uint loopback = LOOPBACK;
5076 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5077 char *session = NULL;
5078 uint hex_charset = HEX_CHARSET;
5079 uint hex_salt = HEX_SALT;
5080 uint hex_wordlist = HEX_WORDLIST;
5081 uint rp_gen = RP_GEN;
5082 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5083 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5084 uint rp_gen_seed = RP_GEN_SEED;
5085 char *rule_buf_l = (char *) RULE_BUF_L;
5086 char *rule_buf_r = (char *) RULE_BUF_R;
5087 uint increment = INCREMENT;
5088 uint increment_min = INCREMENT_MIN;
5089 uint increment_max = INCREMENT_MAX;
5090 char *cpu_affinity = NULL;
5091 char *opencl_devices = NULL;
5092 char *opencl_platform = NULL;
5093 char *truecrypt_keyfiles = NULL;
5094 uint workload_profile = WORKLOAD_PROFILE;
5095 uint kernel_accel = KERNEL_ACCEL;
5096 uint kernel_loops = KERNEL_LOOPS;
5097 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5098 uint gpu_temp_abort = GPU_TEMP_ABORT;
5099 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5100 uint powertune_enable = POWERTUNE_ENABLE;
5101 uint logfile_disable = LOGFILE_DISABLE;
5102 uint segment_size = SEGMENT_SIZE;
5103 uint scrypt_tmto = SCRYPT_TMTO;
5104 char separator = SEPARATOR;
5105 uint bitmap_min = BITMAP_MIN;
5106 uint bitmap_max = BITMAP_MAX;
5107 char *custom_charset_1 = NULL;
5108 char *custom_charset_2 = NULL;
5109 char *custom_charset_3 = NULL;
5110 char *custom_charset_4 = NULL;
5111
5112 #define IDX_HELP 'h'
5113 #define IDX_VERSION 'V'
5114 #define IDX_VERSION_LOWER 'v'
5115 #define IDX_QUIET 0xff02
5116 #define IDX_SHOW 0xff03
5117 #define IDX_LEFT 0xff04
5118 #define IDX_REMOVE 0xff05
5119 #define IDX_REMOVE_TIMER 0xff37
5120 #define IDX_SKIP 's'
5121 #define IDX_LIMIT 'l'
5122 #define IDX_KEYSPACE 0xff35
5123 #define IDX_POTFILE_DISABLE 0xff06
5124 #define IDX_DEBUG_MODE 0xff43
5125 #define IDX_DEBUG_FILE 0xff44
5126 #define IDX_INDUCTION_DIR 0xff46
5127 #define IDX_OUTFILE_CHECK_DIR 0xff47
5128 #define IDX_USERNAME 0xff07
5129 #define IDX_FORCE 0xff08
5130 #define IDX_RUNTIME 0xff09
5131 #define IDX_BENCHMARK 'b'
5132 #define IDX_BENCHMARK_MODE 0xff32
5133 #define IDX_HASH_MODE 'm'
5134 #define IDX_ATTACK_MODE 'a'
5135 #define IDX_RP_FILE 'r'
5136 #define IDX_RP_GEN 'g'
5137 #define IDX_RP_GEN_FUNC_MIN 0xff10
5138 #define IDX_RP_GEN_FUNC_MAX 0xff11
5139 #define IDX_RP_GEN_SEED 0xff34
5140 #define IDX_RULE_BUF_L 'j'
5141 #define IDX_RULE_BUF_R 'k'
5142 #define IDX_INCREMENT 'i'
5143 #define IDX_INCREMENT_MIN 0xff12
5144 #define IDX_INCREMENT_MAX 0xff13
5145 #define IDX_OUTFILE 'o'
5146 #define IDX_OUTFILE_FORMAT 0xff14
5147 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5148 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5149 #define IDX_RESTORE 0xff15
5150 #define IDX_RESTORE_DISABLE 0xff27
5151 #define IDX_STATUS 0xff17
5152 #define IDX_STATUS_TIMER 0xff18
5153 #define IDX_STATUS_AUTOMAT 0xff50
5154 #define IDX_LOOPBACK 0xff38
5155 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5156 #define IDX_SESSION 0xff19
5157 #define IDX_HEX_CHARSET 0xff20
5158 #define IDX_HEX_SALT 0xff21
5159 #define IDX_HEX_WORDLIST 0xff40
5160 #define IDX_MARKOV_DISABLE 0xff22
5161 #define IDX_MARKOV_CLASSIC 0xff23
5162 #define IDX_MARKOV_THRESHOLD 't'
5163 #define IDX_MARKOV_HCSTAT 0xff24
5164 #define IDX_CPU_AFFINITY 0xff25
5165 #define IDX_OPENCL_DEVICES 'd'
5166 #define IDX_OPENCL_PLATFORM 0xff72
5167 #define IDX_WORKLOAD_PROFILE 'w'
5168 #define IDX_KERNEL_ACCEL 'n'
5169 #define IDX_KERNEL_LOOPS 'u'
5170 #define IDX_GPU_TEMP_DISABLE 0xff29
5171 #define IDX_GPU_TEMP_ABORT 0xff30
5172 #define IDX_GPU_TEMP_RETAIN 0xff31
5173 #define IDX_POWERTUNE_ENABLE 0xff41
5174 #define IDX_LOGFILE_DISABLE 0xff51
5175 #define IDX_TRUECRYPT_KEYFILES 0xff52
5176 #define IDX_SCRYPT_TMTO 0xff61
5177 #define IDX_SEGMENT_SIZE 'c'
5178 #define IDX_SEPARATOR 'p'
5179 #define IDX_BITMAP_MIN 0xff70
5180 #define IDX_BITMAP_MAX 0xff71
5181 #define IDX_CUSTOM_CHARSET_1 '1'
5182 #define IDX_CUSTOM_CHARSET_2 '2'
5183 #define IDX_CUSTOM_CHARSET_3 '3'
5184 #define IDX_CUSTOM_CHARSET_4 '4'
5185
5186 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5187
5188 struct option long_options[] =
5189 {
5190 {"help", no_argument, 0, IDX_HELP},
5191 {"version", no_argument, 0, IDX_VERSION},
5192 {"quiet", no_argument, 0, IDX_QUIET},
5193 {"show", no_argument, 0, IDX_SHOW},
5194 {"left", no_argument, 0, IDX_LEFT},
5195 {"username", no_argument, 0, IDX_USERNAME},
5196 {"remove", no_argument, 0, IDX_REMOVE},
5197 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5198 {"skip", required_argument, 0, IDX_SKIP},
5199 {"limit", required_argument, 0, IDX_LIMIT},
5200 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5201 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5202 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5203 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5204 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5205 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5206 {"force", no_argument, 0, IDX_FORCE},
5207 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5208 {"benchmark-mode", required_argument, 0, IDX_BENCHMARK_MODE},
5209 {"restore", no_argument, 0, IDX_RESTORE},
5210 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5211 {"status", no_argument, 0, IDX_STATUS},
5212 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5213 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5214 {"loopback", no_argument, 0, IDX_LOOPBACK},
5215 {"weak-hash-threshold",
5216 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5217 {"session", required_argument, 0, IDX_SESSION},
5218 {"runtime", required_argument, 0, IDX_RUNTIME},
5219 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5220 {"generate-rules-func-min",
5221 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5222 {"generate-rules-func-max",
5223 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5224 {"generate-rules-seed",
5225 required_argument, 0, IDX_RP_GEN_SEED},
5226 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5227 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5228 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5229 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5230 {"rules-file", required_argument, 0, IDX_RP_FILE},
5231 {"outfile", required_argument, 0, IDX_OUTFILE},
5232 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5233 {"outfile-autohex-disable",
5234 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5235 {"outfile-check-timer",
5236 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5237 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5238 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5239 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5240 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5241 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5242 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5243 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5244 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5245 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5246 {"opencl-platform", required_argument, 0, IDX_OPENCL_PLATFORM},
5247 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5248 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5249 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5250 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5251 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5252 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5253 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5254 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5255 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5256 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5257 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5258 // deprecated
5259 {"seperator", required_argument, 0, IDX_SEPARATOR},
5260 {"separator", required_argument, 0, IDX_SEPARATOR},
5261 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5262 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5263 {"increment", no_argument, 0, IDX_INCREMENT},
5264 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5265 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5266 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5267 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5268 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5269 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5270
5271 {0, 0, 0, 0}
5272 };
5273
5274 uint rp_files_cnt = 0;
5275
5276 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5277
5278 int option_index;
5279 int c;
5280
5281 optind = 1;
5282 optopt = 0;
5283 option_index = 0;
5284
5285 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5286 {
5287 switch (c)
5288 {
5289 case IDX_HELP: usage = 1; break;
5290 case IDX_VERSION:
5291 case IDX_VERSION_LOWER: version = 1; break;
5292 case IDX_RESTORE: restore = 1; break;
5293 case IDX_SESSION: session = optarg; break;
5294 case IDX_SHOW: show = 1; break;
5295 case IDX_LEFT: left = 1; break;
5296 case '?': return (-1);
5297 }
5298 }
5299
5300 if (optopt != 0)
5301 {
5302 log_error ("ERROR: Invalid argument specified");
5303
5304 return (-1);
5305 }
5306
5307 /**
5308 * exit functions
5309 */
5310
5311 if (version)
5312 {
5313 log_info (VERSION_TXT);
5314
5315 return (0);
5316 }
5317
5318 if (usage)
5319 {
5320 usage_big_print (PROGNAME);
5321
5322 return (0);
5323 }
5324
5325 /**
5326 * session needs to be set, always!
5327 */
5328
5329 if (session == NULL) session = (char *) PROGNAME;
5330
5331 /**
5332 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5333 */
5334
5335 char *exec_path = get_exec_path ();
5336
5337 #ifdef LINUX
5338
5339 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5340 char *resolved_exec_path = realpath (exec_path, NULL);
5341
5342 char *install_dir = get_install_dir (resolved_exec_path);
5343 char *profile_dir = NULL;
5344 char *session_dir = NULL;
5345 char *shared_dir = NULL;
5346
5347 if (strcmp (install_dir, resolved_install_folder) == 0)
5348 {
5349 struct passwd *pw = getpwuid (getuid ());
5350
5351 const char *homedir = pw->pw_dir;
5352
5353 profile_dir = get_profile_dir (homedir);
5354 session_dir = get_session_dir (profile_dir);
5355 shared_dir = strdup (SHARED_FOLDER);
5356
5357 mkdir (profile_dir, 0700);
5358 mkdir (session_dir, 0700);
5359 }
5360 else
5361 {
5362 profile_dir = install_dir;
5363 session_dir = install_dir;
5364 shared_dir = install_dir;
5365 }
5366
5367 myfree (resolved_install_folder);
5368 myfree (resolved_exec_path);
5369
5370 #else
5371
5372 char *install_dir = get_install_dir (exec_path);
5373 char *profile_dir = install_dir;
5374 char *session_dir = install_dir;
5375 char *shared_dir = install_dir;
5376
5377 #endif
5378
5379 data.install_dir = install_dir;
5380 data.profile_dir = profile_dir;
5381 data.session_dir = session_dir;
5382 data.shared_dir = shared_dir;
5383
5384 myfree (exec_path);
5385
5386 /**
5387 * session
5388 */
5389
5390 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5391
5392 data.session = session;
5393
5394 char *eff_restore_file = (char *) mymalloc (session_size);
5395 char *new_restore_file = (char *) mymalloc (session_size);
5396
5397 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5398 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5399
5400 data.eff_restore_file = eff_restore_file;
5401 data.new_restore_file = new_restore_file;
5402
5403 if (((show == 1) || (left == 1)) && (restore == 1))
5404 {
5405 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5406 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5407
5408 return (-1);
5409 }
5410
5411 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5412 if ((show == 1) || (left == 1))
5413 {
5414 restore_disable = 1;
5415
5416 restore = 0;
5417 }
5418
5419 data.restore_disable = restore_disable;
5420
5421 restore_data_t *rd = init_restore (argc, argv);
5422
5423 data.rd = rd;
5424
5425 /**
5426 * restore file
5427 */
5428
5429 if (restore == 1)
5430 {
5431 read_restore (eff_restore_file, rd);
5432
5433 if (rd->version_bin < RESTORE_MIN)
5434 {
5435 log_error ("ERROR: Incompatible restore-file version");
5436
5437 return (-1);
5438 }
5439
5440 myargc = rd->argc;
5441 myargv = rd->argv;
5442
5443 #ifdef _POSIX
5444 rd->pid = getpid ();
5445 #elif _WIN
5446 rd->pid = GetCurrentProcessId ();
5447 #endif
5448 }
5449
5450 uint hash_mode_chgd = 0;
5451 uint runtime_chgd = 0;
5452 uint kernel_loops_chgd = 0;
5453 uint kernel_accel_chgd = 0;
5454 uint attack_mode_chgd = 0;
5455 uint outfile_format_chgd = 0;
5456 uint rp_gen_seed_chgd = 0;
5457 uint remove_timer_chgd = 0;
5458 uint increment_min_chgd = 0;
5459 uint increment_max_chgd = 0;
5460 uint gpu_temp_abort_chgd = 0;
5461 uint gpu_temp_retain_chgd = 0;
5462
5463 optind = 1;
5464 optopt = 0;
5465 option_index = 0;
5466
5467 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5468 {
5469 switch (c)
5470 {
5471 //case IDX_HELP: usage = 1; break;
5472 //case IDX_VERSION: version = 1; break;
5473 //case IDX_RESTORE: restore = 1; break;
5474 case IDX_QUIET: quiet = 1; break;
5475 //case IDX_SHOW: show = 1; break;
5476 case IDX_SHOW: break;
5477 //case IDX_LEFT: left = 1; break;
5478 case IDX_LEFT: break;
5479 case IDX_USERNAME: username = 1; break;
5480 case IDX_REMOVE: remove = 1; break;
5481 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5482 remove_timer_chgd = 1; break;
5483 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5484 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5485 case IDX_DEBUG_FILE: debug_file = optarg; break;
5486 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5487 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5488 case IDX_FORCE: force = 1; break;
5489 case IDX_SKIP: skip = atoll (optarg); break;
5490 case IDX_LIMIT: limit = atoll (optarg); break;
5491 case IDX_KEYSPACE: keyspace = 1; break;
5492 case IDX_BENCHMARK: benchmark = 1; break;
5493 case IDX_BENCHMARK_MODE: benchmark_mode = atoi (optarg); break;
5494 case IDX_RESTORE: break;
5495 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5496 case IDX_STATUS: status = 1; break;
5497 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5498 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5499 case IDX_LOOPBACK: loopback = 1; break;
5500 case IDX_WEAK_HASH_THRESHOLD:
5501 weak_hash_threshold = atoi (optarg); break;
5502 //case IDX_SESSION: session = optarg; break;
5503 case IDX_SESSION: break;
5504 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5505 hash_mode_chgd = 1; break;
5506 case IDX_RUNTIME: runtime = atoi (optarg);
5507 runtime_chgd = 1; break;
5508 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5509 attack_mode_chgd = 1; break;
5510 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5511 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5512 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5513 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5514 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5515 rp_gen_seed_chgd = 1; break;
5516 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5517 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5518 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5519 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5520 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5521 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5522 case IDX_OUTFILE: outfile = optarg; break;
5523 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5524 outfile_format_chgd = 1; break;
5525 case IDX_OUTFILE_AUTOHEX_DISABLE:
5526 outfile_autohex = 0; break;
5527 case IDX_OUTFILE_CHECK_TIMER:
5528 outfile_check_timer = atoi (optarg); break;
5529 case IDX_HEX_CHARSET: hex_charset = 1; break;
5530 case IDX_HEX_SALT: hex_salt = 1; break;
5531 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5532 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5533 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5534 case IDX_OPENCL_PLATFORM: opencl_platform = optarg; break;
5535 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg); break;
5536 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5537 kernel_accel_chgd = 1; break;
5538 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5539 kernel_loops_chgd = 1; break;
5540 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5541 case IDX_GPU_TEMP_ABORT: gpu_temp_abort_chgd = 1;
5542 gpu_temp_abort = atoi (optarg); break;
5543 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain_chgd = 1;
5544 gpu_temp_retain = atoi (optarg); break;
5545 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5546 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5547 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5548 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5549 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5550 case IDX_SEPARATOR: separator = optarg[0]; break;
5551 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5552 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5553 case IDX_INCREMENT: increment = 1; break;
5554 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5555 increment_min_chgd = 1; break;
5556 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5557 increment_max_chgd = 1; break;
5558 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5559 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5560 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5561 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5562
5563 default:
5564 log_error ("ERROR: Invalid argument specified");
5565 return (-1);
5566 }
5567 }
5568
5569 if (optopt != 0)
5570 {
5571 log_error ("ERROR: Invalid argument specified");
5572
5573 return (-1);
5574 }
5575
5576 /**
5577 * Inform user things getting started,
5578 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5579 * - we do not need to check algorithm_pos
5580 */
5581
5582 if (quiet == 0)
5583 {
5584 if (benchmark == 1)
5585 {
5586 log_info ("%s v%.2f starting in benchmark-mode...", PROGNAME, (float) VERSION_BIN / 100);
5587
5588 log_info ("");
5589 }
5590 else if (restore == 1)
5591 {
5592 log_info ("%s v%.2f starting in restore-mode...", PROGNAME, (float) VERSION_BIN / 100);
5593
5594 log_info ("");
5595 }
5596 else
5597 {
5598 log_info ("%s v%.2f starting...", PROGNAME, (float) VERSION_BIN / 100);
5599
5600 log_info ("");
5601 }
5602 }
5603
5604 /**
5605 * sanity check
5606 */
5607
5608 if (attack_mode > 7)
5609 {
5610 log_error ("ERROR: Invalid attack-mode specified");
5611
5612 return (-1);
5613 }
5614
5615 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5616 {
5617 log_error ("ERROR: Invalid runtime specified");
5618
5619 return (-1);
5620 }
5621
5622 if (hash_mode_chgd && hash_mode > 13000) // just added to remove compiler warnings for hash_mode_chgd
5623 {
5624 log_error ("ERROR: Invalid hash-type specified");
5625
5626 return (-1);
5627 }
5628
5629 // renamed hash modes
5630
5631 if (hash_mode_chgd)
5632 {
5633 int n = -1;
5634
5635 switch (hash_mode)
5636 {
5637 case 123: n = 124;
5638 break;
5639 }
5640
5641 if (n >= 0)
5642 {
5643 log_error ("Old -m specified, use -m %d instead", n);
5644
5645 return (-1);
5646 }
5647 }
5648
5649 if (username == 1)
5650 {
5651 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5652 {
5653 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5654
5655 return (-1);
5656 }
5657 }
5658
5659 if (outfile_format > 16)
5660 {
5661 log_error ("ERROR: Invalid outfile-format specified");
5662
5663 return (-1);
5664 }
5665
5666 if (left == 1)
5667 {
5668 if (outfile_format_chgd == 1)
5669 {
5670 if (outfile_format > 1)
5671 {
5672 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5673
5674 return (-1);
5675 }
5676 }
5677 else
5678 {
5679 outfile_format = OUTFILE_FMT_HASH;
5680 }
5681 }
5682
5683 if (show == 1)
5684 {
5685 if (outfile_format_chgd == 1)
5686 {
5687 if ((outfile_format > 7) && (outfile_format < 16))
5688 {
5689 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
5690
5691 return (-1);
5692 }
5693 }
5694 }
5695
5696 if (increment_min < INCREMENT_MIN)
5697 {
5698 log_error ("ERROR: Invalid increment-min specified");
5699
5700 return (-1);
5701 }
5702
5703 if (increment_max > INCREMENT_MAX)
5704 {
5705 log_error ("ERROR: Invalid increment-max specified");
5706
5707 return (-1);
5708 }
5709
5710 if (increment_min > increment_max)
5711 {
5712 log_error ("ERROR: Invalid increment-min specified");
5713
5714 return (-1);
5715 }
5716
5717 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
5718 {
5719 log_error ("ERROR: increment is not allowed in attack-mode 0");
5720
5721 return (-1);
5722 }
5723
5724 if ((increment == 0) && (increment_min_chgd == 1))
5725 {
5726 log_error ("ERROR: increment-min is only supported together with increment switch");
5727
5728 return (-1);
5729 }
5730
5731 if ((increment == 0) && (increment_max_chgd == 1))
5732 {
5733 log_error ("ERROR: increment-max is only supported together with increment switch");
5734
5735 return (-1);
5736 }
5737
5738 if (rp_files_cnt && rp_gen)
5739 {
5740 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
5741
5742 return (-1);
5743 }
5744
5745 if (rp_files_cnt || rp_gen)
5746 {
5747 if (attack_mode != ATTACK_MODE_STRAIGHT)
5748 {
5749 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
5750
5751 return (-1);
5752 }
5753 }
5754
5755 if (rp_gen_func_min > rp_gen_func_max)
5756 {
5757 log_error ("ERROR: Invalid rp-gen-func-min specified");
5758
5759 return (-1);
5760 }
5761
5762 if (kernel_accel_chgd == 1)
5763 {
5764 if (workload_profile != WORKLOAD_PROFILE)
5765 {
5766 log_error ("ERROR: kernel-accel parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5767
5768 return (-1);
5769 }
5770
5771 if (kernel_accel < 1)
5772 {
5773 log_error ("ERROR: Invalid kernel-accel specified");
5774
5775 return (-1);
5776 }
5777
5778 if (kernel_accel > 800)
5779 {
5780 log_error ("ERROR: Invalid kernel-accel specified");
5781
5782 return (-1);
5783 }
5784 }
5785
5786 if (kernel_loops_chgd == 1)
5787 {
5788 if (workload_profile != WORKLOAD_PROFILE)
5789 {
5790 log_error ("ERROR: kernel-loops parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5791
5792 return (-1);
5793 }
5794
5795 if (kernel_loops < 1)
5796 {
5797 log_error ("ERROR: Invalid kernel-loops specified");
5798
5799 return (-1);
5800 }
5801
5802 if (kernel_loops > 1024)
5803 {
5804 log_error ("ERROR: Invalid kernel-loops specified");
5805
5806 return (-1);
5807 }
5808 }
5809
5810 if (benchmark == 1)
5811 {
5812 if (workload_profile != WORKLOAD_PROFILE)
5813 {
5814 log_error ("ERROR: Using the workload-profile in benchmark mode is not allowed");
5815
5816 return (-1);
5817 }
5818 }
5819
5820 if ((workload_profile < 1) || (workload_profile > 3))
5821 {
5822 log_error ("ERROR: workload-profile %i not available", workload_profile);
5823
5824 return (-1);
5825 }
5826
5827 if (show == 1 || left == 1)
5828 {
5829 attack_mode = ATTACK_MODE_NONE;
5830
5831 if (remove == 1)
5832 {
5833 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
5834
5835 return (-1);
5836 }
5837
5838 if (potfile_disable == 1)
5839 {
5840 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
5841
5842 return (-1);
5843 }
5844 }
5845
5846 uint attack_kern = ATTACK_KERN_NONE;
5847
5848 switch (attack_mode)
5849 {
5850 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
5851 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
5852 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
5853 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
5854 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
5855 }
5856
5857 if (benchmark == 0)
5858 {
5859 if (keyspace == 1)
5860 {
5861 int num_additional_params = 1;
5862
5863 if (attack_kern == ATTACK_KERN_COMBI)
5864 {
5865 num_additional_params = 2;
5866 }
5867
5868 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
5869
5870 if (keyspace_wordlist_specified == 0) optind--;
5871 }
5872
5873 if (attack_kern == ATTACK_KERN_NONE)
5874 {
5875 if ((optind + 1) != myargc)
5876 {
5877 usage_mini_print (myargv[0]);
5878
5879 return (-1);
5880 }
5881 }
5882 else if (attack_kern == ATTACK_KERN_STRAIGHT)
5883 {
5884 if ((optind + 1) > myargc)
5885 {
5886 usage_mini_print (myargv[0]);
5887
5888 return (-1);
5889 }
5890 }
5891 else if (attack_kern == ATTACK_KERN_COMBI)
5892 {
5893 if ((optind + 3) != myargc)
5894 {
5895 usage_mini_print (myargv[0]);
5896
5897 return (-1);
5898 }
5899 }
5900 else if (attack_kern == ATTACK_KERN_BF)
5901 {
5902 if ((optind + 1) > myargc)
5903 {
5904 usage_mini_print (myargv[0]);
5905
5906 return (-1);
5907 }
5908 }
5909 else
5910 {
5911 usage_mini_print (myargv[0]);
5912
5913 return (-1);
5914 }
5915 }
5916 else
5917 {
5918 if (myargv[optind] != 0)
5919 {
5920 log_error ("ERROR: Invalid argument for benchmark mode specified");
5921
5922 return (-1);
5923 }
5924
5925 if (attack_mode_chgd == 1)
5926 {
5927 if (attack_mode != ATTACK_MODE_BF)
5928 {
5929 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
5930
5931 return (-1);
5932 }
5933 }
5934
5935 if (benchmark_mode == 0)
5936 {
5937 // nothing to do
5938 }
5939 else if (benchmark_mode == 1)
5940 {
5941 if (kernel_accel_chgd == 1 || kernel_loops_chgd == 1)
5942 {
5943 log_error ("ERROR: Benchmark-mode 1 does not allow kernel-accel or kernel-loops changed");
5944
5945 return (-1);
5946 }
5947 }
5948 else
5949 {
5950 log_error ("ERROR: Benchmark-mode must be 0 or 1");
5951
5952 return (-1);
5953 }
5954 }
5955
5956 if (skip != 0 && limit != 0)
5957 {
5958 limit += skip;
5959 }
5960
5961 if (keyspace == 1)
5962 {
5963 if (show == 1)
5964 {
5965 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
5966
5967 return (-1);
5968 }
5969 else if (left == 1)
5970 {
5971 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
5972
5973 return (-1);
5974 }
5975
5976 potfile_disable = 1;
5977
5978 restore_disable = 1;
5979
5980 restore = 0;
5981
5982 weak_hash_threshold = 0;
5983
5984 quiet = 1;
5985 }
5986
5987 if (remove_timer_chgd == 1)
5988 {
5989 if (remove == 0)
5990 {
5991 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
5992
5993 return (-1);
5994 }
5995
5996 if (remove_timer < 1)
5997 {
5998 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
5999
6000 return (-1);
6001 }
6002 }
6003
6004 if (loopback == 1)
6005 {
6006 if (attack_mode == ATTACK_MODE_BF)
6007 {
6008 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6009
6010 return (-1);
6011 }
6012 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6013 {
6014 if ((rp_files_cnt == 0) && (rp_gen == 0))
6015 {
6016 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6017
6018 return (-1);
6019 }
6020 }
6021 }
6022
6023 if (debug_mode > 0)
6024 {
6025 if (attack_mode != ATTACK_MODE_STRAIGHT)
6026 {
6027 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6028
6029 return (-1);
6030 }
6031
6032 if ((rp_files_cnt == 0) && (rp_gen == 0))
6033 {
6034 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6035
6036 return (-1);
6037 }
6038 }
6039
6040 if (debug_mode > 4)
6041 {
6042 log_error ("ERROR: Invalid debug-mode specified");
6043
6044 return (-1);
6045 }
6046
6047 if (debug_file != NULL)
6048 {
6049 if (debug_mode < 1)
6050 {
6051 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6052
6053 return (-1);
6054 }
6055 }
6056
6057 if (induction_dir != NULL)
6058 {
6059 if (attack_mode == ATTACK_MODE_BF)
6060 {
6061 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6062
6063 return (-1);
6064 }
6065 }
6066
6067 /**
6068 * induction directory
6069 */
6070
6071 char *induction_directory = NULL;
6072
6073 if (attack_mode != ATTACK_MODE_BF)
6074 {
6075 if (induction_dir == NULL)
6076 {
6077 induction_directory = (char *) mymalloc (session_size);
6078
6079 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6080
6081 // create induction folder if it does not already exist
6082
6083 if (keyspace == 0)
6084 {
6085 if (rmdir (induction_directory) == -1)
6086 {
6087 if (errno == ENOENT)
6088 {
6089 // good, we can ignore
6090 }
6091 else if (errno == ENOTEMPTY)
6092 {
6093 char *induction_directory_mv = (char *) mymalloc (session_size);
6094
6095 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6096
6097 if (rename (induction_directory, induction_directory_mv) != 0)
6098 {
6099 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6100
6101 return (-1);
6102 }
6103 }
6104 else
6105 {
6106 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6107
6108 return (-1);
6109 }
6110 }
6111
6112 if (mkdir (induction_directory, 0700) == -1)
6113 {
6114 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6115
6116 return (-1);
6117 }
6118 }
6119 }
6120 else
6121 {
6122 induction_directory = induction_dir;
6123 }
6124 }
6125
6126 data.induction_directory = induction_directory;
6127
6128 /**
6129 * loopback
6130 */
6131
6132 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6133
6134 char *loopback_file = (char *) mymalloc (loopback_size);
6135
6136 /**
6137 * outfile-check directory
6138 */
6139
6140 char *outfile_check_directory = NULL;
6141
6142 if (outfile_check_dir == NULL)
6143 {
6144 outfile_check_directory = (char *) mymalloc (session_size);
6145
6146 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6147 }
6148 else
6149 {
6150 outfile_check_directory = outfile_check_dir;
6151 }
6152
6153 data.outfile_check_directory = outfile_check_directory;
6154
6155 if (keyspace == 0)
6156 {
6157 struct stat outfile_check_stat;
6158
6159 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6160 {
6161 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6162
6163 if (is_dir == 0)
6164 {
6165 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6166
6167 return (-1);
6168 }
6169 }
6170 else if (outfile_check_dir == NULL)
6171 {
6172 if (mkdir (outfile_check_directory, 0700) == -1)
6173 {
6174 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6175
6176 return (-1);
6177 }
6178 }
6179 }
6180
6181 /**
6182 * special other stuff
6183 */
6184
6185 if (hash_mode == 9710)
6186 {
6187 outfile_format = 5;
6188 outfile_format_chgd = 1;
6189 }
6190
6191 if (hash_mode == 9810)
6192 {
6193 outfile_format = 5;
6194 outfile_format_chgd = 1;
6195 }
6196
6197 if (hash_mode == 10410)
6198 {
6199 outfile_format = 5;
6200 outfile_format_chgd = 1;
6201 }
6202
6203 /**
6204 * store stuff
6205 */
6206
6207 data.hash_mode = hash_mode;
6208 data.restore = restore;
6209 data.restore_timer = restore_timer;
6210 data.restore_disable = restore_disable;
6211 data.status = status;
6212 data.status_timer = status_timer;
6213 data.status_automat = status_automat;
6214 data.loopback = loopback;
6215 data.runtime = runtime;
6216 data.remove = remove;
6217 data.remove_timer = remove_timer;
6218 data.debug_mode = debug_mode;
6219 data.debug_file = debug_file;
6220 data.username = username;
6221 data.quiet = quiet;
6222 data.outfile = outfile;
6223 data.outfile_format = outfile_format;
6224 data.outfile_autohex = outfile_autohex;
6225 data.hex_charset = hex_charset;
6226 data.hex_salt = hex_salt;
6227 data.hex_wordlist = hex_wordlist;
6228 data.separator = separator;
6229 data.rp_files = rp_files;
6230 data.rp_files_cnt = rp_files_cnt;
6231 data.rp_gen = rp_gen;
6232 data.rp_gen_seed = rp_gen_seed;
6233 data.force = force;
6234 data.benchmark = benchmark;
6235 data.skip = skip;
6236 data.limit = limit;
6237 data.powertune_enable = powertune_enable;
6238 data.logfile_disable = logfile_disable;
6239 data.truecrypt_keyfiles = truecrypt_keyfiles;
6240 data.scrypt_tmto = scrypt_tmto;
6241
6242 /**
6243 * cpu affinity
6244 */
6245
6246 if (cpu_affinity)
6247 {
6248 set_cpu_affinity (cpu_affinity);
6249 }
6250
6251 if (rp_gen_seed_chgd == 0)
6252 {
6253 srand (proc_start);
6254 }
6255 else
6256 {
6257 srand (rp_gen_seed);
6258 }
6259
6260 /**
6261 * logfile init
6262 */
6263
6264 if (logfile_disable == 0)
6265 {
6266 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6267
6268 char *logfile = (char *) mymalloc (logfile_size);
6269
6270 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6271
6272 data.logfile = logfile;
6273
6274 char *topid = logfile_generate_topid ();
6275
6276 data.topid = topid;
6277 }
6278
6279 // logfile_append() checks for logfile_disable internally to make it easier from here
6280
6281 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6282 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6283 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6284 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6285 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6286 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6287 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6288 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6289 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6290 #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));
6291
6292 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6293 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6294 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6295 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6296 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6297 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6298 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6299 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6300
6301 logfile_top_msg ("START");
6302
6303 logfile_top_uint (attack_mode);
6304 logfile_top_uint (attack_kern);
6305 logfile_top_uint (benchmark);
6306 logfile_top_uint (benchmark_mode);
6307 logfile_top_uint (bitmap_min);
6308 logfile_top_uint (bitmap_max);
6309 logfile_top_uint (debug_mode);
6310 logfile_top_uint (force);
6311 logfile_top_uint (kernel_accel);
6312 logfile_top_uint (kernel_loops);
6313 logfile_top_uint (gpu_temp_abort);
6314 logfile_top_uint (gpu_temp_disable);
6315 logfile_top_uint (gpu_temp_retain);
6316 logfile_top_uint (hash_mode);
6317 logfile_top_uint (hex_charset);
6318 logfile_top_uint (hex_salt);
6319 logfile_top_uint (hex_wordlist);
6320 logfile_top_uint (increment);
6321 logfile_top_uint (increment_max);
6322 logfile_top_uint (increment_min);
6323 logfile_top_uint (keyspace);
6324 logfile_top_uint (left);
6325 logfile_top_uint (logfile_disable);
6326 logfile_top_uint (loopback);
6327 logfile_top_uint (markov_classic);
6328 logfile_top_uint (markov_disable);
6329 logfile_top_uint (markov_threshold);
6330 logfile_top_uint (outfile_autohex);
6331 logfile_top_uint (outfile_check_timer);
6332 logfile_top_uint (outfile_format);
6333 logfile_top_uint (potfile_disable);
6334 logfile_top_uint (powertune_enable);
6335 logfile_top_uint (scrypt_tmto);
6336 logfile_top_uint (quiet);
6337 logfile_top_uint (remove);
6338 logfile_top_uint (remove_timer);
6339 logfile_top_uint (restore);
6340 logfile_top_uint (restore_disable);
6341 logfile_top_uint (restore_timer);
6342 logfile_top_uint (rp_gen);
6343 logfile_top_uint (rp_gen_func_max);
6344 logfile_top_uint (rp_gen_func_min);
6345 logfile_top_uint (rp_gen_seed);
6346 logfile_top_uint (runtime);
6347 logfile_top_uint (segment_size);
6348 logfile_top_uint (show);
6349 logfile_top_uint (status);
6350 logfile_top_uint (status_automat);
6351 logfile_top_uint (status_timer);
6352 logfile_top_uint (usage);
6353 logfile_top_uint (username);
6354 logfile_top_uint (version);
6355 logfile_top_uint (weak_hash_threshold);
6356 logfile_top_uint (workload_profile);
6357 logfile_top_uint64 (limit);
6358 logfile_top_uint64 (skip);
6359 logfile_top_char (separator);
6360 logfile_top_string (cpu_affinity);
6361 logfile_top_string (custom_charset_1);
6362 logfile_top_string (custom_charset_2);
6363 logfile_top_string (custom_charset_3);
6364 logfile_top_string (custom_charset_4);
6365 logfile_top_string (debug_file);
6366 logfile_top_string (opencl_devices);
6367 logfile_top_string (opencl_platform);
6368 logfile_top_string (induction_dir);
6369 logfile_top_string (markov_hcstat);
6370 logfile_top_string (outfile);
6371 logfile_top_string (outfile_check_dir);
6372 logfile_top_string (rule_buf_l);
6373 logfile_top_string (rule_buf_r);
6374 logfile_top_string (session);
6375 logfile_top_string (truecrypt_keyfiles);
6376
6377 /**
6378 * devices
6379 */
6380
6381 uint opencl_devicemask = devices_to_devicemask (opencl_devices);
6382
6383 /**
6384 * benchmark
6385 */
6386
6387 if (benchmark == 1)
6388 {
6389 /**
6390 * disable useless stuff for benchmark
6391 */
6392
6393 restore_timer = 0;
6394 status_timer = 0;
6395 restore_disable = 1;
6396 potfile_disable = 1;
6397 weak_hash_threshold = 0;
6398
6399 data.restore_timer = restore_timer;
6400 data.status_timer = status_timer;
6401 data.restore_disable = restore_disable;
6402
6403 if (benchmark_mode == 1)
6404 {
6405 markov_disable = 1;
6406 }
6407
6408 /**
6409 * force attack mode to be bruteforce
6410 */
6411
6412 attack_mode = ATTACK_MODE_BF;
6413 attack_kern = ATTACK_KERN_BF;
6414
6415 if (runtime_chgd == 0)
6416 {
6417 runtime = 4;
6418
6419 if (benchmark_mode == 1) runtime = 17;
6420
6421 data.runtime = runtime;
6422 }
6423 }
6424
6425 /**
6426 * config
6427 */
6428
6429 uint hash_type = 0;
6430 uint salt_type = 0;
6431 uint attack_exec = 0;
6432 uint opts_type = 0;
6433 uint kern_type = 0;
6434 uint dgst_size = 0;
6435 uint esalt_size = 0;
6436 uint opti_type = 0;
6437 uint dgst_pos0 = -1;
6438 uint dgst_pos1 = -1;
6439 uint dgst_pos2 = -1;
6440 uint dgst_pos3 = -1;
6441
6442 int (*parse_func) (char *, uint, hash_t *);
6443 int (*sort_by_digest) (const void *, const void *);
6444
6445 uint algorithm_pos = 0;
6446 uint algorithm_max = 1;
6447
6448 uint *algorithms = default_benchmark_algorithms;
6449
6450 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6451
6452 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6453 {
6454 /*
6455 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6456 * the following algos are skipped entirely
6457 */
6458
6459 if (algorithm_pos > 0)
6460 {
6461 local_free (rd);
6462
6463 rd = init_restore (argc, argv);
6464
6465 data.rd = rd;
6466 }
6467
6468 /**
6469 * update hash_mode in case of multihash benchmark
6470 */
6471
6472 if (benchmark == 1)
6473 {
6474 if (hash_mode_chgd == 0)
6475 {
6476 hash_mode = algorithms[algorithm_pos];
6477
6478 data.hash_mode = hash_mode;
6479 }
6480
6481 quiet = 1;
6482
6483 data.quiet = quiet;
6484 }
6485
6486 switch (hash_mode)
6487 {
6488 case 0: hash_type = HASH_TYPE_MD5;
6489 salt_type = SALT_TYPE_NONE;
6490 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6491 opts_type = OPTS_TYPE_PT_GENERATE_LE
6492 | OPTS_TYPE_PT_ADD80
6493 | OPTS_TYPE_PT_ADDBITS14;
6494 kern_type = KERN_TYPE_MD5;
6495 dgst_size = DGST_SIZE_4_4;
6496 parse_func = md5_parse_hash;
6497 sort_by_digest = sort_by_digest_4_4;
6498 opti_type = OPTI_TYPE_ZERO_BYTE
6499 | OPTI_TYPE_PRECOMPUTE_INIT
6500 | OPTI_TYPE_PRECOMPUTE_MERKLE
6501 | OPTI_TYPE_MEET_IN_MIDDLE
6502 | OPTI_TYPE_EARLY_SKIP
6503 | OPTI_TYPE_NOT_ITERATED
6504 | OPTI_TYPE_NOT_SALTED
6505 | OPTI_TYPE_RAW_HASH;
6506 dgst_pos0 = 0;
6507 dgst_pos1 = 3;
6508 dgst_pos2 = 2;
6509 dgst_pos3 = 1;
6510 break;
6511
6512 case 10: hash_type = HASH_TYPE_MD5;
6513 salt_type = SALT_TYPE_INTERN;
6514 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6515 opts_type = OPTS_TYPE_PT_GENERATE_LE
6516 | OPTS_TYPE_ST_ADD80
6517 | OPTS_TYPE_ST_ADDBITS14;
6518 kern_type = KERN_TYPE_MD5_PWSLT;
6519 dgst_size = DGST_SIZE_4_4;
6520 parse_func = md5s_parse_hash;
6521 sort_by_digest = sort_by_digest_4_4;
6522 opti_type = OPTI_TYPE_ZERO_BYTE
6523 | OPTI_TYPE_PRECOMPUTE_INIT
6524 | OPTI_TYPE_PRECOMPUTE_MERKLE
6525 | OPTI_TYPE_MEET_IN_MIDDLE
6526 | OPTI_TYPE_EARLY_SKIP
6527 | OPTI_TYPE_NOT_ITERATED
6528 | OPTI_TYPE_APPENDED_SALT
6529 | OPTI_TYPE_RAW_HASH;
6530 dgst_pos0 = 0;
6531 dgst_pos1 = 3;
6532 dgst_pos2 = 2;
6533 dgst_pos3 = 1;
6534 break;
6535
6536 case 11: hash_type = HASH_TYPE_MD5;
6537 salt_type = SALT_TYPE_INTERN;
6538 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6539 opts_type = OPTS_TYPE_PT_GENERATE_LE
6540 | OPTS_TYPE_ST_ADD80
6541 | OPTS_TYPE_ST_ADDBITS14;
6542 kern_type = KERN_TYPE_MD5_PWSLT;
6543 dgst_size = DGST_SIZE_4_4;
6544 parse_func = joomla_parse_hash;
6545 sort_by_digest = sort_by_digest_4_4;
6546 opti_type = OPTI_TYPE_ZERO_BYTE
6547 | OPTI_TYPE_PRECOMPUTE_INIT
6548 | OPTI_TYPE_PRECOMPUTE_MERKLE
6549 | OPTI_TYPE_MEET_IN_MIDDLE
6550 | OPTI_TYPE_EARLY_SKIP
6551 | OPTI_TYPE_NOT_ITERATED
6552 | OPTI_TYPE_APPENDED_SALT
6553 | OPTI_TYPE_RAW_HASH;
6554 dgst_pos0 = 0;
6555 dgst_pos1 = 3;
6556 dgst_pos2 = 2;
6557 dgst_pos3 = 1;
6558 break;
6559
6560 case 12: hash_type = HASH_TYPE_MD5;
6561 salt_type = SALT_TYPE_INTERN;
6562 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6563 opts_type = OPTS_TYPE_PT_GENERATE_LE
6564 | OPTS_TYPE_ST_ADD80
6565 | OPTS_TYPE_ST_ADDBITS14;
6566 kern_type = KERN_TYPE_MD5_PWSLT;
6567 dgst_size = DGST_SIZE_4_4;
6568 parse_func = postgresql_parse_hash;
6569 sort_by_digest = sort_by_digest_4_4;
6570 opti_type = OPTI_TYPE_ZERO_BYTE
6571 | OPTI_TYPE_PRECOMPUTE_INIT
6572 | OPTI_TYPE_PRECOMPUTE_MERKLE
6573 | OPTI_TYPE_MEET_IN_MIDDLE
6574 | OPTI_TYPE_EARLY_SKIP
6575 | OPTI_TYPE_NOT_ITERATED
6576 | OPTI_TYPE_APPENDED_SALT
6577 | OPTI_TYPE_RAW_HASH;
6578 dgst_pos0 = 0;
6579 dgst_pos1 = 3;
6580 dgst_pos2 = 2;
6581 dgst_pos3 = 1;
6582 break;
6583
6584 case 20: hash_type = HASH_TYPE_MD5;
6585 salt_type = SALT_TYPE_INTERN;
6586 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6587 opts_type = OPTS_TYPE_PT_GENERATE_LE
6588 | OPTS_TYPE_PT_ADD80
6589 | OPTS_TYPE_PT_ADDBITS14;
6590 kern_type = KERN_TYPE_MD5_SLTPW;
6591 dgst_size = DGST_SIZE_4_4;
6592 parse_func = md5s_parse_hash;
6593 sort_by_digest = sort_by_digest_4_4;
6594 opti_type = OPTI_TYPE_ZERO_BYTE
6595 | OPTI_TYPE_PRECOMPUTE_INIT
6596 | OPTI_TYPE_PRECOMPUTE_MERKLE
6597 | OPTI_TYPE_EARLY_SKIP
6598 | OPTI_TYPE_NOT_ITERATED
6599 | OPTI_TYPE_PREPENDED_SALT
6600 | OPTI_TYPE_RAW_HASH;
6601 dgst_pos0 = 0;
6602 dgst_pos1 = 3;
6603 dgst_pos2 = 2;
6604 dgst_pos3 = 1;
6605 break;
6606
6607 case 21: hash_type = HASH_TYPE_MD5;
6608 salt_type = SALT_TYPE_INTERN;
6609 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6610 opts_type = OPTS_TYPE_PT_GENERATE_LE
6611 | OPTS_TYPE_PT_ADD80
6612 | OPTS_TYPE_PT_ADDBITS14;
6613 kern_type = KERN_TYPE_MD5_SLTPW;
6614 dgst_size = DGST_SIZE_4_4;
6615 parse_func = osc_parse_hash;
6616 sort_by_digest = sort_by_digest_4_4;
6617 opti_type = OPTI_TYPE_ZERO_BYTE
6618 | OPTI_TYPE_PRECOMPUTE_INIT
6619 | OPTI_TYPE_PRECOMPUTE_MERKLE
6620 | OPTI_TYPE_EARLY_SKIP
6621 | OPTI_TYPE_NOT_ITERATED
6622 | OPTI_TYPE_PREPENDED_SALT
6623 | OPTI_TYPE_RAW_HASH;
6624 dgst_pos0 = 0;
6625 dgst_pos1 = 3;
6626 dgst_pos2 = 2;
6627 dgst_pos3 = 1;
6628 break;
6629
6630 case 22: hash_type = HASH_TYPE_MD5;
6631 salt_type = SALT_TYPE_EMBEDDED;
6632 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6633 opts_type = OPTS_TYPE_PT_GENERATE_LE
6634 | OPTS_TYPE_PT_ADD80
6635 | OPTS_TYPE_PT_ADDBITS14;
6636 kern_type = KERN_TYPE_MD5_SLTPW;
6637 dgst_size = DGST_SIZE_4_4;
6638 parse_func = netscreen_parse_hash;
6639 sort_by_digest = sort_by_digest_4_4;
6640 opti_type = OPTI_TYPE_ZERO_BYTE
6641 | OPTI_TYPE_PRECOMPUTE_INIT
6642 | OPTI_TYPE_PRECOMPUTE_MERKLE
6643 | OPTI_TYPE_EARLY_SKIP
6644 | OPTI_TYPE_NOT_ITERATED
6645 | OPTI_TYPE_PREPENDED_SALT
6646 | OPTI_TYPE_RAW_HASH;
6647 dgst_pos0 = 0;
6648 dgst_pos1 = 3;
6649 dgst_pos2 = 2;
6650 dgst_pos3 = 1;
6651 break;
6652
6653 case 23: hash_type = HASH_TYPE_MD5;
6654 salt_type = SALT_TYPE_EMBEDDED;
6655 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6656 opts_type = OPTS_TYPE_PT_GENERATE_LE
6657 | OPTS_TYPE_PT_ADD80
6658 | OPTS_TYPE_PT_ADDBITS14;
6659 kern_type = KERN_TYPE_MD5_SLTPW;
6660 dgst_size = DGST_SIZE_4_4;
6661 parse_func = skype_parse_hash;
6662 sort_by_digest = sort_by_digest_4_4;
6663 opti_type = OPTI_TYPE_ZERO_BYTE
6664 | OPTI_TYPE_PRECOMPUTE_INIT
6665 | OPTI_TYPE_PRECOMPUTE_MERKLE
6666 | OPTI_TYPE_EARLY_SKIP
6667 | OPTI_TYPE_NOT_ITERATED
6668 | OPTI_TYPE_PREPENDED_SALT
6669 | OPTI_TYPE_RAW_HASH;
6670 dgst_pos0 = 0;
6671 dgst_pos1 = 3;
6672 dgst_pos2 = 2;
6673 dgst_pos3 = 1;
6674 break;
6675
6676 case 30: hash_type = HASH_TYPE_MD5;
6677 salt_type = SALT_TYPE_INTERN;
6678 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6679 opts_type = OPTS_TYPE_PT_GENERATE_LE
6680 | OPTS_TYPE_PT_UNICODE
6681 | OPTS_TYPE_ST_ADD80
6682 | OPTS_TYPE_ST_ADDBITS14;
6683 kern_type = KERN_TYPE_MD5_PWUSLT;
6684 dgst_size = DGST_SIZE_4_4;
6685 parse_func = md5s_parse_hash;
6686 sort_by_digest = sort_by_digest_4_4;
6687 opti_type = OPTI_TYPE_ZERO_BYTE
6688 | OPTI_TYPE_PRECOMPUTE_INIT
6689 | OPTI_TYPE_PRECOMPUTE_MERKLE
6690 | OPTI_TYPE_MEET_IN_MIDDLE
6691 | OPTI_TYPE_EARLY_SKIP
6692 | OPTI_TYPE_NOT_ITERATED
6693 | OPTI_TYPE_APPENDED_SALT
6694 | OPTI_TYPE_RAW_HASH;
6695 dgst_pos0 = 0;
6696 dgst_pos1 = 3;
6697 dgst_pos2 = 2;
6698 dgst_pos3 = 1;
6699 break;
6700
6701 case 40: hash_type = HASH_TYPE_MD5;
6702 salt_type = SALT_TYPE_INTERN;
6703 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6704 opts_type = OPTS_TYPE_PT_GENERATE_LE
6705 | OPTS_TYPE_PT_ADD80
6706 | OPTS_TYPE_PT_ADDBITS14
6707 | OPTS_TYPE_PT_UNICODE;
6708 kern_type = KERN_TYPE_MD5_SLTPWU;
6709 dgst_size = DGST_SIZE_4_4;
6710 parse_func = md5s_parse_hash;
6711 sort_by_digest = sort_by_digest_4_4;
6712 opti_type = OPTI_TYPE_ZERO_BYTE
6713 | OPTI_TYPE_PRECOMPUTE_INIT
6714 | OPTI_TYPE_PRECOMPUTE_MERKLE
6715 | OPTI_TYPE_EARLY_SKIP
6716 | OPTI_TYPE_NOT_ITERATED
6717 | OPTI_TYPE_PREPENDED_SALT
6718 | OPTI_TYPE_RAW_HASH;
6719 dgst_pos0 = 0;
6720 dgst_pos1 = 3;
6721 dgst_pos2 = 2;
6722 dgst_pos3 = 1;
6723 break;
6724
6725 case 50: hash_type = HASH_TYPE_MD5;
6726 salt_type = SALT_TYPE_INTERN;
6727 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6728 opts_type = OPTS_TYPE_PT_GENERATE_LE
6729 | OPTS_TYPE_ST_ADD80
6730 | OPTS_TYPE_ST_ADDBITS14;
6731 kern_type = KERN_TYPE_HMACMD5_PW;
6732 dgst_size = DGST_SIZE_4_4;
6733 parse_func = hmacmd5_parse_hash;
6734 sort_by_digest = sort_by_digest_4_4;
6735 opti_type = OPTI_TYPE_ZERO_BYTE
6736 | OPTI_TYPE_NOT_ITERATED;
6737 dgst_pos0 = 0;
6738 dgst_pos1 = 3;
6739 dgst_pos2 = 2;
6740 dgst_pos3 = 1;
6741 break;
6742
6743 case 60: hash_type = HASH_TYPE_MD5;
6744 salt_type = SALT_TYPE_INTERN;
6745 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6746 opts_type = OPTS_TYPE_PT_GENERATE_LE
6747 | OPTS_TYPE_PT_ADD80
6748 | OPTS_TYPE_PT_ADDBITS14;
6749 kern_type = KERN_TYPE_HMACMD5_SLT;
6750 dgst_size = DGST_SIZE_4_4;
6751 parse_func = hmacmd5_parse_hash;
6752 sort_by_digest = sort_by_digest_4_4;
6753 opti_type = OPTI_TYPE_ZERO_BYTE
6754 | OPTI_TYPE_NOT_ITERATED;
6755 dgst_pos0 = 0;
6756 dgst_pos1 = 3;
6757 dgst_pos2 = 2;
6758 dgst_pos3 = 1;
6759 break;
6760
6761 case 100: hash_type = HASH_TYPE_SHA1;
6762 salt_type = SALT_TYPE_NONE;
6763 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6764 opts_type = OPTS_TYPE_PT_GENERATE_BE
6765 | OPTS_TYPE_PT_ADD80
6766 | OPTS_TYPE_PT_ADDBITS15;
6767 kern_type = KERN_TYPE_SHA1;
6768 dgst_size = DGST_SIZE_4_5;
6769 parse_func = sha1_parse_hash;
6770 sort_by_digest = sort_by_digest_4_5;
6771 opti_type = OPTI_TYPE_ZERO_BYTE
6772 | OPTI_TYPE_PRECOMPUTE_INIT
6773 | OPTI_TYPE_PRECOMPUTE_MERKLE
6774 | OPTI_TYPE_EARLY_SKIP
6775 | OPTI_TYPE_NOT_ITERATED
6776 | OPTI_TYPE_NOT_SALTED
6777 | OPTI_TYPE_RAW_HASH;
6778 dgst_pos0 = 3;
6779 dgst_pos1 = 4;
6780 dgst_pos2 = 2;
6781 dgst_pos3 = 1;
6782 break;
6783
6784 case 101: hash_type = HASH_TYPE_SHA1;
6785 salt_type = SALT_TYPE_NONE;
6786 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6787 opts_type = OPTS_TYPE_PT_GENERATE_BE
6788 | OPTS_TYPE_PT_ADD80
6789 | OPTS_TYPE_PT_ADDBITS15;
6790 kern_type = KERN_TYPE_SHA1;
6791 dgst_size = DGST_SIZE_4_5;
6792 parse_func = sha1b64_parse_hash;
6793 sort_by_digest = sort_by_digest_4_5;
6794 opti_type = OPTI_TYPE_ZERO_BYTE
6795 | OPTI_TYPE_PRECOMPUTE_INIT
6796 | OPTI_TYPE_PRECOMPUTE_MERKLE
6797 | OPTI_TYPE_EARLY_SKIP
6798 | OPTI_TYPE_NOT_ITERATED
6799 | OPTI_TYPE_NOT_SALTED
6800 | OPTI_TYPE_RAW_HASH;
6801 dgst_pos0 = 3;
6802 dgst_pos1 = 4;
6803 dgst_pos2 = 2;
6804 dgst_pos3 = 1;
6805 break;
6806
6807 case 110: hash_type = HASH_TYPE_SHA1;
6808 salt_type = SALT_TYPE_INTERN;
6809 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6810 opts_type = OPTS_TYPE_PT_GENERATE_BE
6811 | OPTS_TYPE_ST_ADD80
6812 | OPTS_TYPE_ST_ADDBITS15;
6813 kern_type = KERN_TYPE_SHA1_PWSLT;
6814 dgst_size = DGST_SIZE_4_5;
6815 parse_func = sha1s_parse_hash;
6816 sort_by_digest = sort_by_digest_4_5;
6817 opti_type = OPTI_TYPE_ZERO_BYTE
6818 | OPTI_TYPE_PRECOMPUTE_INIT
6819 | OPTI_TYPE_PRECOMPUTE_MERKLE
6820 | OPTI_TYPE_EARLY_SKIP
6821 | OPTI_TYPE_NOT_ITERATED
6822 | OPTI_TYPE_APPENDED_SALT
6823 | OPTI_TYPE_RAW_HASH;
6824 dgst_pos0 = 3;
6825 dgst_pos1 = 4;
6826 dgst_pos2 = 2;
6827 dgst_pos3 = 1;
6828 break;
6829
6830 case 111: hash_type = HASH_TYPE_SHA1;
6831 salt_type = SALT_TYPE_EMBEDDED;
6832 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6833 opts_type = OPTS_TYPE_PT_GENERATE_BE
6834 | OPTS_TYPE_ST_ADD80
6835 | OPTS_TYPE_ST_ADDBITS15;
6836 kern_type = KERN_TYPE_SHA1_PWSLT;
6837 dgst_size = DGST_SIZE_4_5;
6838 parse_func = sha1b64s_parse_hash;
6839 sort_by_digest = sort_by_digest_4_5;
6840 opti_type = OPTI_TYPE_ZERO_BYTE
6841 | OPTI_TYPE_PRECOMPUTE_INIT
6842 | OPTI_TYPE_PRECOMPUTE_MERKLE
6843 | OPTI_TYPE_EARLY_SKIP
6844 | OPTI_TYPE_NOT_ITERATED
6845 | OPTI_TYPE_APPENDED_SALT
6846 | OPTI_TYPE_RAW_HASH;
6847 dgst_pos0 = 3;
6848 dgst_pos1 = 4;
6849 dgst_pos2 = 2;
6850 dgst_pos3 = 1;
6851 break;
6852
6853 case 112: hash_type = HASH_TYPE_SHA1;
6854 salt_type = SALT_TYPE_INTERN;
6855 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6856 opts_type = OPTS_TYPE_PT_GENERATE_BE
6857 | OPTS_TYPE_ST_ADD80
6858 | OPTS_TYPE_ST_ADDBITS15
6859 | OPTS_TYPE_ST_HEX;
6860 kern_type = KERN_TYPE_SHA1_PWSLT;
6861 dgst_size = DGST_SIZE_4_5;
6862 parse_func = oracles_parse_hash;
6863 sort_by_digest = sort_by_digest_4_5;
6864 opti_type = OPTI_TYPE_ZERO_BYTE
6865 | OPTI_TYPE_PRECOMPUTE_INIT
6866 | OPTI_TYPE_PRECOMPUTE_MERKLE
6867 | OPTI_TYPE_EARLY_SKIP
6868 | OPTI_TYPE_NOT_ITERATED
6869 | OPTI_TYPE_APPENDED_SALT
6870 | OPTI_TYPE_RAW_HASH;
6871 dgst_pos0 = 3;
6872 dgst_pos1 = 4;
6873 dgst_pos2 = 2;
6874 dgst_pos3 = 1;
6875 break;
6876
6877 case 120: hash_type = HASH_TYPE_SHA1;
6878 salt_type = SALT_TYPE_INTERN;
6879 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6880 opts_type = OPTS_TYPE_PT_GENERATE_BE
6881 | OPTS_TYPE_PT_ADD80
6882 | OPTS_TYPE_PT_ADDBITS15;
6883 kern_type = KERN_TYPE_SHA1_SLTPW;
6884 dgst_size = DGST_SIZE_4_5;
6885 parse_func = sha1s_parse_hash;
6886 sort_by_digest = sort_by_digest_4_5;
6887 opti_type = OPTI_TYPE_ZERO_BYTE
6888 | OPTI_TYPE_PRECOMPUTE_INIT
6889 | OPTI_TYPE_PRECOMPUTE_MERKLE
6890 | OPTI_TYPE_EARLY_SKIP
6891 | OPTI_TYPE_NOT_ITERATED
6892 | OPTI_TYPE_PREPENDED_SALT
6893 | OPTI_TYPE_RAW_HASH;
6894 dgst_pos0 = 3;
6895 dgst_pos1 = 4;
6896 dgst_pos2 = 2;
6897 dgst_pos3 = 1;
6898 break;
6899
6900 case 121: hash_type = HASH_TYPE_SHA1;
6901 salt_type = SALT_TYPE_INTERN;
6902 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6903 opts_type = OPTS_TYPE_PT_GENERATE_BE
6904 | OPTS_TYPE_PT_ADD80
6905 | OPTS_TYPE_PT_ADDBITS15
6906 | OPTS_TYPE_ST_LOWER;
6907 kern_type = KERN_TYPE_SHA1_SLTPW;
6908 dgst_size = DGST_SIZE_4_5;
6909 parse_func = smf_parse_hash;
6910 sort_by_digest = sort_by_digest_4_5;
6911 opti_type = OPTI_TYPE_ZERO_BYTE
6912 | OPTI_TYPE_PRECOMPUTE_INIT
6913 | OPTI_TYPE_PRECOMPUTE_MERKLE
6914 | OPTI_TYPE_EARLY_SKIP
6915 | OPTI_TYPE_NOT_ITERATED
6916 | OPTI_TYPE_PREPENDED_SALT
6917 | OPTI_TYPE_RAW_HASH;
6918 dgst_pos0 = 3;
6919 dgst_pos1 = 4;
6920 dgst_pos2 = 2;
6921 dgst_pos3 = 1;
6922 break;
6923
6924 case 122: hash_type = HASH_TYPE_SHA1;
6925 salt_type = SALT_TYPE_EMBEDDED;
6926 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6927 opts_type = OPTS_TYPE_PT_GENERATE_BE
6928 | OPTS_TYPE_PT_ADD80
6929 | OPTS_TYPE_PT_ADDBITS15
6930 | OPTS_TYPE_ST_HEX;
6931 kern_type = KERN_TYPE_SHA1_SLTPW;
6932 dgst_size = DGST_SIZE_4_5;
6933 parse_func = osx1_parse_hash;
6934 sort_by_digest = sort_by_digest_4_5;
6935 opti_type = OPTI_TYPE_ZERO_BYTE
6936 | OPTI_TYPE_PRECOMPUTE_INIT
6937 | OPTI_TYPE_PRECOMPUTE_MERKLE
6938 | OPTI_TYPE_EARLY_SKIP
6939 | OPTI_TYPE_NOT_ITERATED
6940 | OPTI_TYPE_PREPENDED_SALT
6941 | OPTI_TYPE_RAW_HASH;
6942 dgst_pos0 = 3;
6943 dgst_pos1 = 4;
6944 dgst_pos2 = 2;
6945 dgst_pos3 = 1;
6946 break;
6947
6948 case 124: hash_type = HASH_TYPE_SHA1;
6949 salt_type = SALT_TYPE_EMBEDDED;
6950 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6951 opts_type = OPTS_TYPE_PT_GENERATE_BE
6952 | OPTS_TYPE_PT_ADD80
6953 | OPTS_TYPE_PT_ADDBITS15;
6954 kern_type = KERN_TYPE_SHA1_SLTPW;
6955 dgst_size = DGST_SIZE_4_5;
6956 parse_func = djangosha1_parse_hash;
6957 sort_by_digest = sort_by_digest_4_5;
6958 opti_type = OPTI_TYPE_ZERO_BYTE
6959 | OPTI_TYPE_PRECOMPUTE_INIT
6960 | OPTI_TYPE_PRECOMPUTE_MERKLE
6961 | OPTI_TYPE_EARLY_SKIP
6962 | OPTI_TYPE_NOT_ITERATED
6963 | OPTI_TYPE_PREPENDED_SALT
6964 | OPTI_TYPE_RAW_HASH;
6965 dgst_pos0 = 3;
6966 dgst_pos1 = 4;
6967 dgst_pos2 = 2;
6968 dgst_pos3 = 1;
6969 break;
6970
6971 case 130: hash_type = HASH_TYPE_SHA1;
6972 salt_type = SALT_TYPE_INTERN;
6973 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6974 opts_type = OPTS_TYPE_PT_GENERATE_BE
6975 | OPTS_TYPE_PT_UNICODE
6976 | OPTS_TYPE_ST_ADD80
6977 | OPTS_TYPE_ST_ADDBITS15;
6978 kern_type = KERN_TYPE_SHA1_PWUSLT;
6979 dgst_size = DGST_SIZE_4_5;
6980 parse_func = sha1s_parse_hash;
6981 sort_by_digest = sort_by_digest_4_5;
6982 opti_type = OPTI_TYPE_ZERO_BYTE
6983 | OPTI_TYPE_PRECOMPUTE_INIT
6984 | OPTI_TYPE_PRECOMPUTE_MERKLE
6985 | OPTI_TYPE_EARLY_SKIP
6986 | OPTI_TYPE_NOT_ITERATED
6987 | OPTI_TYPE_APPENDED_SALT
6988 | OPTI_TYPE_RAW_HASH;
6989 dgst_pos0 = 3;
6990 dgst_pos1 = 4;
6991 dgst_pos2 = 2;
6992 dgst_pos3 = 1;
6993 break;
6994
6995 case 131: hash_type = HASH_TYPE_SHA1;
6996 salt_type = SALT_TYPE_EMBEDDED;
6997 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6998 opts_type = OPTS_TYPE_PT_GENERATE_BE
6999 | OPTS_TYPE_PT_UNICODE
7000 | OPTS_TYPE_PT_UPPER
7001 | OPTS_TYPE_ST_ADD80
7002 | OPTS_TYPE_ST_ADDBITS15
7003 | OPTS_TYPE_ST_HEX;
7004 kern_type = KERN_TYPE_SHA1_PWUSLT;
7005 dgst_size = DGST_SIZE_4_5;
7006 parse_func = mssql2000_parse_hash;
7007 sort_by_digest = sort_by_digest_4_5;
7008 opti_type = OPTI_TYPE_ZERO_BYTE
7009 | OPTI_TYPE_PRECOMPUTE_INIT
7010 | OPTI_TYPE_PRECOMPUTE_MERKLE
7011 | OPTI_TYPE_EARLY_SKIP
7012 | OPTI_TYPE_NOT_ITERATED
7013 | OPTI_TYPE_APPENDED_SALT
7014 | OPTI_TYPE_RAW_HASH;
7015 dgst_pos0 = 3;
7016 dgst_pos1 = 4;
7017 dgst_pos2 = 2;
7018 dgst_pos3 = 1;
7019 break;
7020
7021 case 132: hash_type = HASH_TYPE_SHA1;
7022 salt_type = SALT_TYPE_EMBEDDED;
7023 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7024 opts_type = OPTS_TYPE_PT_GENERATE_BE
7025 | OPTS_TYPE_PT_UNICODE
7026 | OPTS_TYPE_ST_ADD80
7027 | OPTS_TYPE_ST_ADDBITS15
7028 | OPTS_TYPE_ST_HEX;
7029 kern_type = KERN_TYPE_SHA1_PWUSLT;
7030 dgst_size = DGST_SIZE_4_5;
7031 parse_func = mssql2005_parse_hash;
7032 sort_by_digest = sort_by_digest_4_5;
7033 opti_type = OPTI_TYPE_ZERO_BYTE
7034 | OPTI_TYPE_PRECOMPUTE_INIT
7035 | OPTI_TYPE_PRECOMPUTE_MERKLE
7036 | OPTI_TYPE_EARLY_SKIP
7037 | OPTI_TYPE_NOT_ITERATED
7038 | OPTI_TYPE_APPENDED_SALT
7039 | OPTI_TYPE_RAW_HASH;
7040 dgst_pos0 = 3;
7041 dgst_pos1 = 4;
7042 dgst_pos2 = 2;
7043 dgst_pos3 = 1;
7044 break;
7045
7046 case 133: hash_type = HASH_TYPE_SHA1;
7047 salt_type = SALT_TYPE_EMBEDDED;
7048 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7049 opts_type = OPTS_TYPE_PT_GENERATE_BE
7050 | OPTS_TYPE_PT_UNICODE
7051 | OPTS_TYPE_ST_ADD80
7052 | OPTS_TYPE_ST_ADDBITS15;
7053 kern_type = KERN_TYPE_SHA1_PWUSLT;
7054 dgst_size = DGST_SIZE_4_5;
7055 parse_func = peoplesoft_parse_hash;
7056 sort_by_digest = sort_by_digest_4_5;
7057 opti_type = OPTI_TYPE_ZERO_BYTE
7058 | OPTI_TYPE_PRECOMPUTE_INIT
7059 | OPTI_TYPE_PRECOMPUTE_MERKLE
7060 | OPTI_TYPE_EARLY_SKIP
7061 | OPTI_TYPE_NOT_ITERATED
7062 | OPTI_TYPE_APPENDED_SALT
7063 | OPTI_TYPE_RAW_HASH;
7064 dgst_pos0 = 3;
7065 dgst_pos1 = 4;
7066 dgst_pos2 = 2;
7067 dgst_pos3 = 1;
7068 break;
7069
7070 case 140: hash_type = HASH_TYPE_SHA1;
7071 salt_type = SALT_TYPE_INTERN;
7072 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7073 opts_type = OPTS_TYPE_PT_GENERATE_BE
7074 | OPTS_TYPE_PT_ADD80
7075 | OPTS_TYPE_PT_ADDBITS15
7076 | OPTS_TYPE_PT_UNICODE;
7077 kern_type = KERN_TYPE_SHA1_SLTPWU;
7078 dgst_size = DGST_SIZE_4_5;
7079 parse_func = sha1s_parse_hash;
7080 sort_by_digest = sort_by_digest_4_5;
7081 opti_type = OPTI_TYPE_ZERO_BYTE
7082 | OPTI_TYPE_PRECOMPUTE_INIT
7083 | OPTI_TYPE_PRECOMPUTE_MERKLE
7084 | OPTI_TYPE_EARLY_SKIP
7085 | OPTI_TYPE_NOT_ITERATED
7086 | OPTI_TYPE_PREPENDED_SALT
7087 | OPTI_TYPE_RAW_HASH;
7088 dgst_pos0 = 3;
7089 dgst_pos1 = 4;
7090 dgst_pos2 = 2;
7091 dgst_pos3 = 1;
7092 break;
7093
7094 case 141: hash_type = HASH_TYPE_SHA1;
7095 salt_type = SALT_TYPE_EMBEDDED;
7096 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7097 opts_type = OPTS_TYPE_PT_GENERATE_BE
7098 | OPTS_TYPE_PT_ADD80
7099 | OPTS_TYPE_PT_ADDBITS15
7100 | OPTS_TYPE_PT_UNICODE
7101 | OPTS_TYPE_ST_BASE64;
7102 kern_type = KERN_TYPE_SHA1_SLTPWU;
7103 dgst_size = DGST_SIZE_4_5;
7104 parse_func = episerver_parse_hash;
7105 sort_by_digest = sort_by_digest_4_5;
7106 opti_type = OPTI_TYPE_ZERO_BYTE
7107 | OPTI_TYPE_PRECOMPUTE_INIT
7108 | OPTI_TYPE_PRECOMPUTE_MERKLE
7109 | OPTI_TYPE_EARLY_SKIP
7110 | OPTI_TYPE_NOT_ITERATED
7111 | OPTI_TYPE_PREPENDED_SALT
7112 | OPTI_TYPE_RAW_HASH;
7113 dgst_pos0 = 3;
7114 dgst_pos1 = 4;
7115 dgst_pos2 = 2;
7116 dgst_pos3 = 1;
7117 break;
7118
7119 case 150: hash_type = HASH_TYPE_SHA1;
7120 salt_type = SALT_TYPE_INTERN;
7121 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7122 opts_type = OPTS_TYPE_PT_GENERATE_BE
7123 | OPTS_TYPE_ST_ADD80
7124 | OPTS_TYPE_ST_ADDBITS15;
7125 kern_type = KERN_TYPE_HMACSHA1_PW;
7126 dgst_size = DGST_SIZE_4_5;
7127 parse_func = hmacsha1_parse_hash;
7128 sort_by_digest = sort_by_digest_4_5;
7129 opti_type = OPTI_TYPE_ZERO_BYTE
7130 | OPTI_TYPE_NOT_ITERATED;
7131 dgst_pos0 = 3;
7132 dgst_pos1 = 4;
7133 dgst_pos2 = 2;
7134 dgst_pos3 = 1;
7135 break;
7136
7137 case 160: hash_type = HASH_TYPE_SHA1;
7138 salt_type = SALT_TYPE_INTERN;
7139 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7140 opts_type = OPTS_TYPE_PT_GENERATE_BE
7141 | OPTS_TYPE_PT_ADD80
7142 | OPTS_TYPE_PT_ADDBITS15;
7143 kern_type = KERN_TYPE_HMACSHA1_SLT;
7144 dgst_size = DGST_SIZE_4_5;
7145 parse_func = hmacsha1_parse_hash;
7146 sort_by_digest = sort_by_digest_4_5;
7147 opti_type = OPTI_TYPE_ZERO_BYTE
7148 | OPTI_TYPE_NOT_ITERATED;
7149 dgst_pos0 = 3;
7150 dgst_pos1 = 4;
7151 dgst_pos2 = 2;
7152 dgst_pos3 = 1;
7153 break;
7154
7155 case 190: hash_type = HASH_TYPE_SHA1;
7156 salt_type = SALT_TYPE_NONE;
7157 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7158 opts_type = OPTS_TYPE_PT_GENERATE_BE
7159 | OPTS_TYPE_PT_ADD80
7160 | OPTS_TYPE_PT_ADDBITS15;
7161 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7162 dgst_size = DGST_SIZE_4_5;
7163 parse_func = sha1linkedin_parse_hash;
7164 sort_by_digest = sort_by_digest_4_5;
7165 opti_type = OPTI_TYPE_ZERO_BYTE
7166 | OPTI_TYPE_PRECOMPUTE_INIT
7167 | OPTI_TYPE_EARLY_SKIP
7168 | OPTI_TYPE_NOT_ITERATED
7169 | OPTI_TYPE_NOT_SALTED;
7170 dgst_pos0 = 0;
7171 dgst_pos1 = 4;
7172 dgst_pos2 = 3;
7173 dgst_pos3 = 2;
7174 break;
7175
7176 case 200: hash_type = HASH_TYPE_MYSQL;
7177 salt_type = SALT_TYPE_NONE;
7178 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7179 opts_type = 0;
7180 kern_type = KERN_TYPE_MYSQL;
7181 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7182 parse_func = mysql323_parse_hash;
7183 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7184 opti_type = OPTI_TYPE_ZERO_BYTE;
7185 dgst_pos0 = 0;
7186 dgst_pos1 = 1;
7187 dgst_pos2 = 2;
7188 dgst_pos3 = 3;
7189 break;
7190
7191 case 300: hash_type = HASH_TYPE_SHA1;
7192 salt_type = SALT_TYPE_NONE;
7193 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7194 opts_type = OPTS_TYPE_PT_GENERATE_BE
7195 | OPTS_TYPE_PT_ADD80
7196 | OPTS_TYPE_PT_ADDBITS15;
7197 kern_type = KERN_TYPE_MYSQL41;
7198 dgst_size = DGST_SIZE_4_5;
7199 parse_func = sha1_parse_hash;
7200 sort_by_digest = sort_by_digest_4_5;
7201 opti_type = OPTI_TYPE_ZERO_BYTE
7202 | OPTI_TYPE_PRECOMPUTE_INIT
7203 | OPTI_TYPE_PRECOMPUTE_MERKLE
7204 | OPTI_TYPE_EARLY_SKIP
7205 | OPTI_TYPE_NOT_ITERATED
7206 | OPTI_TYPE_NOT_SALTED;
7207 dgst_pos0 = 3;
7208 dgst_pos1 = 4;
7209 dgst_pos2 = 2;
7210 dgst_pos3 = 1;
7211 break;
7212
7213 case 400: hash_type = HASH_TYPE_MD5;
7214 salt_type = SALT_TYPE_EMBEDDED;
7215 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7216 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7217 kern_type = KERN_TYPE_PHPASS;
7218 dgst_size = DGST_SIZE_4_4;
7219 parse_func = phpass_parse_hash;
7220 sort_by_digest = sort_by_digest_4_4;
7221 opti_type = OPTI_TYPE_ZERO_BYTE;
7222 dgst_pos0 = 0;
7223 dgst_pos1 = 1;
7224 dgst_pos2 = 2;
7225 dgst_pos3 = 3;
7226 break;
7227
7228 case 500: hash_type = HASH_TYPE_MD5;
7229 salt_type = SALT_TYPE_EMBEDDED;
7230 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7231 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7232 kern_type = KERN_TYPE_MD5CRYPT;
7233 dgst_size = DGST_SIZE_4_4;
7234 parse_func = md5crypt_parse_hash;
7235 sort_by_digest = sort_by_digest_4_4;
7236 opti_type = OPTI_TYPE_ZERO_BYTE;
7237 dgst_pos0 = 0;
7238 dgst_pos1 = 1;
7239 dgst_pos2 = 2;
7240 dgst_pos3 = 3;
7241 break;
7242
7243 case 501: hash_type = HASH_TYPE_MD5;
7244 salt_type = SALT_TYPE_EMBEDDED;
7245 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7246 opts_type = OPTS_TYPE_PT_GENERATE_LE
7247 | OPTS_TYPE_HASH_COPY;
7248 kern_type = KERN_TYPE_MD5CRYPT;
7249 dgst_size = DGST_SIZE_4_4;
7250 parse_func = juniper_parse_hash;
7251 sort_by_digest = sort_by_digest_4_4;
7252 opti_type = OPTI_TYPE_ZERO_BYTE;
7253 dgst_pos0 = 0;
7254 dgst_pos1 = 1;
7255 dgst_pos2 = 2;
7256 dgst_pos3 = 3;
7257 break;
7258
7259 case 900: hash_type = HASH_TYPE_MD4;
7260 salt_type = SALT_TYPE_NONE;
7261 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7262 opts_type = OPTS_TYPE_PT_GENERATE_LE
7263 | OPTS_TYPE_PT_ADD80
7264 | OPTS_TYPE_PT_ADDBITS14;
7265 kern_type = KERN_TYPE_MD4;
7266 dgst_size = DGST_SIZE_4_4;
7267 parse_func = md4_parse_hash;
7268 sort_by_digest = sort_by_digest_4_4;
7269 opti_type = OPTI_TYPE_ZERO_BYTE
7270 | OPTI_TYPE_PRECOMPUTE_INIT
7271 | OPTI_TYPE_PRECOMPUTE_MERKLE
7272 | OPTI_TYPE_MEET_IN_MIDDLE
7273 | OPTI_TYPE_EARLY_SKIP
7274 | OPTI_TYPE_NOT_ITERATED
7275 | OPTI_TYPE_NOT_SALTED
7276 | OPTI_TYPE_RAW_HASH;
7277 dgst_pos0 = 0;
7278 dgst_pos1 = 3;
7279 dgst_pos2 = 2;
7280 dgst_pos3 = 1;
7281 break;
7282
7283 case 1000: hash_type = HASH_TYPE_MD4;
7284 salt_type = SALT_TYPE_NONE;
7285 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7286 opts_type = OPTS_TYPE_PT_GENERATE_LE
7287 | OPTS_TYPE_PT_ADD80
7288 | OPTS_TYPE_PT_ADDBITS14
7289 | OPTS_TYPE_PT_UNICODE;
7290 kern_type = KERN_TYPE_MD4_PWU;
7291 dgst_size = DGST_SIZE_4_4;
7292 parse_func = md4_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_MEET_IN_MIDDLE
7298 | OPTI_TYPE_EARLY_SKIP
7299 | OPTI_TYPE_NOT_ITERATED
7300 | OPTI_TYPE_NOT_SALTED
7301 | OPTI_TYPE_RAW_HASH;
7302 dgst_pos0 = 0;
7303 dgst_pos1 = 3;
7304 dgst_pos2 = 2;
7305 dgst_pos3 = 1;
7306 break;
7307
7308 case 1100: hash_type = HASH_TYPE_MD4;
7309 salt_type = SALT_TYPE_INTERN;
7310 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7311 opts_type = OPTS_TYPE_PT_GENERATE_LE
7312 | OPTS_TYPE_PT_ADD80
7313 | OPTS_TYPE_PT_ADDBITS14
7314 | OPTS_TYPE_PT_UNICODE
7315 | OPTS_TYPE_ST_ADD80
7316 | OPTS_TYPE_ST_UNICODE
7317 | OPTS_TYPE_ST_LOWER;
7318 kern_type = KERN_TYPE_MD44_PWUSLT;
7319 dgst_size = DGST_SIZE_4_4;
7320 parse_func = dcc_parse_hash;
7321 sort_by_digest = sort_by_digest_4_4;
7322 opti_type = OPTI_TYPE_ZERO_BYTE
7323 | OPTI_TYPE_PRECOMPUTE_INIT
7324 | OPTI_TYPE_PRECOMPUTE_MERKLE
7325 | OPTI_TYPE_EARLY_SKIP
7326 | OPTI_TYPE_NOT_ITERATED;
7327 dgst_pos0 = 0;
7328 dgst_pos1 = 3;
7329 dgst_pos2 = 2;
7330 dgst_pos3 = 1;
7331 break;
7332
7333 case 1400: hash_type = HASH_TYPE_SHA256;
7334 salt_type = SALT_TYPE_NONE;
7335 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7336 opts_type = OPTS_TYPE_PT_GENERATE_BE
7337 | OPTS_TYPE_PT_ADD80
7338 | OPTS_TYPE_PT_ADDBITS15;
7339 kern_type = KERN_TYPE_SHA256;
7340 dgst_size = DGST_SIZE_4_8;
7341 parse_func = sha256_parse_hash;
7342 sort_by_digest = sort_by_digest_4_8;
7343 opti_type = OPTI_TYPE_ZERO_BYTE
7344 | OPTI_TYPE_PRECOMPUTE_INIT
7345 | OPTI_TYPE_PRECOMPUTE_MERKLE
7346 | OPTI_TYPE_EARLY_SKIP
7347 | OPTI_TYPE_NOT_ITERATED
7348 | OPTI_TYPE_NOT_SALTED
7349 | OPTI_TYPE_RAW_HASH;
7350 dgst_pos0 = 3;
7351 dgst_pos1 = 7;
7352 dgst_pos2 = 2;
7353 dgst_pos3 = 6;
7354 break;
7355
7356 case 1410: hash_type = HASH_TYPE_SHA256;
7357 salt_type = SALT_TYPE_INTERN;
7358 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7359 opts_type = OPTS_TYPE_PT_GENERATE_BE
7360 | OPTS_TYPE_ST_ADD80
7361 | OPTS_TYPE_ST_ADDBITS15;
7362 kern_type = KERN_TYPE_SHA256_PWSLT;
7363 dgst_size = DGST_SIZE_4_8;
7364 parse_func = sha256s_parse_hash;
7365 sort_by_digest = sort_by_digest_4_8;
7366 opti_type = OPTI_TYPE_ZERO_BYTE
7367 | OPTI_TYPE_PRECOMPUTE_INIT
7368 | OPTI_TYPE_PRECOMPUTE_MERKLE
7369 | OPTI_TYPE_EARLY_SKIP
7370 | OPTI_TYPE_NOT_ITERATED
7371 | OPTI_TYPE_APPENDED_SALT
7372 | OPTI_TYPE_RAW_HASH;
7373 dgst_pos0 = 3;
7374 dgst_pos1 = 7;
7375 dgst_pos2 = 2;
7376 dgst_pos3 = 6;
7377 break;
7378
7379 case 1420: hash_type = HASH_TYPE_SHA256;
7380 salt_type = SALT_TYPE_INTERN;
7381 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7382 opts_type = OPTS_TYPE_PT_GENERATE_BE
7383 | OPTS_TYPE_PT_ADD80
7384 | OPTS_TYPE_PT_ADDBITS15;
7385 kern_type = KERN_TYPE_SHA256_SLTPW;
7386 dgst_size = DGST_SIZE_4_8;
7387 parse_func = sha256s_parse_hash;
7388 sort_by_digest = sort_by_digest_4_8;
7389 opti_type = OPTI_TYPE_ZERO_BYTE
7390 | OPTI_TYPE_PRECOMPUTE_INIT
7391 | OPTI_TYPE_PRECOMPUTE_MERKLE
7392 | OPTI_TYPE_EARLY_SKIP
7393 | OPTI_TYPE_NOT_ITERATED
7394 | OPTI_TYPE_PREPENDED_SALT
7395 | OPTI_TYPE_RAW_HASH;
7396 dgst_pos0 = 3;
7397 dgst_pos1 = 7;
7398 dgst_pos2 = 2;
7399 dgst_pos3 = 6;
7400 break;
7401
7402 case 1421: hash_type = HASH_TYPE_SHA256;
7403 salt_type = SALT_TYPE_EMBEDDED;
7404 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7405 opts_type = OPTS_TYPE_PT_GENERATE_BE
7406 | OPTS_TYPE_PT_ADD80
7407 | OPTS_TYPE_PT_ADDBITS15;
7408 kern_type = KERN_TYPE_SHA256_SLTPW;
7409 dgst_size = DGST_SIZE_4_8;
7410 parse_func = hmailserver_parse_hash;
7411 sort_by_digest = sort_by_digest_4_8;
7412 opti_type = OPTI_TYPE_ZERO_BYTE
7413 | OPTI_TYPE_PRECOMPUTE_INIT
7414 | OPTI_TYPE_PRECOMPUTE_MERKLE
7415 | OPTI_TYPE_EARLY_SKIP
7416 | OPTI_TYPE_NOT_ITERATED
7417 | OPTI_TYPE_PREPENDED_SALT
7418 | OPTI_TYPE_RAW_HASH;
7419 dgst_pos0 = 3;
7420 dgst_pos1 = 7;
7421 dgst_pos2 = 2;
7422 dgst_pos3 = 6;
7423 break;
7424
7425 case 1430: hash_type = HASH_TYPE_SHA256;
7426 salt_type = SALT_TYPE_INTERN;
7427 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7428 opts_type = OPTS_TYPE_PT_GENERATE_BE
7429 | OPTS_TYPE_PT_UNICODE
7430 | OPTS_TYPE_ST_ADD80
7431 | OPTS_TYPE_ST_ADDBITS15;
7432 kern_type = KERN_TYPE_SHA256_PWUSLT;
7433 dgst_size = DGST_SIZE_4_8;
7434 parse_func = sha256s_parse_hash;
7435 sort_by_digest = sort_by_digest_4_8;
7436 opti_type = OPTI_TYPE_ZERO_BYTE
7437 | OPTI_TYPE_PRECOMPUTE_INIT
7438 | OPTI_TYPE_PRECOMPUTE_MERKLE
7439 | OPTI_TYPE_EARLY_SKIP
7440 | OPTI_TYPE_NOT_ITERATED
7441 | OPTI_TYPE_APPENDED_SALT
7442 | OPTI_TYPE_RAW_HASH;
7443 dgst_pos0 = 3;
7444 dgst_pos1 = 7;
7445 dgst_pos2 = 2;
7446 dgst_pos3 = 6;
7447 break;
7448
7449 case 1440: hash_type = HASH_TYPE_SHA256;
7450 salt_type = SALT_TYPE_INTERN;
7451 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7452 opts_type = OPTS_TYPE_PT_GENERATE_BE
7453 | OPTS_TYPE_PT_ADD80
7454 | OPTS_TYPE_PT_ADDBITS15
7455 | OPTS_TYPE_PT_UNICODE;
7456 kern_type = KERN_TYPE_SHA256_SLTPWU;
7457 dgst_size = DGST_SIZE_4_8;
7458 parse_func = sha256s_parse_hash;
7459 sort_by_digest = sort_by_digest_4_8;
7460 opti_type = OPTI_TYPE_ZERO_BYTE
7461 | OPTI_TYPE_PRECOMPUTE_INIT
7462 | OPTI_TYPE_PRECOMPUTE_MERKLE
7463 | OPTI_TYPE_EARLY_SKIP
7464 | OPTI_TYPE_NOT_ITERATED
7465 | OPTI_TYPE_PREPENDED_SALT
7466 | OPTI_TYPE_RAW_HASH;
7467 dgst_pos0 = 3;
7468 dgst_pos1 = 7;
7469 dgst_pos2 = 2;
7470 dgst_pos3 = 6;
7471 break;
7472
7473 case 1441: hash_type = HASH_TYPE_SHA256;
7474 salt_type = SALT_TYPE_EMBEDDED;
7475 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7476 opts_type = OPTS_TYPE_PT_GENERATE_BE
7477 | OPTS_TYPE_PT_ADD80
7478 | OPTS_TYPE_PT_ADDBITS15
7479 | OPTS_TYPE_PT_UNICODE
7480 | OPTS_TYPE_ST_BASE64;
7481 kern_type = KERN_TYPE_SHA256_SLTPWU;
7482 dgst_size = DGST_SIZE_4_8;
7483 parse_func = episerver4_parse_hash;
7484 sort_by_digest = sort_by_digest_4_8;
7485 opti_type = OPTI_TYPE_ZERO_BYTE
7486 | OPTI_TYPE_PRECOMPUTE_INIT
7487 | OPTI_TYPE_PRECOMPUTE_MERKLE
7488 | OPTI_TYPE_EARLY_SKIP
7489 | OPTI_TYPE_NOT_ITERATED
7490 | OPTI_TYPE_PREPENDED_SALT
7491 | OPTI_TYPE_RAW_HASH;
7492 dgst_pos0 = 3;
7493 dgst_pos1 = 7;
7494 dgst_pos2 = 2;
7495 dgst_pos3 = 6;
7496 break;
7497
7498 case 1450: hash_type = HASH_TYPE_SHA256;
7499 salt_type = SALT_TYPE_INTERN;
7500 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7501 opts_type = OPTS_TYPE_PT_GENERATE_BE
7502 | OPTS_TYPE_ST_ADD80;
7503 kern_type = KERN_TYPE_HMACSHA256_PW;
7504 dgst_size = DGST_SIZE_4_8;
7505 parse_func = hmacsha256_parse_hash;
7506 sort_by_digest = sort_by_digest_4_8;
7507 opti_type = OPTI_TYPE_ZERO_BYTE
7508 | OPTI_TYPE_NOT_ITERATED;
7509 dgst_pos0 = 3;
7510 dgst_pos1 = 7;
7511 dgst_pos2 = 2;
7512 dgst_pos3 = 6;
7513 break;
7514
7515 case 1460: hash_type = HASH_TYPE_SHA256;
7516 salt_type = SALT_TYPE_INTERN;
7517 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7518 opts_type = OPTS_TYPE_PT_GENERATE_BE
7519 | OPTS_TYPE_PT_ADD80
7520 | OPTS_TYPE_PT_ADDBITS15;
7521 kern_type = KERN_TYPE_HMACSHA256_SLT;
7522 dgst_size = DGST_SIZE_4_8;
7523 parse_func = hmacsha256_parse_hash;
7524 sort_by_digest = sort_by_digest_4_8;
7525 opti_type = OPTI_TYPE_ZERO_BYTE
7526 | OPTI_TYPE_NOT_ITERATED;
7527 dgst_pos0 = 3;
7528 dgst_pos1 = 7;
7529 dgst_pos2 = 2;
7530 dgst_pos3 = 6;
7531 break;
7532
7533 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7534 salt_type = SALT_TYPE_EMBEDDED;
7535 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7536 opts_type = OPTS_TYPE_PT_GENERATE_LE
7537 | OPTS_TYPE_PT_BITSLICE;
7538 kern_type = KERN_TYPE_DESCRYPT;
7539 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7540 parse_func = descrypt_parse_hash;
7541 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7542 opti_type = OPTI_TYPE_ZERO_BYTE
7543 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7544 dgst_pos0 = 0;
7545 dgst_pos1 = 1;
7546 dgst_pos2 = 2;
7547 dgst_pos3 = 3;
7548 break;
7549
7550 case 1600: hash_type = HASH_TYPE_MD5;
7551 salt_type = SALT_TYPE_EMBEDDED;
7552 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7553 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7554 kern_type = KERN_TYPE_APR1CRYPT;
7555 dgst_size = DGST_SIZE_4_4;
7556 parse_func = md5apr1_parse_hash;
7557 sort_by_digest = sort_by_digest_4_4;
7558 opti_type = OPTI_TYPE_ZERO_BYTE;
7559 dgst_pos0 = 0;
7560 dgst_pos1 = 1;
7561 dgst_pos2 = 2;
7562 dgst_pos3 = 3;
7563 break;
7564
7565 case 1700: hash_type = HASH_TYPE_SHA512;
7566 salt_type = SALT_TYPE_NONE;
7567 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7568 opts_type = OPTS_TYPE_PT_GENERATE_BE
7569 | OPTS_TYPE_PT_ADD80
7570 | OPTS_TYPE_PT_ADDBITS15;
7571 kern_type = KERN_TYPE_SHA512;
7572 dgst_size = DGST_SIZE_8_8;
7573 parse_func = sha512_parse_hash;
7574 sort_by_digest = sort_by_digest_8_8;
7575 opti_type = OPTI_TYPE_ZERO_BYTE
7576 | OPTI_TYPE_PRECOMPUTE_INIT
7577 | OPTI_TYPE_PRECOMPUTE_MERKLE
7578 | OPTI_TYPE_EARLY_SKIP
7579 | OPTI_TYPE_NOT_ITERATED
7580 | OPTI_TYPE_NOT_SALTED
7581 | OPTI_TYPE_RAW_HASH;
7582 dgst_pos0 = 14;
7583 dgst_pos1 = 15;
7584 dgst_pos2 = 6;
7585 dgst_pos3 = 7;
7586 break;
7587
7588 case 1710: hash_type = HASH_TYPE_SHA512;
7589 salt_type = SALT_TYPE_INTERN;
7590 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7591 opts_type = OPTS_TYPE_PT_GENERATE_BE
7592 | OPTS_TYPE_ST_ADD80
7593 | OPTS_TYPE_ST_ADDBITS15;
7594 kern_type = KERN_TYPE_SHA512_PWSLT;
7595 dgst_size = DGST_SIZE_8_8;
7596 parse_func = sha512s_parse_hash;
7597 sort_by_digest = sort_by_digest_8_8;
7598 opti_type = OPTI_TYPE_ZERO_BYTE
7599 | OPTI_TYPE_PRECOMPUTE_INIT
7600 | OPTI_TYPE_PRECOMPUTE_MERKLE
7601 | OPTI_TYPE_EARLY_SKIP
7602 | OPTI_TYPE_NOT_ITERATED
7603 | OPTI_TYPE_APPENDED_SALT
7604 | OPTI_TYPE_RAW_HASH;
7605 dgst_pos0 = 14;
7606 dgst_pos1 = 15;
7607 dgst_pos2 = 6;
7608 dgst_pos3 = 7;
7609 break;
7610
7611 case 1711: hash_type = HASH_TYPE_SHA512;
7612 salt_type = SALT_TYPE_EMBEDDED;
7613 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7614 opts_type = OPTS_TYPE_PT_GENERATE_BE
7615 | OPTS_TYPE_ST_ADD80
7616 | OPTS_TYPE_ST_ADDBITS15;
7617 kern_type = KERN_TYPE_SHA512_PWSLT;
7618 dgst_size = DGST_SIZE_8_8;
7619 parse_func = sha512b64s_parse_hash;
7620 sort_by_digest = sort_by_digest_8_8;
7621 opti_type = OPTI_TYPE_ZERO_BYTE
7622 | OPTI_TYPE_PRECOMPUTE_INIT
7623 | OPTI_TYPE_PRECOMPUTE_MERKLE
7624 | OPTI_TYPE_EARLY_SKIP
7625 | OPTI_TYPE_NOT_ITERATED
7626 | OPTI_TYPE_APPENDED_SALT
7627 | OPTI_TYPE_RAW_HASH;
7628 dgst_pos0 = 14;
7629 dgst_pos1 = 15;
7630 dgst_pos2 = 6;
7631 dgst_pos3 = 7;
7632 break;
7633
7634 case 1720: hash_type = HASH_TYPE_SHA512;
7635 salt_type = SALT_TYPE_INTERN;
7636 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7637 opts_type = OPTS_TYPE_PT_GENERATE_BE
7638 | OPTS_TYPE_PT_ADD80
7639 | OPTS_TYPE_PT_ADDBITS15;
7640 kern_type = KERN_TYPE_SHA512_SLTPW;
7641 dgst_size = DGST_SIZE_8_8;
7642 parse_func = sha512s_parse_hash;
7643 sort_by_digest = sort_by_digest_8_8;
7644 opti_type = OPTI_TYPE_ZERO_BYTE
7645 | OPTI_TYPE_PRECOMPUTE_INIT
7646 | OPTI_TYPE_PRECOMPUTE_MERKLE
7647 | OPTI_TYPE_EARLY_SKIP
7648 | OPTI_TYPE_NOT_ITERATED
7649 | OPTI_TYPE_PREPENDED_SALT
7650 | OPTI_TYPE_RAW_HASH;
7651 dgst_pos0 = 14;
7652 dgst_pos1 = 15;
7653 dgst_pos2 = 6;
7654 dgst_pos3 = 7;
7655 break;
7656
7657 case 1722: hash_type = HASH_TYPE_SHA512;
7658 salt_type = SALT_TYPE_EMBEDDED;
7659 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7660 opts_type = OPTS_TYPE_PT_GENERATE_BE
7661 | OPTS_TYPE_PT_ADD80
7662 | OPTS_TYPE_PT_ADDBITS15
7663 | OPTS_TYPE_ST_HEX;
7664 kern_type = KERN_TYPE_SHA512_SLTPW;
7665 dgst_size = DGST_SIZE_8_8;
7666 parse_func = osx512_parse_hash;
7667 sort_by_digest = sort_by_digest_8_8;
7668 opti_type = OPTI_TYPE_ZERO_BYTE
7669 | OPTI_TYPE_PRECOMPUTE_INIT
7670 | OPTI_TYPE_PRECOMPUTE_MERKLE
7671 | OPTI_TYPE_EARLY_SKIP
7672 | OPTI_TYPE_NOT_ITERATED
7673 | OPTI_TYPE_PREPENDED_SALT
7674 | OPTI_TYPE_RAW_HASH;
7675 dgst_pos0 = 14;
7676 dgst_pos1 = 15;
7677 dgst_pos2 = 6;
7678 dgst_pos3 = 7;
7679 break;
7680
7681 case 1730: hash_type = HASH_TYPE_SHA512;
7682 salt_type = SALT_TYPE_INTERN;
7683 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7684 opts_type = OPTS_TYPE_PT_GENERATE_BE
7685 | OPTS_TYPE_PT_UNICODE
7686 | OPTS_TYPE_ST_ADD80
7687 | OPTS_TYPE_ST_ADDBITS15;
7688 kern_type = KERN_TYPE_SHA512_PWSLTU;
7689 dgst_size = DGST_SIZE_8_8;
7690 parse_func = sha512s_parse_hash;
7691 sort_by_digest = sort_by_digest_8_8;
7692 opti_type = OPTI_TYPE_ZERO_BYTE
7693 | OPTI_TYPE_PRECOMPUTE_INIT
7694 | OPTI_TYPE_PRECOMPUTE_MERKLE
7695 | OPTI_TYPE_EARLY_SKIP
7696 | OPTI_TYPE_NOT_ITERATED
7697 | OPTI_TYPE_APPENDED_SALT
7698 | OPTI_TYPE_RAW_HASH;
7699 dgst_pos0 = 14;
7700 dgst_pos1 = 15;
7701 dgst_pos2 = 6;
7702 dgst_pos3 = 7;
7703 break;
7704
7705 case 1731: hash_type = HASH_TYPE_SHA512;
7706 salt_type = SALT_TYPE_EMBEDDED;
7707 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7708 opts_type = OPTS_TYPE_PT_GENERATE_BE
7709 | OPTS_TYPE_PT_UNICODE
7710 | OPTS_TYPE_ST_ADD80
7711 | OPTS_TYPE_ST_ADDBITS15
7712 | OPTS_TYPE_ST_HEX;
7713 kern_type = KERN_TYPE_SHA512_PWSLTU;
7714 dgst_size = DGST_SIZE_8_8;
7715 parse_func = mssql2012_parse_hash;
7716 sort_by_digest = sort_by_digest_8_8;
7717 opti_type = OPTI_TYPE_ZERO_BYTE
7718 | OPTI_TYPE_PRECOMPUTE_INIT
7719 | OPTI_TYPE_PRECOMPUTE_MERKLE
7720 | OPTI_TYPE_EARLY_SKIP
7721 | OPTI_TYPE_NOT_ITERATED
7722 | OPTI_TYPE_APPENDED_SALT
7723 | OPTI_TYPE_RAW_HASH;
7724 dgst_pos0 = 14;
7725 dgst_pos1 = 15;
7726 dgst_pos2 = 6;
7727 dgst_pos3 = 7;
7728 break;
7729
7730 case 1740: hash_type = HASH_TYPE_SHA512;
7731 salt_type = SALT_TYPE_INTERN;
7732 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7733 opts_type = OPTS_TYPE_PT_GENERATE_BE
7734 | OPTS_TYPE_PT_ADD80
7735 | OPTS_TYPE_PT_ADDBITS15
7736 | OPTS_TYPE_PT_UNICODE;
7737 kern_type = KERN_TYPE_SHA512_SLTPWU;
7738 dgst_size = DGST_SIZE_8_8;
7739 parse_func = sha512s_parse_hash;
7740 sort_by_digest = sort_by_digest_8_8;
7741 opti_type = OPTI_TYPE_ZERO_BYTE
7742 | OPTI_TYPE_PRECOMPUTE_INIT
7743 | OPTI_TYPE_PRECOMPUTE_MERKLE
7744 | OPTI_TYPE_EARLY_SKIP
7745 | OPTI_TYPE_NOT_ITERATED
7746 | OPTI_TYPE_PREPENDED_SALT
7747 | OPTI_TYPE_RAW_HASH;
7748 dgst_pos0 = 14;
7749 dgst_pos1 = 15;
7750 dgst_pos2 = 6;
7751 dgst_pos3 = 7;
7752 break;
7753
7754 case 1750: hash_type = HASH_TYPE_SHA512;
7755 salt_type = SALT_TYPE_INTERN;
7756 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7757 opts_type = OPTS_TYPE_PT_GENERATE_BE
7758 | OPTS_TYPE_ST_ADD80;
7759 kern_type = KERN_TYPE_HMACSHA512_PW;
7760 dgst_size = DGST_SIZE_8_8;
7761 parse_func = hmacsha512_parse_hash;
7762 sort_by_digest = sort_by_digest_8_8;
7763 opti_type = OPTI_TYPE_ZERO_BYTE
7764 | OPTI_TYPE_NOT_ITERATED;
7765 dgst_pos0 = 14;
7766 dgst_pos1 = 15;
7767 dgst_pos2 = 6;
7768 dgst_pos3 = 7;
7769 break;
7770
7771 case 1760: hash_type = HASH_TYPE_SHA512;
7772 salt_type = SALT_TYPE_INTERN;
7773 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7774 opts_type = OPTS_TYPE_PT_GENERATE_BE
7775 | OPTS_TYPE_PT_ADD80
7776 | OPTS_TYPE_PT_ADDBITS15;
7777 kern_type = KERN_TYPE_HMACSHA512_SLT;
7778 dgst_size = DGST_SIZE_8_8;
7779 parse_func = hmacsha512_parse_hash;
7780 sort_by_digest = sort_by_digest_8_8;
7781 opti_type = OPTI_TYPE_ZERO_BYTE
7782 | OPTI_TYPE_NOT_ITERATED;
7783 dgst_pos0 = 14;
7784 dgst_pos1 = 15;
7785 dgst_pos2 = 6;
7786 dgst_pos3 = 7;
7787 break;
7788
7789 case 1800: hash_type = HASH_TYPE_SHA512;
7790 salt_type = SALT_TYPE_EMBEDDED;
7791 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7792 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7793 kern_type = KERN_TYPE_SHA512CRYPT;
7794 dgst_size = DGST_SIZE_8_8;
7795 parse_func = sha512crypt_parse_hash;
7796 sort_by_digest = sort_by_digest_8_8;
7797 opti_type = OPTI_TYPE_ZERO_BYTE;
7798 dgst_pos0 = 0;
7799 dgst_pos1 = 1;
7800 dgst_pos2 = 2;
7801 dgst_pos3 = 3;
7802 break;
7803
7804 case 2100: hash_type = HASH_TYPE_DCC2;
7805 salt_type = SALT_TYPE_EMBEDDED;
7806 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7807 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
7808 | OPTS_TYPE_ST_LOWER
7809 | OPTS_TYPE_ST_UNICODE;
7810 kern_type = KERN_TYPE_DCC2;
7811 dgst_size = DGST_SIZE_4_4;
7812 parse_func = dcc2_parse_hash;
7813 sort_by_digest = sort_by_digest_4_4;
7814 opti_type = OPTI_TYPE_ZERO_BYTE;
7815 dgst_pos0 = 0;
7816 dgst_pos1 = 1;
7817 dgst_pos2 = 2;
7818 dgst_pos3 = 3;
7819 break;
7820
7821 case 2400: hash_type = HASH_TYPE_MD5;
7822 salt_type = SALT_TYPE_NONE;
7823 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7824 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7825 kern_type = KERN_TYPE_MD5PIX;
7826 dgst_size = DGST_SIZE_4_4;
7827 parse_func = md5pix_parse_hash;
7828 sort_by_digest = sort_by_digest_4_4;
7829 opti_type = OPTI_TYPE_ZERO_BYTE
7830 | OPTI_TYPE_PRECOMPUTE_INIT
7831 | OPTI_TYPE_PRECOMPUTE_MERKLE
7832 | OPTI_TYPE_EARLY_SKIP
7833 | OPTI_TYPE_NOT_ITERATED
7834 | OPTI_TYPE_NOT_SALTED;
7835 dgst_pos0 = 0;
7836 dgst_pos1 = 3;
7837 dgst_pos2 = 2;
7838 dgst_pos3 = 1;
7839 break;
7840
7841 case 2410: hash_type = HASH_TYPE_MD5;
7842 salt_type = SALT_TYPE_INTERN;
7843 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7844 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7845 kern_type = KERN_TYPE_MD5ASA;
7846 dgst_size = DGST_SIZE_4_4;
7847 parse_func = md5asa_parse_hash;
7848 sort_by_digest = sort_by_digest_4_4;
7849 opti_type = OPTI_TYPE_ZERO_BYTE
7850 | OPTI_TYPE_PRECOMPUTE_INIT
7851 | OPTI_TYPE_PRECOMPUTE_MERKLE
7852 | OPTI_TYPE_EARLY_SKIP
7853 | OPTI_TYPE_NOT_ITERATED;
7854 dgst_pos0 = 0;
7855 dgst_pos1 = 3;
7856 dgst_pos2 = 2;
7857 dgst_pos3 = 1;
7858 break;
7859
7860 case 2500: hash_type = HASH_TYPE_WPA;
7861 salt_type = SALT_TYPE_EMBEDDED;
7862 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7863 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7864 kern_type = KERN_TYPE_WPA;
7865 dgst_size = DGST_SIZE_4_4;
7866 parse_func = wpa_parse_hash;
7867 sort_by_digest = sort_by_digest_4_4;
7868 opti_type = OPTI_TYPE_ZERO_BYTE;
7869 dgst_pos0 = 0;
7870 dgst_pos1 = 1;
7871 dgst_pos2 = 2;
7872 dgst_pos3 = 3;
7873 break;
7874
7875 case 2600: hash_type = HASH_TYPE_MD5;
7876 salt_type = SALT_TYPE_VIRTUAL;
7877 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7878 opts_type = OPTS_TYPE_PT_GENERATE_LE
7879 | OPTS_TYPE_PT_ADD80
7880 | OPTS_TYPE_PT_ADDBITS14
7881 | OPTS_TYPE_ST_ADD80;
7882 kern_type = KERN_TYPE_MD55_PWSLT1;
7883 dgst_size = DGST_SIZE_4_4;
7884 parse_func = md5md5_parse_hash;
7885 sort_by_digest = sort_by_digest_4_4;
7886 opti_type = OPTI_TYPE_ZERO_BYTE
7887 | OPTI_TYPE_PRECOMPUTE_INIT
7888 | OPTI_TYPE_PRECOMPUTE_MERKLE
7889 | OPTI_TYPE_EARLY_SKIP;
7890 dgst_pos0 = 0;
7891 dgst_pos1 = 3;
7892 dgst_pos2 = 2;
7893 dgst_pos3 = 1;
7894 break;
7895
7896 case 2611: hash_type = HASH_TYPE_MD5;
7897 salt_type = SALT_TYPE_INTERN;
7898 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7899 opts_type = OPTS_TYPE_PT_GENERATE_LE
7900 | OPTS_TYPE_PT_ADD80
7901 | OPTS_TYPE_PT_ADDBITS14
7902 | OPTS_TYPE_ST_ADD80;
7903 kern_type = KERN_TYPE_MD55_PWSLT1;
7904 dgst_size = DGST_SIZE_4_4;
7905 parse_func = vb3_parse_hash;
7906 sort_by_digest = sort_by_digest_4_4;
7907 opti_type = OPTI_TYPE_ZERO_BYTE
7908 | OPTI_TYPE_PRECOMPUTE_INIT
7909 | OPTI_TYPE_PRECOMPUTE_MERKLE
7910 | OPTI_TYPE_EARLY_SKIP;
7911 dgst_pos0 = 0;
7912 dgst_pos1 = 3;
7913 dgst_pos2 = 2;
7914 dgst_pos3 = 1;
7915 break;
7916
7917 case 2612: hash_type = HASH_TYPE_MD5;
7918 salt_type = SALT_TYPE_EMBEDDED;
7919 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7920 opts_type = OPTS_TYPE_PT_GENERATE_LE
7921 | OPTS_TYPE_PT_ADD80
7922 | OPTS_TYPE_PT_ADDBITS14
7923 | OPTS_TYPE_ST_ADD80
7924 | OPTS_TYPE_ST_HEX;
7925 kern_type = KERN_TYPE_MD55_PWSLT1;
7926 dgst_size = DGST_SIZE_4_4;
7927 parse_func = phps_parse_hash;
7928 sort_by_digest = sort_by_digest_4_4;
7929 opti_type = OPTI_TYPE_ZERO_BYTE
7930 | OPTI_TYPE_PRECOMPUTE_INIT
7931 | OPTI_TYPE_PRECOMPUTE_MERKLE
7932 | OPTI_TYPE_EARLY_SKIP;
7933 dgst_pos0 = 0;
7934 dgst_pos1 = 3;
7935 dgst_pos2 = 2;
7936 dgst_pos3 = 1;
7937 break;
7938
7939 case 2711: hash_type = HASH_TYPE_MD5;
7940 salt_type = SALT_TYPE_INTERN;
7941 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7942 opts_type = OPTS_TYPE_PT_GENERATE_LE
7943 | OPTS_TYPE_PT_ADD80
7944 | OPTS_TYPE_PT_ADDBITS14
7945 | OPTS_TYPE_ST_ADD80;
7946 kern_type = KERN_TYPE_MD55_PWSLT2;
7947 dgst_size = DGST_SIZE_4_4;
7948 parse_func = vb30_parse_hash;
7949 sort_by_digest = sort_by_digest_4_4;
7950 opti_type = OPTI_TYPE_ZERO_BYTE
7951 | OPTI_TYPE_PRECOMPUTE_INIT
7952 | OPTI_TYPE_EARLY_SKIP;
7953 dgst_pos0 = 0;
7954 dgst_pos1 = 3;
7955 dgst_pos2 = 2;
7956 dgst_pos3 = 1;
7957 break;
7958
7959 case 2811: hash_type = HASH_TYPE_MD5;
7960 salt_type = SALT_TYPE_INTERN;
7961 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7962 opts_type = OPTS_TYPE_PT_GENERATE_LE
7963 | OPTS_TYPE_PT_ADD80
7964 | OPTS_TYPE_PT_ADDBITS14;
7965 kern_type = KERN_TYPE_MD55_SLTPW;
7966 dgst_size = DGST_SIZE_4_4;
7967 parse_func = ipb2_parse_hash;
7968 sort_by_digest = sort_by_digest_4_4;
7969 opti_type = OPTI_TYPE_ZERO_BYTE
7970 | OPTI_TYPE_PRECOMPUTE_INIT
7971 | OPTI_TYPE_EARLY_SKIP;
7972 dgst_pos0 = 0;
7973 dgst_pos1 = 3;
7974 dgst_pos2 = 2;
7975 dgst_pos3 = 1;
7976 break;
7977
7978 case 3000: hash_type = HASH_TYPE_LM;
7979 salt_type = SALT_TYPE_NONE;
7980 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7981 opts_type = OPTS_TYPE_PT_GENERATE_LE
7982 | OPTS_TYPE_PT_UPPER
7983 | OPTS_TYPE_PT_BITSLICE;
7984 kern_type = KERN_TYPE_LM;
7985 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7986 parse_func = lm_parse_hash;
7987 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7988 opti_type = OPTI_TYPE_ZERO_BYTE
7989 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7990 dgst_pos0 = 0;
7991 dgst_pos1 = 1;
7992 dgst_pos2 = 2;
7993 dgst_pos3 = 3;
7994 break;
7995
7996 case 3100: hash_type = HASH_TYPE_ORACLEH;
7997 salt_type = SALT_TYPE_INTERN;
7998 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7999 opts_type = OPTS_TYPE_PT_GENERATE_LE
8000 | OPTS_TYPE_PT_UPPER
8001 | OPTS_TYPE_ST_UPPER;
8002 kern_type = KERN_TYPE_ORACLEH;
8003 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8004 parse_func = oracleh_parse_hash;
8005 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8006 opti_type = OPTI_TYPE_ZERO_BYTE;
8007 dgst_pos0 = 0;
8008 dgst_pos1 = 1;
8009 dgst_pos2 = 2;
8010 dgst_pos3 = 3;
8011 break;
8012
8013 case 3200: hash_type = HASH_TYPE_BCRYPT;
8014 salt_type = SALT_TYPE_EMBEDDED;
8015 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8016 opts_type = OPTS_TYPE_PT_GENERATE_LE
8017 | OPTS_TYPE_ST_GENERATE_LE;
8018 kern_type = KERN_TYPE_BCRYPT;
8019 dgst_size = DGST_SIZE_4_6;
8020 parse_func = bcrypt_parse_hash;
8021 sort_by_digest = sort_by_digest_4_6;
8022 opti_type = OPTI_TYPE_ZERO_BYTE;
8023 dgst_pos0 = 0;
8024 dgst_pos1 = 1;
8025 dgst_pos2 = 2;
8026 dgst_pos3 = 3;
8027 break;
8028
8029 case 3710: hash_type = HASH_TYPE_MD5;
8030 salt_type = SALT_TYPE_INTERN;
8031 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8032 opts_type = OPTS_TYPE_PT_GENERATE_LE
8033 | OPTS_TYPE_PT_ADD80
8034 | OPTS_TYPE_PT_ADDBITS14;
8035 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8036 dgst_size = DGST_SIZE_4_4;
8037 parse_func = md5s_parse_hash;
8038 sort_by_digest = sort_by_digest_4_4;
8039 opti_type = OPTI_TYPE_ZERO_BYTE
8040 | OPTI_TYPE_PRECOMPUTE_INIT
8041 | OPTI_TYPE_PRECOMPUTE_MERKLE
8042 | OPTI_TYPE_EARLY_SKIP;
8043 dgst_pos0 = 0;
8044 dgst_pos1 = 3;
8045 dgst_pos2 = 2;
8046 dgst_pos3 = 1;
8047 break;
8048
8049 case 3711: hash_type = HASH_TYPE_MD5;
8050 salt_type = SALT_TYPE_EMBEDDED;
8051 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8052 opts_type = OPTS_TYPE_PT_GENERATE_LE
8053 | OPTS_TYPE_PT_ADD80
8054 | OPTS_TYPE_PT_ADDBITS14;
8055 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8056 dgst_size = DGST_SIZE_4_4;
8057 parse_func = mediawiki_b_parse_hash;
8058 sort_by_digest = sort_by_digest_4_4;
8059 opti_type = OPTI_TYPE_ZERO_BYTE
8060 | OPTI_TYPE_PRECOMPUTE_INIT
8061 | OPTI_TYPE_PRECOMPUTE_MERKLE
8062 | OPTI_TYPE_EARLY_SKIP;
8063 dgst_pos0 = 0;
8064 dgst_pos1 = 3;
8065 dgst_pos2 = 2;
8066 dgst_pos3 = 1;
8067 break;
8068
8069 case 3800: hash_type = HASH_TYPE_MD5;
8070 salt_type = SALT_TYPE_INTERN;
8071 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8072 opts_type = OPTS_TYPE_PT_GENERATE_LE
8073 | OPTS_TYPE_ST_ADDBITS14;
8074 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8075 dgst_size = DGST_SIZE_4_4;
8076 parse_func = md5s_parse_hash;
8077 sort_by_digest = sort_by_digest_4_4;
8078 opti_type = OPTI_TYPE_ZERO_BYTE
8079 | OPTI_TYPE_PRECOMPUTE_INIT
8080 | OPTI_TYPE_PRECOMPUTE_MERKLE
8081 | OPTI_TYPE_EARLY_SKIP
8082 | OPTI_TYPE_NOT_ITERATED
8083 | OPTI_TYPE_RAW_HASH;
8084 dgst_pos0 = 0;
8085 dgst_pos1 = 3;
8086 dgst_pos2 = 2;
8087 dgst_pos3 = 1;
8088 break;
8089
8090 case 4300: hash_type = HASH_TYPE_MD5;
8091 salt_type = SALT_TYPE_VIRTUAL;
8092 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8093 opts_type = OPTS_TYPE_PT_GENERATE_LE
8094 | OPTS_TYPE_PT_ADD80
8095 | OPTS_TYPE_PT_ADDBITS14
8096 | OPTS_TYPE_ST_ADD80;
8097 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8098 dgst_size = DGST_SIZE_4_4;
8099 parse_func = md5md5_parse_hash;
8100 sort_by_digest = sort_by_digest_4_4;
8101 opti_type = OPTI_TYPE_ZERO_BYTE
8102 | OPTI_TYPE_PRECOMPUTE_INIT
8103 | OPTI_TYPE_PRECOMPUTE_MERKLE
8104 | OPTI_TYPE_EARLY_SKIP;
8105 dgst_pos0 = 0;
8106 dgst_pos1 = 3;
8107 dgst_pos2 = 2;
8108 dgst_pos3 = 1;
8109 break;
8110
8111
8112 case 4400: hash_type = HASH_TYPE_MD5;
8113 salt_type = SALT_TYPE_NONE;
8114 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8115 opts_type = OPTS_TYPE_PT_GENERATE_BE
8116 | OPTS_TYPE_PT_ADD80
8117 | OPTS_TYPE_PT_ADDBITS15;
8118 kern_type = KERN_TYPE_MD5_SHA1;
8119 dgst_size = DGST_SIZE_4_4;
8120 parse_func = md5_parse_hash;
8121 sort_by_digest = sort_by_digest_4_4;
8122 opti_type = OPTI_TYPE_ZERO_BYTE
8123 | OPTI_TYPE_PRECOMPUTE_INIT
8124 | OPTI_TYPE_PRECOMPUTE_MERKLE
8125 | OPTI_TYPE_EARLY_SKIP
8126 | OPTI_TYPE_NOT_ITERATED
8127 | OPTI_TYPE_NOT_SALTED
8128 | OPTI_TYPE_RAW_HASH;
8129 dgst_pos0 = 0;
8130 dgst_pos1 = 3;
8131 dgst_pos2 = 2;
8132 dgst_pos3 = 1;
8133 break;
8134
8135 case 4500: hash_type = HASH_TYPE_SHA1;
8136 salt_type = SALT_TYPE_NONE;
8137 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8138 opts_type = OPTS_TYPE_PT_GENERATE_BE
8139 | OPTS_TYPE_PT_ADD80
8140 | OPTS_TYPE_PT_ADDBITS15;
8141 kern_type = KERN_TYPE_SHA11;
8142 dgst_size = DGST_SIZE_4_5;
8143 parse_func = sha1_parse_hash;
8144 sort_by_digest = sort_by_digest_4_5;
8145 opti_type = OPTI_TYPE_ZERO_BYTE
8146 | OPTI_TYPE_PRECOMPUTE_INIT
8147 | OPTI_TYPE_PRECOMPUTE_MERKLE
8148 | OPTI_TYPE_EARLY_SKIP
8149 | OPTI_TYPE_NOT_SALTED;
8150 dgst_pos0 = 3;
8151 dgst_pos1 = 4;
8152 dgst_pos2 = 2;
8153 dgst_pos3 = 1;
8154 break;
8155
8156 case 4700: hash_type = HASH_TYPE_SHA1;
8157 salt_type = SALT_TYPE_NONE;
8158 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8159 opts_type = OPTS_TYPE_PT_GENERATE_LE
8160 | OPTS_TYPE_PT_ADD80
8161 | OPTS_TYPE_PT_ADDBITS14;
8162 kern_type = KERN_TYPE_SHA1_MD5;
8163 dgst_size = DGST_SIZE_4_5;
8164 parse_func = sha1_parse_hash;
8165 sort_by_digest = sort_by_digest_4_5;
8166 opti_type = OPTI_TYPE_ZERO_BYTE
8167 | OPTI_TYPE_PRECOMPUTE_INIT
8168 | OPTI_TYPE_PRECOMPUTE_MERKLE
8169 | OPTI_TYPE_EARLY_SKIP
8170 | OPTI_TYPE_NOT_ITERATED
8171 | OPTI_TYPE_NOT_SALTED
8172 | OPTI_TYPE_RAW_HASH;
8173 dgst_pos0 = 3;
8174 dgst_pos1 = 4;
8175 dgst_pos2 = 2;
8176 dgst_pos3 = 1;
8177 break;
8178
8179 case 4800: hash_type = HASH_TYPE_MD5;
8180 salt_type = SALT_TYPE_EMBEDDED;
8181 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8182 opts_type = OPTS_TYPE_PT_GENERATE_LE
8183 | OPTS_TYPE_PT_ADDBITS14;
8184 kern_type = KERN_TYPE_MD5_CHAP;
8185 dgst_size = DGST_SIZE_4_4;
8186 parse_func = chap_parse_hash;
8187 sort_by_digest = sort_by_digest_4_4;
8188 opti_type = OPTI_TYPE_ZERO_BYTE
8189 | OPTI_TYPE_PRECOMPUTE_INIT
8190 | OPTI_TYPE_PRECOMPUTE_MERKLE
8191 | OPTI_TYPE_MEET_IN_MIDDLE
8192 | OPTI_TYPE_EARLY_SKIP
8193 | OPTI_TYPE_NOT_ITERATED
8194 | OPTI_TYPE_RAW_HASH;
8195 dgst_pos0 = 0;
8196 dgst_pos1 = 3;
8197 dgst_pos2 = 2;
8198 dgst_pos3 = 1;
8199 break;
8200
8201 case 4900: hash_type = HASH_TYPE_SHA1;
8202 salt_type = SALT_TYPE_INTERN;
8203 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8204 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8205 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8206 dgst_size = DGST_SIZE_4_5;
8207 parse_func = sha1s_parse_hash;
8208 sort_by_digest = sort_by_digest_4_5;
8209 opti_type = OPTI_TYPE_ZERO_BYTE
8210 | OPTI_TYPE_PRECOMPUTE_INIT
8211 | OPTI_TYPE_PRECOMPUTE_MERKLE
8212 | OPTI_TYPE_EARLY_SKIP;
8213 dgst_pos0 = 3;
8214 dgst_pos1 = 4;
8215 dgst_pos2 = 2;
8216 dgst_pos3 = 1;
8217 break;
8218
8219 case 5000: hash_type = HASH_TYPE_KECCAK;
8220 salt_type = SALT_TYPE_EMBEDDED;
8221 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8222 opts_type = OPTS_TYPE_PT_GENERATE_LE
8223 | OPTS_TYPE_PT_ADD01;
8224 kern_type = KERN_TYPE_KECCAK;
8225 dgst_size = DGST_SIZE_8_25;
8226 parse_func = keccak_parse_hash;
8227 sort_by_digest = sort_by_digest_8_25;
8228 opti_type = OPTI_TYPE_ZERO_BYTE
8229 | OPTI_TYPE_RAW_HASH;
8230 dgst_pos0 = 2;
8231 dgst_pos1 = 3;
8232 dgst_pos2 = 4;
8233 dgst_pos3 = 5;
8234 break;
8235
8236 case 5100: hash_type = HASH_TYPE_MD5H;
8237 salt_type = SALT_TYPE_NONE;
8238 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8239 opts_type = OPTS_TYPE_PT_GENERATE_LE
8240 | OPTS_TYPE_PT_ADD80
8241 | OPTS_TYPE_PT_ADDBITS14;
8242 kern_type = KERN_TYPE_MD5H;
8243 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8244 parse_func = md5half_parse_hash;
8245 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8246 opti_type = OPTI_TYPE_ZERO_BYTE
8247 | OPTI_TYPE_RAW_HASH;
8248 dgst_pos0 = 0;
8249 dgst_pos1 = 1;
8250 dgst_pos2 = 2;
8251 dgst_pos3 = 3;
8252 break;
8253
8254 case 5200: hash_type = HASH_TYPE_SHA256;
8255 salt_type = SALT_TYPE_EMBEDDED;
8256 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8257 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8258 kern_type = KERN_TYPE_PSAFE3;
8259 dgst_size = DGST_SIZE_4_8;
8260 parse_func = psafe3_parse_hash;
8261 sort_by_digest = sort_by_digest_4_8;
8262 opti_type = OPTI_TYPE_ZERO_BYTE;
8263 dgst_pos0 = 0;
8264 dgst_pos1 = 1;
8265 dgst_pos2 = 2;
8266 dgst_pos3 = 3;
8267 break;
8268
8269 case 5300: hash_type = HASH_TYPE_MD5;
8270 salt_type = SALT_TYPE_EMBEDDED;
8271 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8272 opts_type = OPTS_TYPE_PT_GENERATE_LE
8273 | OPTS_TYPE_ST_ADD80;
8274 kern_type = KERN_TYPE_IKEPSK_MD5;
8275 dgst_size = DGST_SIZE_4_4;
8276 parse_func = ikepsk_md5_parse_hash;
8277 sort_by_digest = sort_by_digest_4_4;
8278 opti_type = OPTI_TYPE_ZERO_BYTE;
8279 dgst_pos0 = 0;
8280 dgst_pos1 = 3;
8281 dgst_pos2 = 2;
8282 dgst_pos3 = 1;
8283 break;
8284
8285 case 5400: hash_type = HASH_TYPE_SHA1;
8286 salt_type = SALT_TYPE_EMBEDDED;
8287 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8288 opts_type = OPTS_TYPE_PT_GENERATE_BE
8289 | OPTS_TYPE_ST_ADD80;
8290 kern_type = KERN_TYPE_IKEPSK_SHA1;
8291 dgst_size = DGST_SIZE_4_5;
8292 parse_func = ikepsk_sha1_parse_hash;
8293 sort_by_digest = sort_by_digest_4_5;
8294 opti_type = OPTI_TYPE_ZERO_BYTE;
8295 dgst_pos0 = 3;
8296 dgst_pos1 = 4;
8297 dgst_pos2 = 2;
8298 dgst_pos3 = 1;
8299 break;
8300
8301 case 5500: hash_type = HASH_TYPE_NETNTLM;
8302 salt_type = SALT_TYPE_EMBEDDED;
8303 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8304 opts_type = OPTS_TYPE_PT_GENERATE_LE
8305 | OPTS_TYPE_PT_ADD80
8306 | OPTS_TYPE_PT_ADDBITS14
8307 | OPTS_TYPE_PT_UNICODE
8308 | OPTS_TYPE_ST_HEX;
8309 kern_type = KERN_TYPE_NETNTLMv1;
8310 dgst_size = DGST_SIZE_4_4;
8311 parse_func = netntlmv1_parse_hash;
8312 sort_by_digest = sort_by_digest_4_4;
8313 opti_type = OPTI_TYPE_ZERO_BYTE
8314 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8315 dgst_pos0 = 0;
8316 dgst_pos1 = 1;
8317 dgst_pos2 = 2;
8318 dgst_pos3 = 3;
8319 break;
8320
8321 case 5600: hash_type = HASH_TYPE_MD5;
8322 salt_type = SALT_TYPE_EMBEDDED;
8323 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8324 opts_type = OPTS_TYPE_PT_GENERATE_LE
8325 | OPTS_TYPE_PT_ADD80
8326 | OPTS_TYPE_PT_ADDBITS14
8327 | OPTS_TYPE_PT_UNICODE;
8328 kern_type = KERN_TYPE_NETNTLMv2;
8329 dgst_size = DGST_SIZE_4_4;
8330 parse_func = netntlmv2_parse_hash;
8331 sort_by_digest = sort_by_digest_4_4;
8332 opti_type = OPTI_TYPE_ZERO_BYTE;
8333 dgst_pos0 = 0;
8334 dgst_pos1 = 3;
8335 dgst_pos2 = 2;
8336 dgst_pos3 = 1;
8337 break;
8338
8339 case 5700: hash_type = HASH_TYPE_SHA256;
8340 salt_type = SALT_TYPE_NONE;
8341 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8342 opts_type = OPTS_TYPE_PT_GENERATE_BE
8343 | OPTS_TYPE_PT_ADD80
8344 | OPTS_TYPE_PT_ADDBITS15;
8345 kern_type = KERN_TYPE_SHA256;
8346 dgst_size = DGST_SIZE_4_8;
8347 parse_func = cisco4_parse_hash;
8348 sort_by_digest = sort_by_digest_4_8;
8349 opti_type = OPTI_TYPE_ZERO_BYTE
8350 | OPTI_TYPE_PRECOMPUTE_INIT
8351 | OPTI_TYPE_PRECOMPUTE_MERKLE
8352 | OPTI_TYPE_EARLY_SKIP
8353 | OPTI_TYPE_NOT_ITERATED
8354 | OPTI_TYPE_NOT_SALTED
8355 | OPTI_TYPE_RAW_HASH;
8356 dgst_pos0 = 3;
8357 dgst_pos1 = 7;
8358 dgst_pos2 = 2;
8359 dgst_pos3 = 6;
8360 break;
8361
8362 case 5800: hash_type = HASH_TYPE_SHA1;
8363 salt_type = SALT_TYPE_INTERN;
8364 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8365 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8366 | OPTS_TYPE_ST_ADD80;
8367 kern_type = KERN_TYPE_ANDROIDPIN;
8368 dgst_size = DGST_SIZE_4_5;
8369 parse_func = androidpin_parse_hash;
8370 sort_by_digest = sort_by_digest_4_5;
8371 opti_type = OPTI_TYPE_ZERO_BYTE;
8372 dgst_pos0 = 0;
8373 dgst_pos1 = 1;
8374 dgst_pos2 = 2;
8375 dgst_pos3 = 3;
8376 break;
8377
8378 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8379 salt_type = SALT_TYPE_NONE;
8380 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8381 opts_type = OPTS_TYPE_PT_GENERATE_LE
8382 | OPTS_TYPE_PT_ADD80;
8383 kern_type = KERN_TYPE_RIPEMD160;
8384 dgst_size = DGST_SIZE_4_5;
8385 parse_func = ripemd160_parse_hash;
8386 sort_by_digest = sort_by_digest_4_5;
8387 opti_type = OPTI_TYPE_ZERO_BYTE;
8388 dgst_pos0 = 0;
8389 dgst_pos1 = 1;
8390 dgst_pos2 = 2;
8391 dgst_pos3 = 3;
8392 break;
8393
8394 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8395 salt_type = SALT_TYPE_NONE;
8396 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8397 opts_type = OPTS_TYPE_PT_GENERATE_BE
8398 | OPTS_TYPE_PT_ADD80;
8399 kern_type = KERN_TYPE_WHIRLPOOL;
8400 dgst_size = DGST_SIZE_4_16;
8401 parse_func = whirlpool_parse_hash;
8402 sort_by_digest = sort_by_digest_4_16;
8403 opti_type = OPTI_TYPE_ZERO_BYTE;
8404 dgst_pos0 = 0;
8405 dgst_pos1 = 1;
8406 dgst_pos2 = 2;
8407 dgst_pos3 = 3;
8408 break;
8409
8410 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8411 salt_type = SALT_TYPE_EMBEDDED;
8412 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8413 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8414 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8415 dgst_size = DGST_SIZE_4_5;
8416 parse_func = truecrypt_parse_hash_2k;
8417 sort_by_digest = sort_by_digest_4_5;
8418 opti_type = OPTI_TYPE_ZERO_BYTE;
8419 dgst_pos0 = 0;
8420 dgst_pos1 = 1;
8421 dgst_pos2 = 2;
8422 dgst_pos3 = 3;
8423 break;
8424
8425 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8426 salt_type = SALT_TYPE_EMBEDDED;
8427 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8428 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8429 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8430 dgst_size = DGST_SIZE_4_5;
8431 parse_func = truecrypt_parse_hash_2k;
8432 sort_by_digest = sort_by_digest_4_5;
8433 opti_type = OPTI_TYPE_ZERO_BYTE;
8434 dgst_pos0 = 0;
8435 dgst_pos1 = 1;
8436 dgst_pos2 = 2;
8437 dgst_pos3 = 3;
8438 break;
8439
8440 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8441 salt_type = SALT_TYPE_EMBEDDED;
8442 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8443 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8444 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8445 dgst_size = DGST_SIZE_4_5;
8446 parse_func = truecrypt_parse_hash_2k;
8447 sort_by_digest = sort_by_digest_4_5;
8448 opti_type = OPTI_TYPE_ZERO_BYTE;
8449 dgst_pos0 = 0;
8450 dgst_pos1 = 1;
8451 dgst_pos2 = 2;
8452 dgst_pos3 = 3;
8453 break;
8454
8455 case 6221: hash_type = HASH_TYPE_SHA512;
8456 salt_type = SALT_TYPE_EMBEDDED;
8457 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8458 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8459 kern_type = KERN_TYPE_TCSHA512_XTS512;
8460 dgst_size = DGST_SIZE_8_8;
8461 parse_func = truecrypt_parse_hash_1k;
8462 sort_by_digest = sort_by_digest_8_8;
8463 opti_type = OPTI_TYPE_ZERO_BYTE;
8464 dgst_pos0 = 0;
8465 dgst_pos1 = 1;
8466 dgst_pos2 = 2;
8467 dgst_pos3 = 3;
8468 break;
8469
8470 case 6222: hash_type = HASH_TYPE_SHA512;
8471 salt_type = SALT_TYPE_EMBEDDED;
8472 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8473 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8474 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8475 dgst_size = DGST_SIZE_8_8;
8476 parse_func = truecrypt_parse_hash_1k;
8477 sort_by_digest = sort_by_digest_8_8;
8478 opti_type = OPTI_TYPE_ZERO_BYTE;
8479 dgst_pos0 = 0;
8480 dgst_pos1 = 1;
8481 dgst_pos2 = 2;
8482 dgst_pos3 = 3;
8483 break;
8484
8485 case 6223: hash_type = HASH_TYPE_SHA512;
8486 salt_type = SALT_TYPE_EMBEDDED;
8487 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8488 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8489 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8490 dgst_size = DGST_SIZE_8_8;
8491 parse_func = truecrypt_parse_hash_1k;
8492 sort_by_digest = sort_by_digest_8_8;
8493 opti_type = OPTI_TYPE_ZERO_BYTE;
8494 dgst_pos0 = 0;
8495 dgst_pos1 = 1;
8496 dgst_pos2 = 2;
8497 dgst_pos3 = 3;
8498 break;
8499
8500 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8501 salt_type = SALT_TYPE_EMBEDDED;
8502 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8503 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8504 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8505 dgst_size = DGST_SIZE_4_8;
8506 parse_func = truecrypt_parse_hash_1k;
8507 sort_by_digest = sort_by_digest_4_8;
8508 opti_type = OPTI_TYPE_ZERO_BYTE;
8509 dgst_pos0 = 0;
8510 dgst_pos1 = 1;
8511 dgst_pos2 = 2;
8512 dgst_pos3 = 3;
8513 break;
8514
8515 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8516 salt_type = SALT_TYPE_EMBEDDED;
8517 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8518 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8519 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8520 dgst_size = DGST_SIZE_4_8;
8521 parse_func = truecrypt_parse_hash_1k;
8522 sort_by_digest = sort_by_digest_4_8;
8523 opti_type = OPTI_TYPE_ZERO_BYTE;
8524 dgst_pos0 = 0;
8525 dgst_pos1 = 1;
8526 dgst_pos2 = 2;
8527 dgst_pos3 = 3;
8528 break;
8529
8530 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8531 salt_type = SALT_TYPE_EMBEDDED;
8532 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8533 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8534 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8535 dgst_size = DGST_SIZE_4_8;
8536 parse_func = truecrypt_parse_hash_1k;
8537 sort_by_digest = sort_by_digest_4_8;
8538 opti_type = OPTI_TYPE_ZERO_BYTE;
8539 dgst_pos0 = 0;
8540 dgst_pos1 = 1;
8541 dgst_pos2 = 2;
8542 dgst_pos3 = 3;
8543 break;
8544
8545 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8546 salt_type = SALT_TYPE_EMBEDDED;
8547 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8548 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8549 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8550 dgst_size = DGST_SIZE_4_5;
8551 parse_func = truecrypt_parse_hash_1k;
8552 sort_by_digest = sort_by_digest_4_5;
8553 opti_type = OPTI_TYPE_ZERO_BYTE;
8554 dgst_pos0 = 0;
8555 dgst_pos1 = 1;
8556 dgst_pos2 = 2;
8557 dgst_pos3 = 3;
8558 break;
8559
8560 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8561 salt_type = SALT_TYPE_EMBEDDED;
8562 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8563 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8564 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8565 dgst_size = DGST_SIZE_4_5;
8566 parse_func = truecrypt_parse_hash_1k;
8567 sort_by_digest = sort_by_digest_4_5;
8568 opti_type = OPTI_TYPE_ZERO_BYTE;
8569 dgst_pos0 = 0;
8570 dgst_pos1 = 1;
8571 dgst_pos2 = 2;
8572 dgst_pos3 = 3;
8573 break;
8574
8575 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8576 salt_type = SALT_TYPE_EMBEDDED;
8577 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8578 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8579 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8580 dgst_size = DGST_SIZE_4_5;
8581 parse_func = truecrypt_parse_hash_1k;
8582 sort_by_digest = sort_by_digest_4_5;
8583 opti_type = OPTI_TYPE_ZERO_BYTE;
8584 dgst_pos0 = 0;
8585 dgst_pos1 = 1;
8586 dgst_pos2 = 2;
8587 dgst_pos3 = 3;
8588 break;
8589
8590 case 6300: hash_type = HASH_TYPE_MD5;
8591 salt_type = SALT_TYPE_EMBEDDED;
8592 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8593 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8594 kern_type = KERN_TYPE_MD5AIX;
8595 dgst_size = DGST_SIZE_4_4;
8596 parse_func = md5aix_parse_hash;
8597 sort_by_digest = sort_by_digest_4_4;
8598 opti_type = OPTI_TYPE_ZERO_BYTE;
8599 dgst_pos0 = 0;
8600 dgst_pos1 = 1;
8601 dgst_pos2 = 2;
8602 dgst_pos3 = 3;
8603 break;
8604
8605 case 6400: hash_type = HASH_TYPE_SHA256;
8606 salt_type = SALT_TYPE_EMBEDDED;
8607 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8608 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8609 kern_type = KERN_TYPE_SHA256AIX;
8610 dgst_size = DGST_SIZE_4_8;
8611 parse_func = sha256aix_parse_hash;
8612 sort_by_digest = sort_by_digest_4_8;
8613 opti_type = OPTI_TYPE_ZERO_BYTE;
8614 dgst_pos0 = 0;
8615 dgst_pos1 = 1;
8616 dgst_pos2 = 2;
8617 dgst_pos3 = 3;
8618 break;
8619
8620 case 6500: hash_type = HASH_TYPE_SHA512;
8621 salt_type = SALT_TYPE_EMBEDDED;
8622 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8623 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8624 kern_type = KERN_TYPE_SHA512AIX;
8625 dgst_size = DGST_SIZE_8_8;
8626 parse_func = sha512aix_parse_hash;
8627 sort_by_digest = sort_by_digest_8_8;
8628 opti_type = OPTI_TYPE_ZERO_BYTE;
8629 dgst_pos0 = 0;
8630 dgst_pos1 = 1;
8631 dgst_pos2 = 2;
8632 dgst_pos3 = 3;
8633 break;
8634
8635 case 6600: hash_type = HASH_TYPE_AES;
8636 salt_type = SALT_TYPE_EMBEDDED;
8637 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8638 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8639 kern_type = KERN_TYPE_AGILEKEY;
8640 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8641 parse_func = agilekey_parse_hash;
8642 sort_by_digest = sort_by_digest_4_5;
8643 opti_type = OPTI_TYPE_ZERO_BYTE;
8644 dgst_pos0 = 0;
8645 dgst_pos1 = 1;
8646 dgst_pos2 = 2;
8647 dgst_pos3 = 3;
8648 break;
8649
8650 case 6700: hash_type = HASH_TYPE_SHA1;
8651 salt_type = SALT_TYPE_EMBEDDED;
8652 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8653 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8654 kern_type = KERN_TYPE_SHA1AIX;
8655 dgst_size = DGST_SIZE_4_5;
8656 parse_func = sha1aix_parse_hash;
8657 sort_by_digest = sort_by_digest_4_5;
8658 opti_type = OPTI_TYPE_ZERO_BYTE;
8659 dgst_pos0 = 0;
8660 dgst_pos1 = 1;
8661 dgst_pos2 = 2;
8662 dgst_pos3 = 3;
8663 break;
8664
8665 case 6800: hash_type = HASH_TYPE_AES;
8666 salt_type = SALT_TYPE_EMBEDDED;
8667 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8668 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8669 kern_type = KERN_TYPE_LASTPASS;
8670 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
8671 parse_func = lastpass_parse_hash;
8672 sort_by_digest = sort_by_digest_4_8;
8673 opti_type = OPTI_TYPE_ZERO_BYTE;
8674 dgst_pos0 = 0;
8675 dgst_pos1 = 1;
8676 dgst_pos2 = 2;
8677 dgst_pos3 = 3;
8678 break;
8679
8680 case 6900: hash_type = HASH_TYPE_GOST;
8681 salt_type = SALT_TYPE_NONE;
8682 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8683 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8684 kern_type = KERN_TYPE_GOST;
8685 dgst_size = DGST_SIZE_4_8;
8686 parse_func = gost_parse_hash;
8687 sort_by_digest = sort_by_digest_4_8;
8688 opti_type = OPTI_TYPE_ZERO_BYTE;
8689 dgst_pos0 = 0;
8690 dgst_pos1 = 1;
8691 dgst_pos2 = 2;
8692 dgst_pos3 = 3;
8693 break;
8694
8695 case 7100: hash_type = HASH_TYPE_SHA512;
8696 salt_type = SALT_TYPE_EMBEDDED;
8697 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8698 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8699 kern_type = KERN_TYPE_PBKDF2_SHA512;
8700 dgst_size = DGST_SIZE_8_16;
8701 parse_func = sha512osx_parse_hash;
8702 sort_by_digest = sort_by_digest_8_16;
8703 opti_type = OPTI_TYPE_ZERO_BYTE;
8704 dgst_pos0 = 0;
8705 dgst_pos1 = 1;
8706 dgst_pos2 = 2;
8707 dgst_pos3 = 3;
8708 break;
8709
8710 case 7200: hash_type = HASH_TYPE_SHA512;
8711 salt_type = SALT_TYPE_EMBEDDED;
8712 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8713 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8714 kern_type = KERN_TYPE_PBKDF2_SHA512;
8715 dgst_size = DGST_SIZE_8_16;
8716 parse_func = sha512grub_parse_hash;
8717 sort_by_digest = sort_by_digest_8_16;
8718 opti_type = OPTI_TYPE_ZERO_BYTE;
8719 dgst_pos0 = 0;
8720 dgst_pos1 = 1;
8721 dgst_pos2 = 2;
8722 dgst_pos3 = 3;
8723 break;
8724
8725 case 7300: hash_type = HASH_TYPE_SHA1;
8726 salt_type = SALT_TYPE_EMBEDDED;
8727 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8728 opts_type = OPTS_TYPE_PT_GENERATE_BE
8729 | OPTS_TYPE_ST_ADD80
8730 | OPTS_TYPE_ST_ADDBITS15;
8731 kern_type = KERN_TYPE_RAKP;
8732 dgst_size = DGST_SIZE_4_5;
8733 parse_func = rakp_parse_hash;
8734 sort_by_digest = sort_by_digest_4_5;
8735 opti_type = OPTI_TYPE_ZERO_BYTE
8736 | OPTI_TYPE_NOT_ITERATED;
8737 dgst_pos0 = 3;
8738 dgst_pos1 = 4;
8739 dgst_pos2 = 2;
8740 dgst_pos3 = 1;
8741 break;
8742
8743 case 7400: hash_type = HASH_TYPE_SHA256;
8744 salt_type = SALT_TYPE_EMBEDDED;
8745 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8746 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8747 kern_type = KERN_TYPE_SHA256CRYPT;
8748 dgst_size = DGST_SIZE_4_8;
8749 parse_func = sha256crypt_parse_hash;
8750 sort_by_digest = sort_by_digest_4_8;
8751 opti_type = OPTI_TYPE_ZERO_BYTE;
8752 dgst_pos0 = 0;
8753 dgst_pos1 = 1;
8754 dgst_pos2 = 2;
8755 dgst_pos3 = 3;
8756 break;
8757
8758 case 7500: hash_type = HASH_TYPE_KRB5PA;
8759 salt_type = SALT_TYPE_EMBEDDED;
8760 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8761 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8762 kern_type = KERN_TYPE_KRB5PA;
8763 dgst_size = DGST_SIZE_4_4;
8764 parse_func = krb5pa_parse_hash;
8765 sort_by_digest = sort_by_digest_4_4;
8766 opti_type = OPTI_TYPE_ZERO_BYTE
8767 | OPTI_TYPE_NOT_ITERATED;
8768 dgst_pos0 = 3;
8769 dgst_pos1 = 7;
8770 dgst_pos2 = 2;
8771 dgst_pos3 = 6;
8772 break;
8773
8774 case 7600: hash_type = HASH_TYPE_SHA1;
8775 salt_type = SALT_TYPE_INTERN;
8776 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8777 opts_type = OPTS_TYPE_PT_GENERATE_BE
8778 | OPTS_TYPE_PT_ADD80
8779 | OPTS_TYPE_PT_ADDBITS15;
8780 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
8781 dgst_size = DGST_SIZE_4_5;
8782 parse_func = redmine_parse_hash;
8783 sort_by_digest = sort_by_digest_4_5;
8784 opti_type = OPTI_TYPE_ZERO_BYTE
8785 | OPTI_TYPE_PRECOMPUTE_INIT
8786 | OPTI_TYPE_EARLY_SKIP
8787 | OPTI_TYPE_NOT_ITERATED
8788 | OPTI_TYPE_PREPENDED_SALT;
8789 dgst_pos0 = 3;
8790 dgst_pos1 = 4;
8791 dgst_pos2 = 2;
8792 dgst_pos3 = 1;
8793 break;
8794
8795 case 7700: hash_type = HASH_TYPE_SAPB;
8796 salt_type = SALT_TYPE_EMBEDDED;
8797 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8798 opts_type = OPTS_TYPE_PT_GENERATE_LE
8799 | OPTS_TYPE_PT_UPPER
8800 | OPTS_TYPE_ST_UPPER;
8801 kern_type = KERN_TYPE_SAPB;
8802 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8803 parse_func = sapb_parse_hash;
8804 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8805 opti_type = OPTI_TYPE_ZERO_BYTE
8806 | OPTI_TYPE_PRECOMPUTE_INIT
8807 | OPTI_TYPE_NOT_ITERATED;
8808 dgst_pos0 = 0;
8809 dgst_pos1 = 1;
8810 dgst_pos2 = 2;
8811 dgst_pos3 = 3;
8812 break;
8813
8814 case 7800: hash_type = HASH_TYPE_SAPG;
8815 salt_type = SALT_TYPE_EMBEDDED;
8816 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8817 opts_type = OPTS_TYPE_PT_GENERATE_BE
8818 | OPTS_TYPE_ST_ADD80
8819 | OPTS_TYPE_ST_UPPER;
8820 kern_type = KERN_TYPE_SAPG;
8821 dgst_size = DGST_SIZE_4_5;
8822 parse_func = sapg_parse_hash;
8823 sort_by_digest = sort_by_digest_4_5;
8824 opti_type = OPTI_TYPE_ZERO_BYTE
8825 | OPTI_TYPE_PRECOMPUTE_INIT
8826 | OPTI_TYPE_NOT_ITERATED;
8827 dgst_pos0 = 3;
8828 dgst_pos1 = 4;
8829 dgst_pos2 = 2;
8830 dgst_pos3 = 1;
8831 break;
8832
8833 case 7900: hash_type = HASH_TYPE_SHA512;
8834 salt_type = SALT_TYPE_EMBEDDED;
8835 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8836 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8837 kern_type = KERN_TYPE_DRUPAL7;
8838 dgst_size = DGST_SIZE_8_8;
8839 parse_func = drupal7_parse_hash;
8840 sort_by_digest = sort_by_digest_8_8;
8841 opti_type = OPTI_TYPE_ZERO_BYTE;
8842 dgst_pos0 = 0;
8843 dgst_pos1 = 1;
8844 dgst_pos2 = 2;
8845 dgst_pos3 = 3;
8846 break;
8847
8848 case 8000: hash_type = HASH_TYPE_SHA256;
8849 salt_type = SALT_TYPE_EMBEDDED;
8850 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8851 opts_type = OPTS_TYPE_PT_GENERATE_BE
8852 | OPTS_TYPE_PT_UNICODE
8853 | OPTS_TYPE_ST_ADD80
8854 | OPTS_TYPE_ST_HEX;
8855 kern_type = KERN_TYPE_SYBASEASE;
8856 dgst_size = DGST_SIZE_4_8;
8857 parse_func = sybasease_parse_hash;
8858 sort_by_digest = sort_by_digest_4_8;
8859 opti_type = OPTI_TYPE_ZERO_BYTE
8860 | OPTI_TYPE_PRECOMPUTE_INIT
8861 | OPTI_TYPE_EARLY_SKIP
8862 | OPTI_TYPE_NOT_ITERATED
8863 | OPTI_TYPE_RAW_HASH;
8864 dgst_pos0 = 3;
8865 dgst_pos1 = 7;
8866 dgst_pos2 = 2;
8867 dgst_pos3 = 6;
8868 break;
8869
8870 case 8100: hash_type = HASH_TYPE_SHA1;
8871 salt_type = SALT_TYPE_EMBEDDED;
8872 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8873 opts_type = OPTS_TYPE_PT_GENERATE_BE;
8874 kern_type = KERN_TYPE_NETSCALER;
8875 dgst_size = DGST_SIZE_4_5;
8876 parse_func = netscaler_parse_hash;
8877 sort_by_digest = sort_by_digest_4_5;
8878 opti_type = OPTI_TYPE_ZERO_BYTE
8879 | OPTI_TYPE_PRECOMPUTE_INIT
8880 | OPTI_TYPE_PRECOMPUTE_MERKLE
8881 | OPTI_TYPE_EARLY_SKIP
8882 | OPTI_TYPE_NOT_ITERATED
8883 | OPTI_TYPE_PREPENDED_SALT
8884 | OPTI_TYPE_RAW_HASH;
8885 dgst_pos0 = 3;
8886 dgst_pos1 = 4;
8887 dgst_pos2 = 2;
8888 dgst_pos3 = 1;
8889 break;
8890
8891 case 8200: hash_type = HASH_TYPE_SHA256;
8892 salt_type = SALT_TYPE_EMBEDDED;
8893 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8894 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8895 kern_type = KERN_TYPE_CLOUDKEY;
8896 dgst_size = DGST_SIZE_4_8;
8897 parse_func = cloudkey_parse_hash;
8898 sort_by_digest = sort_by_digest_4_8;
8899 opti_type = OPTI_TYPE_ZERO_BYTE;
8900 dgst_pos0 = 0;
8901 dgst_pos1 = 1;
8902 dgst_pos2 = 2;
8903 dgst_pos3 = 3;
8904 break;
8905
8906 case 8300: hash_type = HASH_TYPE_SHA1;
8907 salt_type = SALT_TYPE_EMBEDDED;
8908 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8909 opts_type = OPTS_TYPE_PT_GENERATE_LE
8910 | OPTS_TYPE_ST_HEX
8911 | OPTS_TYPE_ST_ADD80;
8912 kern_type = KERN_TYPE_NSEC3;
8913 dgst_size = DGST_SIZE_4_5;
8914 parse_func = nsec3_parse_hash;
8915 sort_by_digest = sort_by_digest_4_5;
8916 opti_type = OPTI_TYPE_ZERO_BYTE;
8917 dgst_pos0 = 3;
8918 dgst_pos1 = 4;
8919 dgst_pos2 = 2;
8920 dgst_pos3 = 1;
8921 break;
8922
8923 case 8400: hash_type = HASH_TYPE_SHA1;
8924 salt_type = SALT_TYPE_INTERN;
8925 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8926 opts_type = OPTS_TYPE_PT_GENERATE_BE
8927 | OPTS_TYPE_PT_ADD80
8928 | OPTS_TYPE_PT_ADDBITS15;
8929 kern_type = KERN_TYPE_WBB3;
8930 dgst_size = DGST_SIZE_4_5;
8931 parse_func = wbb3_parse_hash;
8932 sort_by_digest = sort_by_digest_4_5;
8933 opti_type = OPTI_TYPE_ZERO_BYTE
8934 | OPTI_TYPE_PRECOMPUTE_INIT
8935 | OPTI_TYPE_NOT_ITERATED;
8936 dgst_pos0 = 3;
8937 dgst_pos1 = 4;
8938 dgst_pos2 = 2;
8939 dgst_pos3 = 1;
8940 break;
8941
8942 case 8500: hash_type = HASH_TYPE_DESRACF;
8943 salt_type = SALT_TYPE_EMBEDDED;
8944 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8945 opts_type = OPTS_TYPE_PT_GENERATE_LE
8946 | OPTS_TYPE_ST_UPPER;
8947 kern_type = KERN_TYPE_RACF;
8948 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8949 parse_func = racf_parse_hash;
8950 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8951 opti_type = OPTI_TYPE_ZERO_BYTE
8952 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8953 dgst_pos0 = 0;
8954 dgst_pos1 = 1;
8955 dgst_pos2 = 2;
8956 dgst_pos3 = 3;
8957 break;
8958
8959 case 8600: hash_type = HASH_TYPE_LOTUS5;
8960 salt_type = SALT_TYPE_NONE;
8961 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8962 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8963 kern_type = KERN_TYPE_LOTUS5;
8964 dgst_size = DGST_SIZE_4_4;
8965 parse_func = lotus5_parse_hash;
8966 sort_by_digest = sort_by_digest_4_4;
8967 opti_type = OPTI_TYPE_EARLY_SKIP
8968 | OPTI_TYPE_NOT_ITERATED
8969 | OPTI_TYPE_NOT_SALTED
8970 | OPTI_TYPE_RAW_HASH;
8971 dgst_pos0 = 0;
8972 dgst_pos1 = 1;
8973 dgst_pos2 = 2;
8974 dgst_pos3 = 3;
8975 break;
8976
8977 case 8700: hash_type = HASH_TYPE_LOTUS6;
8978 salt_type = SALT_TYPE_EMBEDDED;
8979 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8980 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8981 kern_type = KERN_TYPE_LOTUS6;
8982 dgst_size = DGST_SIZE_4_4;
8983 parse_func = lotus6_parse_hash;
8984 sort_by_digest = sort_by_digest_4_4;
8985 opti_type = OPTI_TYPE_EARLY_SKIP
8986 | OPTI_TYPE_NOT_ITERATED
8987 | OPTI_TYPE_RAW_HASH;
8988 dgst_pos0 = 0;
8989 dgst_pos1 = 1;
8990 dgst_pos2 = 2;
8991 dgst_pos3 = 3;
8992 break;
8993
8994 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
8995 salt_type = SALT_TYPE_EMBEDDED;
8996 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8997 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8998 kern_type = KERN_TYPE_ANDROIDFDE;
8999 dgst_size = DGST_SIZE_4_4;
9000 parse_func = androidfde_parse_hash;
9001 sort_by_digest = sort_by_digest_4_4;
9002 opti_type = OPTI_TYPE_ZERO_BYTE;
9003 dgst_pos0 = 0;
9004 dgst_pos1 = 1;
9005 dgst_pos2 = 2;
9006 dgst_pos3 = 3;
9007 break;
9008
9009 case 8900: hash_type = HASH_TYPE_SCRYPT;
9010 salt_type = SALT_TYPE_EMBEDDED;
9011 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9012 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9013 kern_type = KERN_TYPE_SCRYPT;
9014 dgst_size = DGST_SIZE_4_8;
9015 parse_func = scrypt_parse_hash;
9016 sort_by_digest = sort_by_digest_4_8;
9017 opti_type = OPTI_TYPE_ZERO_BYTE;
9018 dgst_pos0 = 0;
9019 dgst_pos1 = 1;
9020 dgst_pos2 = 2;
9021 dgst_pos3 = 3;
9022 break;
9023
9024 case 9000: hash_type = HASH_TYPE_SHA1;
9025 salt_type = SALT_TYPE_EMBEDDED;
9026 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9027 opts_type = OPTS_TYPE_PT_GENERATE_LE
9028 | OPTS_TYPE_ST_GENERATE_LE;
9029 kern_type = KERN_TYPE_PSAFE2;
9030 dgst_size = DGST_SIZE_4_5;
9031 parse_func = psafe2_parse_hash;
9032 sort_by_digest = sort_by_digest_4_5;
9033 opti_type = OPTI_TYPE_ZERO_BYTE;
9034 dgst_pos0 = 0;
9035 dgst_pos1 = 1;
9036 dgst_pos2 = 2;
9037 dgst_pos3 = 3;
9038 break;
9039
9040 case 9100: hash_type = HASH_TYPE_LOTUS8;
9041 salt_type = SALT_TYPE_EMBEDDED;
9042 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9043 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9044 kern_type = KERN_TYPE_LOTUS8;
9045 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9046 parse_func = lotus8_parse_hash;
9047 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9048 opti_type = OPTI_TYPE_ZERO_BYTE;
9049 dgst_pos0 = 0;
9050 dgst_pos1 = 1;
9051 dgst_pos2 = 2;
9052 dgst_pos3 = 3;
9053 break;
9054
9055 case 9200: hash_type = HASH_TYPE_SHA256;
9056 salt_type = SALT_TYPE_EMBEDDED;
9057 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9058 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9059 kern_type = KERN_TYPE_PBKDF2_SHA256;
9060 dgst_size = DGST_SIZE_4_32;
9061 parse_func = cisco8_parse_hash;
9062 sort_by_digest = sort_by_digest_4_32;
9063 opti_type = OPTI_TYPE_ZERO_BYTE;
9064 dgst_pos0 = 0;
9065 dgst_pos1 = 1;
9066 dgst_pos2 = 2;
9067 dgst_pos3 = 3;
9068 break;
9069
9070 case 9300: hash_type = HASH_TYPE_SCRYPT;
9071 salt_type = SALT_TYPE_EMBEDDED;
9072 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9073 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9074 kern_type = KERN_TYPE_SCRYPT;
9075 dgst_size = DGST_SIZE_4_8;
9076 parse_func = cisco9_parse_hash;
9077 sort_by_digest = sort_by_digest_4_8;
9078 opti_type = OPTI_TYPE_ZERO_BYTE;
9079 dgst_pos0 = 0;
9080 dgst_pos1 = 1;
9081 dgst_pos2 = 2;
9082 dgst_pos3 = 3;
9083 break;
9084
9085 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9086 salt_type = SALT_TYPE_EMBEDDED;
9087 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9088 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9089 kern_type = KERN_TYPE_OFFICE2007;
9090 dgst_size = DGST_SIZE_4_4;
9091 parse_func = office2007_parse_hash;
9092 sort_by_digest = sort_by_digest_4_4;
9093 opti_type = OPTI_TYPE_ZERO_BYTE;
9094 dgst_pos0 = 0;
9095 dgst_pos1 = 1;
9096 dgst_pos2 = 2;
9097 dgst_pos3 = 3;
9098 break;
9099
9100 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9101 salt_type = SALT_TYPE_EMBEDDED;
9102 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9103 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9104 kern_type = KERN_TYPE_OFFICE2010;
9105 dgst_size = DGST_SIZE_4_4;
9106 parse_func = office2010_parse_hash;
9107 sort_by_digest = sort_by_digest_4_4;
9108 opti_type = OPTI_TYPE_ZERO_BYTE;
9109 dgst_pos0 = 0;
9110 dgst_pos1 = 1;
9111 dgst_pos2 = 2;
9112 dgst_pos3 = 3;
9113 break;
9114
9115 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9116 salt_type = SALT_TYPE_EMBEDDED;
9117 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9118 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9119 kern_type = KERN_TYPE_OFFICE2013;
9120 dgst_size = DGST_SIZE_4_4;
9121 parse_func = office2013_parse_hash;
9122 sort_by_digest = sort_by_digest_4_4;
9123 opti_type = OPTI_TYPE_ZERO_BYTE;
9124 dgst_pos0 = 0;
9125 dgst_pos1 = 1;
9126 dgst_pos2 = 2;
9127 dgst_pos3 = 3;
9128 break;
9129
9130 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9131 salt_type = SALT_TYPE_EMBEDDED;
9132 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9133 opts_type = OPTS_TYPE_PT_GENERATE_LE
9134 | OPTS_TYPE_PT_ADD80
9135 | OPTS_TYPE_PT_UNICODE;
9136 kern_type = KERN_TYPE_OLDOFFICE01;
9137 dgst_size = DGST_SIZE_4_4;
9138 parse_func = oldoffice01_parse_hash;
9139 sort_by_digest = sort_by_digest_4_4;
9140 opti_type = OPTI_TYPE_ZERO_BYTE
9141 | OPTI_TYPE_PRECOMPUTE_INIT
9142 | OPTI_TYPE_NOT_ITERATED;
9143 dgst_pos0 = 0;
9144 dgst_pos1 = 1;
9145 dgst_pos2 = 2;
9146 dgst_pos3 = 3;
9147 break;
9148
9149 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9150 salt_type = SALT_TYPE_EMBEDDED;
9151 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9152 opts_type = OPTS_TYPE_PT_GENERATE_LE
9153 | OPTS_TYPE_PT_ADD80;
9154 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9155 dgst_size = DGST_SIZE_4_4;
9156 parse_func = oldoffice01cm1_parse_hash;
9157 sort_by_digest = sort_by_digest_4_4;
9158 opti_type = OPTI_TYPE_ZERO_BYTE
9159 | OPTI_TYPE_PRECOMPUTE_INIT
9160 | OPTI_TYPE_NOT_ITERATED;
9161 dgst_pos0 = 0;
9162 dgst_pos1 = 1;
9163 dgst_pos2 = 2;
9164 dgst_pos3 = 3;
9165 break;
9166
9167 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9168 salt_type = SALT_TYPE_EMBEDDED;
9169 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9170 opts_type = OPTS_TYPE_PT_GENERATE_LE
9171 | OPTS_TYPE_PT_ADD80
9172 | OPTS_TYPE_PT_UNICODE
9173 | OPTS_TYPE_PT_NEVERCRACK;
9174 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9175 dgst_size = DGST_SIZE_4_4;
9176 parse_func = oldoffice01cm2_parse_hash;
9177 sort_by_digest = sort_by_digest_4_4;
9178 opti_type = OPTI_TYPE_ZERO_BYTE
9179 | OPTI_TYPE_PRECOMPUTE_INIT
9180 | OPTI_TYPE_NOT_ITERATED;
9181 dgst_pos0 = 0;
9182 dgst_pos1 = 1;
9183 dgst_pos2 = 2;
9184 dgst_pos3 = 3;
9185 break;
9186
9187 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9188 salt_type = SALT_TYPE_EMBEDDED;
9189 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9190 opts_type = OPTS_TYPE_PT_GENERATE_BE
9191 | OPTS_TYPE_PT_ADD80
9192 | OPTS_TYPE_PT_UNICODE;
9193 kern_type = KERN_TYPE_OLDOFFICE34;
9194 dgst_size = DGST_SIZE_4_4;
9195 parse_func = oldoffice34_parse_hash;
9196 sort_by_digest = sort_by_digest_4_4;
9197 opti_type = OPTI_TYPE_ZERO_BYTE
9198 | OPTI_TYPE_PRECOMPUTE_INIT
9199 | OPTI_TYPE_NOT_ITERATED;
9200 dgst_pos0 = 0;
9201 dgst_pos1 = 1;
9202 dgst_pos2 = 2;
9203 dgst_pos3 = 3;
9204 break;
9205
9206 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9207 salt_type = SALT_TYPE_EMBEDDED;
9208 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9209 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9210 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9211 dgst_size = DGST_SIZE_4_4;
9212 parse_func = oldoffice34cm1_parse_hash;
9213 sort_by_digest = sort_by_digest_4_4;
9214 opti_type = OPTI_TYPE_ZERO_BYTE
9215 | OPTI_TYPE_PRECOMPUTE_INIT
9216 | OPTI_TYPE_NOT_ITERATED;
9217 dgst_pos0 = 0;
9218 dgst_pos1 = 1;
9219 dgst_pos2 = 2;
9220 dgst_pos3 = 3;
9221 break;
9222
9223 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9224 salt_type = SALT_TYPE_EMBEDDED;
9225 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9226 opts_type = OPTS_TYPE_PT_GENERATE_BE
9227 | OPTS_TYPE_PT_ADD80
9228 | OPTS_TYPE_PT_UNICODE
9229 | OPTS_TYPE_PT_NEVERCRACK;
9230 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9231 dgst_size = DGST_SIZE_4_4;
9232 parse_func = oldoffice34cm2_parse_hash;
9233 sort_by_digest = sort_by_digest_4_4;
9234 opti_type = OPTI_TYPE_ZERO_BYTE
9235 | OPTI_TYPE_PRECOMPUTE_INIT
9236 | OPTI_TYPE_NOT_ITERATED;
9237 dgst_pos0 = 0;
9238 dgst_pos1 = 1;
9239 dgst_pos2 = 2;
9240 dgst_pos3 = 3;
9241 break;
9242
9243 case 9900: hash_type = HASH_TYPE_MD5;
9244 salt_type = SALT_TYPE_NONE;
9245 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9246 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9247 kern_type = KERN_TYPE_RADMIN2;
9248 dgst_size = DGST_SIZE_4_4;
9249 parse_func = radmin2_parse_hash;
9250 sort_by_digest = sort_by_digest_4_4;
9251 opti_type = OPTI_TYPE_ZERO_BYTE
9252 | OPTI_TYPE_PRECOMPUTE_INIT
9253 | OPTI_TYPE_EARLY_SKIP
9254 | OPTI_TYPE_NOT_ITERATED
9255 | OPTI_TYPE_NOT_SALTED;
9256 dgst_pos0 = 0;
9257 dgst_pos1 = 3;
9258 dgst_pos2 = 2;
9259 dgst_pos3 = 1;
9260 break;
9261
9262 case 10000: hash_type = HASH_TYPE_SHA256;
9263 salt_type = SALT_TYPE_EMBEDDED;
9264 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9265 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9266 kern_type = KERN_TYPE_PBKDF2_SHA256;
9267 dgst_size = DGST_SIZE_4_32;
9268 parse_func = djangopbkdf2_parse_hash;
9269 sort_by_digest = sort_by_digest_4_32;
9270 opti_type = OPTI_TYPE_ZERO_BYTE;
9271 dgst_pos0 = 0;
9272 dgst_pos1 = 1;
9273 dgst_pos2 = 2;
9274 dgst_pos3 = 3;
9275 break;
9276
9277 case 10100: hash_type = HASH_TYPE_SIPHASH;
9278 salt_type = SALT_TYPE_EMBEDDED;
9279 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9280 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9281 kern_type = KERN_TYPE_SIPHASH;
9282 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9283 parse_func = siphash_parse_hash;
9284 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9285 opti_type = OPTI_TYPE_ZERO_BYTE
9286 | OPTI_TYPE_NOT_ITERATED
9287 | OPTI_TYPE_RAW_HASH;
9288 dgst_pos0 = 0;
9289 dgst_pos1 = 1;
9290 dgst_pos2 = 2;
9291 dgst_pos3 = 3;
9292 break;
9293
9294 case 10200: hash_type = HASH_TYPE_MD5;
9295 salt_type = SALT_TYPE_EMBEDDED;
9296 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9297 opts_type = OPTS_TYPE_PT_GENERATE_LE
9298 | OPTS_TYPE_ST_ADD80
9299 | OPTS_TYPE_ST_ADDBITS14;
9300 kern_type = KERN_TYPE_HMACMD5_PW;
9301 dgst_size = DGST_SIZE_4_4;
9302 parse_func = crammd5_parse_hash;
9303 sort_by_digest = sort_by_digest_4_4;
9304 opti_type = OPTI_TYPE_ZERO_BYTE
9305 | OPTI_TYPE_NOT_ITERATED;
9306 dgst_pos0 = 0;
9307 dgst_pos1 = 3;
9308 dgst_pos2 = 2;
9309 dgst_pos3 = 1;
9310 break;
9311
9312 case 10300: hash_type = HASH_TYPE_SHA1;
9313 salt_type = SALT_TYPE_EMBEDDED;
9314 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9315 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9316 kern_type = KERN_TYPE_SAPH_SHA1;
9317 dgst_size = DGST_SIZE_4_5;
9318 parse_func = saph_sha1_parse_hash;
9319 sort_by_digest = sort_by_digest_4_5;
9320 opti_type = OPTI_TYPE_ZERO_BYTE;
9321 dgst_pos0 = 0;
9322 dgst_pos1 = 1;
9323 dgst_pos2 = 2;
9324 dgst_pos3 = 3;
9325 break;
9326
9327 case 10400: hash_type = HASH_TYPE_PDFU16;
9328 salt_type = SALT_TYPE_EMBEDDED;
9329 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9330 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9331 kern_type = KERN_TYPE_PDF11;
9332 dgst_size = DGST_SIZE_4_4;
9333 parse_func = pdf11_parse_hash;
9334 sort_by_digest = sort_by_digest_4_4;
9335 opti_type = OPTI_TYPE_ZERO_BYTE
9336 | OPTI_TYPE_NOT_ITERATED;
9337 dgst_pos0 = 0;
9338 dgst_pos1 = 1;
9339 dgst_pos2 = 2;
9340 dgst_pos3 = 3;
9341 break;
9342
9343 case 10410: hash_type = HASH_TYPE_PDFU16;
9344 salt_type = SALT_TYPE_EMBEDDED;
9345 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9346 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9347 kern_type = KERN_TYPE_PDF11CM1;
9348 dgst_size = DGST_SIZE_4_4;
9349 parse_func = pdf11cm1_parse_hash;
9350 sort_by_digest = sort_by_digest_4_4;
9351 opti_type = OPTI_TYPE_ZERO_BYTE
9352 | OPTI_TYPE_NOT_ITERATED;
9353 dgst_pos0 = 0;
9354 dgst_pos1 = 1;
9355 dgst_pos2 = 2;
9356 dgst_pos3 = 3;
9357 break;
9358
9359 case 10420: hash_type = HASH_TYPE_PDFU16;
9360 salt_type = SALT_TYPE_EMBEDDED;
9361 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9362 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9363 kern_type = KERN_TYPE_PDF11CM2;
9364 dgst_size = DGST_SIZE_4_4;
9365 parse_func = pdf11cm2_parse_hash;
9366 sort_by_digest = sort_by_digest_4_4;
9367 opti_type = OPTI_TYPE_ZERO_BYTE
9368 | OPTI_TYPE_NOT_ITERATED;
9369 dgst_pos0 = 0;
9370 dgst_pos1 = 1;
9371 dgst_pos2 = 2;
9372 dgst_pos3 = 3;
9373 break;
9374
9375 case 10500: hash_type = HASH_TYPE_PDFU16;
9376 salt_type = SALT_TYPE_EMBEDDED;
9377 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9378 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9379 kern_type = KERN_TYPE_PDF14;
9380 dgst_size = DGST_SIZE_4_4;
9381 parse_func = pdf14_parse_hash;
9382 sort_by_digest = sort_by_digest_4_4;
9383 opti_type = OPTI_TYPE_ZERO_BYTE
9384 | OPTI_TYPE_NOT_ITERATED;
9385 dgst_pos0 = 0;
9386 dgst_pos1 = 1;
9387 dgst_pos2 = 2;
9388 dgst_pos3 = 3;
9389 break;
9390
9391 case 10600: hash_type = HASH_TYPE_SHA256;
9392 salt_type = SALT_TYPE_EMBEDDED;
9393 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9394 opts_type = OPTS_TYPE_PT_GENERATE_BE
9395 | OPTS_TYPE_ST_ADD80
9396 | OPTS_TYPE_ST_ADDBITS15
9397 | OPTS_TYPE_HASH_COPY;
9398 kern_type = KERN_TYPE_SHA256_PWSLT;
9399 dgst_size = DGST_SIZE_4_8;
9400 parse_func = pdf17l3_parse_hash;
9401 sort_by_digest = sort_by_digest_4_8;
9402 opti_type = OPTI_TYPE_ZERO_BYTE
9403 | OPTI_TYPE_PRECOMPUTE_INIT
9404 | OPTI_TYPE_PRECOMPUTE_MERKLE
9405 | OPTI_TYPE_EARLY_SKIP
9406 | OPTI_TYPE_NOT_ITERATED
9407 | OPTI_TYPE_APPENDED_SALT
9408 | OPTI_TYPE_RAW_HASH;
9409 dgst_pos0 = 3;
9410 dgst_pos1 = 7;
9411 dgst_pos2 = 2;
9412 dgst_pos3 = 6;
9413 break;
9414
9415 case 10700: hash_type = HASH_TYPE_PDFU32;
9416 salt_type = SALT_TYPE_EMBEDDED;
9417 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9418 opts_type = OPTS_TYPE_PT_GENERATE_LE
9419 | OPTS_TYPE_HASH_COPY;
9420 kern_type = KERN_TYPE_PDF17L8;
9421 dgst_size = DGST_SIZE_4_8;
9422 parse_func = pdf17l8_parse_hash;
9423 sort_by_digest = sort_by_digest_4_8;
9424 opti_type = OPTI_TYPE_ZERO_BYTE
9425 | OPTI_TYPE_NOT_ITERATED;
9426 dgst_pos0 = 0;
9427 dgst_pos1 = 1;
9428 dgst_pos2 = 2;
9429 dgst_pos3 = 3;
9430 break;
9431
9432 case 10800: hash_type = HASH_TYPE_SHA384;
9433 salt_type = SALT_TYPE_NONE;
9434 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9435 opts_type = OPTS_TYPE_PT_GENERATE_BE
9436 | OPTS_TYPE_PT_ADD80
9437 | OPTS_TYPE_PT_ADDBITS15;
9438 kern_type = KERN_TYPE_SHA384;
9439 dgst_size = DGST_SIZE_8_8;
9440 parse_func = sha384_parse_hash;
9441 sort_by_digest = sort_by_digest_8_8;
9442 opti_type = OPTI_TYPE_ZERO_BYTE
9443 | OPTI_TYPE_PRECOMPUTE_INIT
9444 | OPTI_TYPE_PRECOMPUTE_MERKLE
9445 | OPTI_TYPE_EARLY_SKIP
9446 | OPTI_TYPE_NOT_ITERATED
9447 | OPTI_TYPE_NOT_SALTED
9448 | OPTI_TYPE_RAW_HASH;
9449 dgst_pos0 = 6;
9450 dgst_pos1 = 7;
9451 dgst_pos2 = 4;
9452 dgst_pos3 = 5;
9453 break;
9454
9455 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9456 salt_type = SALT_TYPE_EMBEDDED;
9457 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9458 opts_type = OPTS_TYPE_PT_GENERATE_LE
9459 | OPTS_TYPE_ST_BASE64
9460 | OPTS_TYPE_HASH_COPY;
9461 kern_type = KERN_TYPE_PBKDF2_SHA256;
9462 dgst_size = DGST_SIZE_4_32;
9463 parse_func = pbkdf2_sha256_parse_hash;
9464 sort_by_digest = sort_by_digest_4_32;
9465 opti_type = OPTI_TYPE_ZERO_BYTE;
9466 dgst_pos0 = 0;
9467 dgst_pos1 = 1;
9468 dgst_pos2 = 2;
9469 dgst_pos3 = 3;
9470 break;
9471
9472 case 11000: hash_type = HASH_TYPE_MD5;
9473 salt_type = SALT_TYPE_INTERN;
9474 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9475 opts_type = OPTS_TYPE_PT_GENERATE_LE
9476 | OPTS_TYPE_PT_ADD80;
9477 kern_type = KERN_TYPE_PRESTASHOP;
9478 dgst_size = DGST_SIZE_4_4;
9479 parse_func = prestashop_parse_hash;
9480 sort_by_digest = sort_by_digest_4_4;
9481 opti_type = OPTI_TYPE_ZERO_BYTE
9482 | OPTI_TYPE_PRECOMPUTE_INIT
9483 | OPTI_TYPE_NOT_ITERATED
9484 | OPTI_TYPE_PREPENDED_SALT;
9485 dgst_pos0 = 0;
9486 dgst_pos1 = 3;
9487 dgst_pos2 = 2;
9488 dgst_pos3 = 1;
9489 break;
9490
9491 case 11100: hash_type = HASH_TYPE_MD5;
9492 salt_type = SALT_TYPE_EMBEDDED;
9493 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9494 opts_type = OPTS_TYPE_PT_GENERATE_LE
9495 | OPTS_TYPE_ST_ADD80;
9496 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9497 dgst_size = DGST_SIZE_4_4;
9498 parse_func = postgresql_auth_parse_hash;
9499 sort_by_digest = sort_by_digest_4_4;
9500 opti_type = OPTI_TYPE_ZERO_BYTE
9501 | OPTI_TYPE_PRECOMPUTE_INIT
9502 | OPTI_TYPE_PRECOMPUTE_MERKLE
9503 | OPTI_TYPE_EARLY_SKIP;
9504 dgst_pos0 = 0;
9505 dgst_pos1 = 3;
9506 dgst_pos2 = 2;
9507 dgst_pos3 = 1;
9508 break;
9509
9510 case 11200: hash_type = HASH_TYPE_SHA1;
9511 salt_type = SALT_TYPE_EMBEDDED;
9512 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9513 opts_type = OPTS_TYPE_PT_GENERATE_BE
9514 | OPTS_TYPE_PT_ADD80
9515 | OPTS_TYPE_ST_HEX;
9516 kern_type = KERN_TYPE_MYSQL_AUTH;
9517 dgst_size = DGST_SIZE_4_5;
9518 parse_func = mysql_auth_parse_hash;
9519 sort_by_digest = sort_by_digest_4_5;
9520 opti_type = OPTI_TYPE_ZERO_BYTE
9521 | OPTI_TYPE_EARLY_SKIP;
9522 dgst_pos0 = 3;
9523 dgst_pos1 = 4;
9524 dgst_pos2 = 2;
9525 dgst_pos3 = 1;
9526 break;
9527
9528 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9529 salt_type = SALT_TYPE_EMBEDDED;
9530 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9531 opts_type = OPTS_TYPE_PT_GENERATE_LE
9532 | OPTS_TYPE_ST_HEX
9533 | OPTS_TYPE_ST_ADD80;
9534 kern_type = KERN_TYPE_BITCOIN_WALLET;
9535 dgst_size = DGST_SIZE_4_4;
9536 parse_func = bitcoin_wallet_parse_hash;
9537 sort_by_digest = sort_by_digest_4_4;
9538 opti_type = OPTI_TYPE_ZERO_BYTE;
9539 dgst_pos0 = 0;
9540 dgst_pos1 = 1;
9541 dgst_pos2 = 2;
9542 dgst_pos3 = 3;
9543 break;
9544
9545 case 11400: hash_type = HASH_TYPE_MD5;
9546 salt_type = SALT_TYPE_EMBEDDED;
9547 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9548 opts_type = OPTS_TYPE_PT_GENERATE_LE
9549 | OPTS_TYPE_PT_ADD80
9550 | OPTS_TYPE_HASH_COPY;
9551 kern_type = KERN_TYPE_SIP_AUTH;
9552 dgst_size = DGST_SIZE_4_4;
9553 parse_func = sip_auth_parse_hash;
9554 sort_by_digest = sort_by_digest_4_4;
9555 opti_type = OPTI_TYPE_ZERO_BYTE;
9556 dgst_pos0 = 0;
9557 dgst_pos1 = 3;
9558 dgst_pos2 = 2;
9559 dgst_pos3 = 1;
9560 break;
9561
9562 case 11500: hash_type = HASH_TYPE_CRC32;
9563 salt_type = SALT_TYPE_INTERN;
9564 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9565 opts_type = OPTS_TYPE_PT_GENERATE_LE
9566 | OPTS_TYPE_ST_GENERATE_LE
9567 | OPTS_TYPE_ST_HEX;
9568 kern_type = KERN_TYPE_CRC32;
9569 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9570 parse_func = crc32_parse_hash;
9571 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9572 opti_type = OPTI_TYPE_ZERO_BYTE;
9573 dgst_pos0 = 0;
9574 dgst_pos1 = 1;
9575 dgst_pos2 = 2;
9576 dgst_pos3 = 3;
9577 break;
9578
9579 case 11600: hash_type = HASH_TYPE_AES;
9580 salt_type = SALT_TYPE_EMBEDDED;
9581 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9582 opts_type = OPTS_TYPE_PT_GENERATE_LE
9583 | OPTS_TYPE_PT_NEVERCRACK;
9584 kern_type = KERN_TYPE_SEVEN_ZIP;
9585 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9586 parse_func = seven_zip_parse_hash;
9587 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9588 opti_type = OPTI_TYPE_ZERO_BYTE;
9589 dgst_pos0 = 0;
9590 dgst_pos1 = 1;
9591 dgst_pos2 = 2;
9592 dgst_pos3 = 3;
9593 break;
9594
9595 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9596 salt_type = SALT_TYPE_NONE;
9597 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9598 opts_type = OPTS_TYPE_PT_GENERATE_LE
9599 | OPTS_TYPE_PT_ADD01;
9600 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9601 dgst_size = DGST_SIZE_4_8;
9602 parse_func = gost2012sbog_256_parse_hash;
9603 sort_by_digest = sort_by_digest_4_8;
9604 opti_type = OPTI_TYPE_ZERO_BYTE;
9605 dgst_pos0 = 0;
9606 dgst_pos1 = 1;
9607 dgst_pos2 = 2;
9608 dgst_pos3 = 3;
9609 break;
9610
9611 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9612 salt_type = SALT_TYPE_NONE;
9613 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9614 opts_type = OPTS_TYPE_PT_GENERATE_LE
9615 | OPTS_TYPE_PT_ADD01;
9616 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9617 dgst_size = DGST_SIZE_4_16;
9618 parse_func = gost2012sbog_512_parse_hash;
9619 sort_by_digest = sort_by_digest_4_16;
9620 opti_type = OPTI_TYPE_ZERO_BYTE;
9621 dgst_pos0 = 0;
9622 dgst_pos1 = 1;
9623 dgst_pos2 = 2;
9624 dgst_pos3 = 3;
9625 break;
9626
9627 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9628 salt_type = SALT_TYPE_EMBEDDED;
9629 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9630 opts_type = OPTS_TYPE_PT_GENERATE_LE
9631 | OPTS_TYPE_ST_BASE64
9632 | OPTS_TYPE_HASH_COPY;
9633 kern_type = KERN_TYPE_PBKDF2_MD5;
9634 dgst_size = DGST_SIZE_4_32;
9635 parse_func = pbkdf2_md5_parse_hash;
9636 sort_by_digest = sort_by_digest_4_32;
9637 opti_type = OPTI_TYPE_ZERO_BYTE;
9638 dgst_pos0 = 0;
9639 dgst_pos1 = 1;
9640 dgst_pos2 = 2;
9641 dgst_pos3 = 3;
9642 break;
9643
9644 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
9645 salt_type = SALT_TYPE_EMBEDDED;
9646 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9647 opts_type = OPTS_TYPE_PT_GENERATE_LE
9648 | OPTS_TYPE_ST_BASE64
9649 | OPTS_TYPE_HASH_COPY;
9650 kern_type = KERN_TYPE_PBKDF2_SHA1;
9651 dgst_size = DGST_SIZE_4_32;
9652 parse_func = pbkdf2_sha1_parse_hash;
9653 sort_by_digest = sort_by_digest_4_32;
9654 opti_type = OPTI_TYPE_ZERO_BYTE;
9655 dgst_pos0 = 0;
9656 dgst_pos1 = 1;
9657 dgst_pos2 = 2;
9658 dgst_pos3 = 3;
9659 break;
9660
9661 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
9662 salt_type = SALT_TYPE_EMBEDDED;
9663 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9664 opts_type = OPTS_TYPE_PT_GENERATE_LE
9665 | OPTS_TYPE_ST_BASE64
9666 | OPTS_TYPE_HASH_COPY;
9667 kern_type = KERN_TYPE_PBKDF2_SHA512;
9668 dgst_size = DGST_SIZE_8_16;
9669 parse_func = pbkdf2_sha512_parse_hash;
9670 sort_by_digest = sort_by_digest_8_16;
9671 opti_type = OPTI_TYPE_ZERO_BYTE;
9672 dgst_pos0 = 0;
9673 dgst_pos1 = 1;
9674 dgst_pos2 = 2;
9675 dgst_pos3 = 3;
9676 break;
9677
9678 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
9679 salt_type = SALT_TYPE_EMBEDDED;
9680 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9681 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9682 kern_type = KERN_TYPE_ECRYPTFS;
9683 dgst_size = DGST_SIZE_8_8;
9684 parse_func = ecryptfs_parse_hash;
9685 sort_by_digest = sort_by_digest_8_8;
9686 opti_type = OPTI_TYPE_ZERO_BYTE;
9687 dgst_pos0 = 0;
9688 dgst_pos1 = 1;
9689 dgst_pos2 = 2;
9690 dgst_pos3 = 3;
9691 break;
9692
9693 case 12300: hash_type = HASH_TYPE_ORACLET;
9694 salt_type = SALT_TYPE_EMBEDDED;
9695 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9696 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9697 kern_type = KERN_TYPE_ORACLET;
9698 dgst_size = DGST_SIZE_8_16;
9699 parse_func = oraclet_parse_hash;
9700 sort_by_digest = sort_by_digest_8_16;
9701 opti_type = OPTI_TYPE_ZERO_BYTE;
9702 dgst_pos0 = 0;
9703 dgst_pos1 = 1;
9704 dgst_pos2 = 2;
9705 dgst_pos3 = 3;
9706 break;
9707
9708 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
9709 salt_type = SALT_TYPE_EMBEDDED;
9710 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9711 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9712 kern_type = KERN_TYPE_BSDICRYPT;
9713 dgst_size = DGST_SIZE_4_4;
9714 parse_func = bsdicrypt_parse_hash;
9715 sort_by_digest = sort_by_digest_4_4;
9716 opti_type = OPTI_TYPE_ZERO_BYTE
9717 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9718 dgst_pos0 = 0;
9719 dgst_pos1 = 1;
9720 dgst_pos2 = 2;
9721 dgst_pos3 = 3;
9722 break;
9723
9724 case 12500: hash_type = HASH_TYPE_RAR3HP;
9725 salt_type = SALT_TYPE_EMBEDDED;
9726 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9727 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9728 kern_type = KERN_TYPE_RAR3;
9729 dgst_size = DGST_SIZE_4_4;
9730 parse_func = rar3hp_parse_hash;
9731 sort_by_digest = sort_by_digest_4_4;
9732 opti_type = OPTI_TYPE_ZERO_BYTE;
9733 dgst_pos0 = 0;
9734 dgst_pos1 = 1;
9735 dgst_pos2 = 2;
9736 dgst_pos3 = 3;
9737 break;
9738
9739 case 12600: hash_type = HASH_TYPE_SHA256;
9740 salt_type = SALT_TYPE_INTERN;
9741 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9742 opts_type = OPTS_TYPE_PT_GENERATE_BE
9743 | OPTS_TYPE_PT_ADD80;
9744 kern_type = KERN_TYPE_CF10;
9745 dgst_size = DGST_SIZE_4_8;
9746 parse_func = cf10_parse_hash;
9747 sort_by_digest = sort_by_digest_4_8;
9748 opti_type = OPTI_TYPE_ZERO_BYTE
9749 | OPTI_TYPE_PRECOMPUTE_INIT
9750 | OPTI_TYPE_EARLY_SKIP
9751 | OPTI_TYPE_NOT_ITERATED;
9752 dgst_pos0 = 3;
9753 dgst_pos1 = 7;
9754 dgst_pos2 = 2;
9755 dgst_pos3 = 6;
9756 break;
9757
9758 case 12700: hash_type = HASH_TYPE_AES;
9759 salt_type = SALT_TYPE_EMBEDDED;
9760 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9761 opts_type = OPTS_TYPE_PT_GENERATE_LE
9762 | OPTS_TYPE_HASH_COPY;
9763 kern_type = KERN_TYPE_MYWALLET;
9764 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9765 parse_func = mywallet_parse_hash;
9766 sort_by_digest = sort_by_digest_4_5;
9767 opti_type = OPTI_TYPE_ZERO_BYTE;
9768 dgst_pos0 = 0;
9769 dgst_pos1 = 1;
9770 dgst_pos2 = 2;
9771 dgst_pos3 = 3;
9772 break;
9773
9774 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
9775 salt_type = SALT_TYPE_EMBEDDED;
9776 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9777 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9778 kern_type = KERN_TYPE_MS_DRSR;
9779 dgst_size = DGST_SIZE_4_8;
9780 parse_func = ms_drsr_parse_hash;
9781 sort_by_digest = sort_by_digest_4_8;
9782 opti_type = OPTI_TYPE_ZERO_BYTE;
9783 dgst_pos0 = 0;
9784 dgst_pos1 = 1;
9785 dgst_pos2 = 2;
9786 dgst_pos3 = 3;
9787 break;
9788
9789 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9790 salt_type = SALT_TYPE_EMBEDDED;
9791 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9792 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9793 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
9794 dgst_size = DGST_SIZE_4_8;
9795 parse_func = androidfde_samsung_parse_hash;
9796 sort_by_digest = sort_by_digest_4_8;
9797 opti_type = OPTI_TYPE_ZERO_BYTE;
9798 dgst_pos0 = 0;
9799 dgst_pos1 = 1;
9800 dgst_pos2 = 2;
9801 dgst_pos3 = 3;
9802 break;
9803
9804 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
9805 salt_type = SALT_TYPE_EMBEDDED;
9806 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9807 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9808 kern_type = KERN_TYPE_RAR5;
9809 dgst_size = DGST_SIZE_4_4;
9810 parse_func = rar5_parse_hash;
9811 sort_by_digest = sort_by_digest_4_4;
9812 opti_type = OPTI_TYPE_ZERO_BYTE;
9813 dgst_pos0 = 0;
9814 dgst_pos1 = 1;
9815 dgst_pos2 = 2;
9816 dgst_pos3 = 3;
9817 break;
9818
9819 default: usage_mini_print (PROGNAME); return (-1);
9820 }
9821
9822 /**
9823 * transpose
9824 */
9825
9826 data.parse_func = parse_func;
9827
9828 /**
9829 * misc stuff
9830 */
9831
9832 if (hex_salt)
9833 {
9834 if (salt_type == SALT_TYPE_INTERN)
9835 {
9836 opts_type |= OPTS_TYPE_ST_HEX;
9837 }
9838 else
9839 {
9840 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
9841
9842 return (-1);
9843 }
9844 }
9845
9846 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
9847 | (salt_type == SALT_TYPE_EXTERN)
9848 | (salt_type == SALT_TYPE_EMBEDDED)
9849 | (salt_type == SALT_TYPE_VIRTUAL));
9850
9851 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
9852
9853 data.hash_type = hash_type;
9854 data.attack_mode = attack_mode;
9855 data.attack_kern = attack_kern;
9856 data.attack_exec = attack_exec;
9857 data.kern_type = kern_type;
9858 data.opts_type = opts_type;
9859 data.dgst_size = dgst_size;
9860 data.salt_type = salt_type;
9861 data.isSalted = isSalted;
9862 data.sort_by_digest = sort_by_digest;
9863 data.dgst_pos0 = dgst_pos0;
9864 data.dgst_pos1 = dgst_pos1;
9865 data.dgst_pos2 = dgst_pos2;
9866 data.dgst_pos3 = dgst_pos3;
9867
9868 esalt_size = 0;
9869
9870 switch (hash_mode)
9871 {
9872 case 2500: esalt_size = sizeof (wpa_t); break;
9873 case 5300: esalt_size = sizeof (ikepsk_t); break;
9874 case 5400: esalt_size = sizeof (ikepsk_t); break;
9875 case 5500: esalt_size = sizeof (netntlm_t); break;
9876 case 5600: esalt_size = sizeof (netntlm_t); break;
9877 case 6211:
9878 case 6212:
9879 case 6213:
9880 case 6221:
9881 case 6222:
9882 case 6223:
9883 case 6231:
9884 case 6232:
9885 case 6233:
9886 case 6241:
9887 case 6242:
9888 case 6243: esalt_size = sizeof (tc_t); break;
9889 case 6600: esalt_size = sizeof (agilekey_t); break;
9890 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
9891 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
9892 case 7300: esalt_size = sizeof (rakp_t); break;
9893 case 7500: esalt_size = sizeof (krb5pa_t); break;
9894 case 8200: esalt_size = sizeof (cloudkey_t); break;
9895 case 8800: esalt_size = sizeof (androidfde_t); break;
9896 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
9897 case 9400: esalt_size = sizeof (office2007_t); break;
9898 case 9500: esalt_size = sizeof (office2010_t); break;
9899 case 9600: esalt_size = sizeof (office2013_t); break;
9900 case 9700: esalt_size = sizeof (oldoffice01_t); break;
9901 case 9710: esalt_size = sizeof (oldoffice01_t); break;
9902 case 9720: esalt_size = sizeof (oldoffice01_t); break;
9903 case 9800: esalt_size = sizeof (oldoffice34_t); break;
9904 case 9810: esalt_size = sizeof (oldoffice34_t); break;
9905 case 9820: esalt_size = sizeof (oldoffice34_t); break;
9906 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
9907 case 10200: esalt_size = sizeof (cram_md5_t); break;
9908 case 10400: esalt_size = sizeof (pdf_t); break;
9909 case 10410: esalt_size = sizeof (pdf_t); break;
9910 case 10420: esalt_size = sizeof (pdf_t); break;
9911 case 10500: esalt_size = sizeof (pdf_t); break;
9912 case 10600: esalt_size = sizeof (pdf_t); break;
9913 case 10700: esalt_size = sizeof (pdf_t); break;
9914 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
9915 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
9916 case 11400: esalt_size = sizeof (sip_t); break;
9917 case 11600: esalt_size = sizeof (seven_zip_t); break;
9918 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
9919 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
9920 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
9921 case 13000: esalt_size = sizeof (rar5_t); break;
9922 }
9923
9924 data.esalt_size = esalt_size;
9925
9926 /**
9927 * choose dictionary parser
9928 */
9929
9930 if (hash_type == HASH_TYPE_LM)
9931 {
9932 get_next_word_func = get_next_word_lm;
9933 }
9934 else if (opts_type & OPTS_TYPE_PT_UPPER)
9935 {
9936 get_next_word_func = get_next_word_uc;
9937 }
9938 else
9939 {
9940 get_next_word_func = get_next_word_std;
9941 }
9942
9943 /**
9944 * dictstat
9945 */
9946
9947 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
9948
9949 #ifdef _POSIX
9950 size_t dictstat_nmemb = 0;
9951 #endif
9952
9953 #ifdef _WIN
9954 uint dictstat_nmemb = 0;
9955 #endif
9956
9957 char dictstat[256];
9958
9959 FILE *dictstat_fp = NULL;
9960
9961 if (keyspace == 0)
9962 {
9963 memset (dictstat, 0, sizeof (dictstat));
9964
9965 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
9966
9967 dictstat_fp = fopen (dictstat, "rb");
9968
9969 if (dictstat_fp)
9970 {
9971 #ifdef _POSIX
9972 struct stat tmpstat;
9973
9974 fstat (fileno (dictstat_fp), &tmpstat);
9975 #endif
9976
9977 #ifdef _WIN
9978 struct stat64 tmpstat;
9979
9980 _fstat64 (fileno (dictstat_fp), &tmpstat);
9981 #endif
9982
9983 if (tmpstat.st_mtime < COMPTIME)
9984 {
9985 /* with v0.15 the format changed so we have to ensure user is using a good version
9986 since there is no version-header in the dictstat file */
9987
9988 fclose (dictstat_fp);
9989
9990 unlink (dictstat);
9991 }
9992 else
9993 {
9994 while (!feof (dictstat_fp))
9995 {
9996 dictstat_t d;
9997
9998 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
9999
10000 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10001
10002 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10003 {
10004 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10005
10006 return -1;
10007 }
10008 }
10009
10010 fclose (dictstat_fp);
10011 }
10012 }
10013 }
10014
10015 /**
10016 * potfile
10017 */
10018
10019 char potfile[256];
10020
10021 memset (potfile, 0, sizeof (potfile));
10022
10023 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
10024
10025 data.pot_fp = NULL;
10026
10027 FILE *out_fp = NULL;
10028 FILE *pot_fp = NULL;
10029
10030 if (show == 1 || left == 1)
10031 {
10032 pot_fp = fopen (potfile, "rb");
10033
10034 if (pot_fp == NULL)
10035 {
10036 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10037
10038 return (-1);
10039 }
10040
10041 if (outfile != NULL)
10042 {
10043 if ((out_fp = fopen (outfile, "ab")) == NULL)
10044 {
10045 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10046
10047 fclose (pot_fp);
10048
10049 return (-1);
10050 }
10051 }
10052 else
10053 {
10054 out_fp = stdout;
10055 }
10056 }
10057 else
10058 {
10059 if (potfile_disable == 0)
10060 {
10061 pot_fp = fopen (potfile, "ab");
10062
10063 if (pot_fp == NULL)
10064 {
10065 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10066
10067 return (-1);
10068 }
10069
10070 data.pot_fp = pot_fp;
10071 }
10072 }
10073
10074 pot_t *pot = NULL;
10075
10076 uint pot_cnt = 0;
10077 uint pot_avail = 0;
10078
10079 if (show == 1 || left == 1)
10080 {
10081 SUPPRESS_OUTPUT = 1;
10082
10083 pot_avail = count_lines (pot_fp);
10084
10085 rewind (pot_fp);
10086
10087 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10088
10089 uint pot_hashes_avail = 0;
10090
10091 uint line_num = 0;
10092
10093 while (!feof (pot_fp))
10094 {
10095 line_num++;
10096
10097 char line_buf[BUFSIZ];
10098
10099 int line_len = fgetl (pot_fp, line_buf);
10100
10101 if (line_len == 0) continue;
10102
10103 char *plain_buf = line_buf + line_len;
10104
10105 pot_t *pot_ptr = &pot[pot_cnt];
10106
10107 hash_t *hashes_buf = &pot_ptr->hash;
10108
10109 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10110 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10111
10112 if (pot_cnt == pot_hashes_avail)
10113 {
10114 uint pos = 0;
10115
10116 for (pos = 0; pos < INCR_POT; pos++)
10117 {
10118 if ((pot_cnt + pos) >= pot_avail) break;
10119
10120 pot_t *tmp_pot = &pot[pot_cnt + pos];
10121
10122 hash_t *tmp_hash = &tmp_pot->hash;
10123
10124 tmp_hash->digest = mymalloc (dgst_size);
10125
10126 if (isSalted)
10127 {
10128 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10129 }
10130
10131 if (esalt_size)
10132 {
10133 tmp_hash->esalt = mymalloc (esalt_size);
10134 }
10135
10136 pot_hashes_avail++;
10137 }
10138 }
10139
10140 int plain_len = 0;
10141
10142 int parser_status;
10143
10144 int iter = MAX_CUT_TRIES;
10145
10146 do
10147 {
10148 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10149 {
10150 if (line_buf[i] == ':')
10151 {
10152 line_len--;
10153
10154 break;
10155 }
10156 }
10157
10158 if (data.hash_mode != 2500)
10159 {
10160 parser_status = parse_func (line_buf, line_len, hashes_buf);
10161 }
10162 else
10163 {
10164 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10165
10166 if (line_len > max_salt_size)
10167 {
10168 parser_status = PARSER_GLOBAL_LENGTH;
10169 }
10170 else
10171 {
10172 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10173
10174 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10175
10176 hashes_buf->salt->salt_len = line_len;
10177
10178 parser_status = PARSER_OK;
10179 }
10180 }
10181
10182 // if NOT parsed without error, we add the ":" to the plain
10183
10184 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10185 {
10186 plain_len++;
10187 plain_buf--;
10188 }
10189
10190 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10191
10192 if (parser_status < PARSER_GLOBAL_ZERO)
10193 {
10194 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10195
10196 continue;
10197 }
10198
10199 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10200
10201 pot_ptr->plain_len = plain_len;
10202
10203 pot_cnt++;
10204 }
10205
10206 fclose (pot_fp);
10207
10208 SUPPRESS_OUTPUT = 0;
10209
10210 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10211 }
10212
10213 /**
10214 * kernel accel and loops auto adjustment
10215 */
10216
10217 if (kernel_accel_chgd == 0) kernel_accel = set_kernel_accel (hash_mode);
10218 if (kernel_loops_chgd == 0) kernel_loops = set_kernel_loops (hash_mode);
10219
10220 if (workload_profile == 1)
10221 {
10222 kernel_loops /= 8;
10223 kernel_accel /= 4;
10224
10225 if (kernel_loops == 0) kernel_loops = 8;
10226 if (kernel_accel == 0) kernel_accel = 2;
10227 }
10228 else if (workload_profile == 3)
10229 {
10230 kernel_loops *= 8;
10231 kernel_accel *= 4;
10232
10233 if (kernel_loops > 1024) kernel_loops = 1024;
10234 if (kernel_accel > 256) kernel_accel = 256; // causes memory problems otherwise
10235 }
10236
10237 // those hashes *must* run at a specific kernel_loops count because of some optimization inside the kernel
10238
10239 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
10240 {
10241 kernel_loops = 1024;
10242 }
10243
10244 if (hash_mode == 12500)
10245 {
10246 kernel_loops = ROUNDS_RAR3 / 16;
10247 }
10248
10249 data.kernel_accel = kernel_accel;
10250 data.kernel_loops = kernel_loops;
10251
10252 /**
10253 * word len
10254 */
10255
10256 uint pw_min = PW_MIN;
10257 uint pw_max = PW_MAX;
10258
10259 switch (hash_mode)
10260 {
10261 case 400: if (pw_max > 40) pw_max = 40;
10262 break;
10263 case 500: if (pw_max > 16) pw_max = 16;
10264 break;
10265 case 1500: if (pw_max > 8) pw_max = 8;
10266 break;
10267 case 1600: if (pw_max > 16) pw_max = 16;
10268 break;
10269 case 1800: if (pw_max > 16) pw_max = 16;
10270 break;
10271 case 2100: if (pw_max > 16) pw_max = 16;
10272 break;
10273 case 2500: if (pw_min < 8) pw_min = 8;
10274 break;
10275 case 3000: if (pw_max > 7) pw_max = 7;
10276 break;
10277 case 5200: if (pw_max > 24) pw_max = 24;
10278 break;
10279 case 5800: if (pw_max > 16) pw_max = 16;
10280 break;
10281 case 6300: if (pw_max > 16) pw_max = 16;
10282 break;
10283 case 7400: if (pw_max > 16) pw_max = 16;
10284 break;
10285 case 7900: if (pw_max > 48) pw_max = 48;
10286 break;
10287 case 8500: if (pw_max > 8) pw_max = 8;
10288 break;
10289 case 8600: if (pw_max > 16) pw_max = 16;
10290 break;
10291 case 9710: pw_min = 5;
10292 pw_max = 5;
10293 break;
10294 case 9810: pw_min = 5;
10295 pw_max = 5;
10296 break;
10297 case 10410: pw_min = 5;
10298 pw_max = 5;
10299 break;
10300 case 10300: if (pw_max < 3) pw_min = 3;
10301 if (pw_max > 40) pw_max = 40;
10302 break;
10303 case 10500: if (pw_max < 3) pw_min = 3;
10304 if (pw_max > 40) pw_max = 40;
10305 break;
10306 case 10700: if (pw_max > 16) pw_max = 16;
10307 break;
10308 case 11300: if (pw_max > 40) pw_max = 40;
10309 break;
10310 case 12500: if (pw_max > 20) pw_max = 20;
10311 break;
10312 case 12800: if (pw_max > 24) pw_max = 24;
10313 break;
10314 }
10315
10316 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10317 {
10318 switch (attack_kern)
10319 {
10320 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10321 break;
10322 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10323 break;
10324 }
10325 }
10326
10327 /**
10328 * charsets : keep them together for more easy maintainnce
10329 */
10330
10331 cs_t mp_sys[6];
10332 cs_t mp_usr[4];
10333
10334 memset (mp_sys, 0, sizeof (mp_sys));
10335 memset (mp_usr, 0, sizeof (mp_usr));
10336
10337 mp_setup_sys (mp_sys);
10338
10339 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10340 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10341 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10342 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10343
10344 /**
10345 * load hashes, part I: find input mode, count hashes
10346 */
10347
10348 uint hashlist_mode = 0;
10349 uint hashlist_format = HLFMT_HASHCAT;
10350
10351 uint hashes_avail = 0;
10352
10353 if (benchmark == 0)
10354 {
10355 struct stat f;
10356
10357 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10358
10359 if ((hash_mode == 2500) ||
10360 (hash_mode == 5200) ||
10361 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10362 (hash_mode == 9000))
10363 {
10364 hashlist_mode = HL_MODE_ARG;
10365
10366 char *hashfile = myargv[optind];
10367
10368 data.hashfile = hashfile;
10369
10370 logfile_top_var_string ("target", hashfile);
10371 }
10372
10373 if (hashlist_mode == HL_MODE_ARG)
10374 {
10375 if (hash_mode == 2500)
10376 {
10377 struct stat st;
10378
10379 if (stat (data.hashfile, &st) == -1)
10380 {
10381 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10382
10383 return (-1);
10384 }
10385
10386 hashes_avail = st.st_size / sizeof (hccap_t);
10387 }
10388 else
10389 {
10390 hashes_avail = 1;
10391 }
10392 }
10393 else if (hashlist_mode == HL_MODE_FILE)
10394 {
10395 char *hashfile = myargv[optind];
10396
10397 data.hashfile = hashfile;
10398
10399 logfile_top_var_string ("target", hashfile);
10400
10401 FILE *fp = NULL;
10402
10403 if ((fp = fopen (hashfile, "rb")) == NULL)
10404 {
10405 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10406
10407 return (-1);
10408 }
10409
10410 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10411
10412 hashes_avail = count_lines (fp);
10413
10414 rewind (fp);
10415
10416 if (hashes_avail == 0)
10417 {
10418 log_error ("ERROR: hashfile is empty or corrupt");
10419
10420 fclose (fp);
10421
10422 return (-1);
10423 }
10424
10425 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10426
10427 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10428 {
10429 log_error ("ERROR: remove not supported in native hashfile-format mode");
10430
10431 fclose (fp);
10432
10433 return (-1);
10434 }
10435
10436 fclose (fp);
10437 }
10438 }
10439 else
10440 {
10441 hashlist_mode = HL_MODE_ARG;
10442
10443 hashes_avail = 1;
10444 }
10445
10446 if (hash_mode == 3000) hashes_avail *= 2;
10447
10448 data.hashlist_mode = hashlist_mode;
10449 data.hashlist_format = hashlist_format;
10450
10451 logfile_top_uint (hashlist_mode);
10452 logfile_top_uint (hashlist_format);
10453
10454 /**
10455 * load hashes, part II: allocate required memory, set pointers
10456 */
10457
10458 hash_t *hashes_buf = NULL;
10459 void *digests_buf = NULL;
10460 salt_t *salts_buf = NULL;
10461 void *esalts_buf = NULL;
10462
10463 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10464
10465 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10466
10467 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10468 {
10469 uint32_t hash_pos;
10470
10471 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10472 {
10473 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10474
10475 hashes_buf[hash_pos].hash_info = hash_info;
10476
10477 if (username && (remove || show || left))
10478 {
10479 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10480 }
10481
10482 if (benchmark)
10483 {
10484 hash_info->orighash = (char *) mymalloc (256);
10485 }
10486 }
10487 }
10488
10489 if (isSalted)
10490 {
10491 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10492
10493 if (esalt_size)
10494 {
10495 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10496 }
10497 }
10498 else
10499 {
10500 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10501 }
10502
10503 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10504 {
10505 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10506
10507 if (isSalted)
10508 {
10509 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10510
10511 if (esalt_size)
10512 {
10513 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10514 }
10515 }
10516 else
10517 {
10518 hashes_buf[hash_pos].salt = &salts_buf[0];
10519 }
10520 }
10521
10522 /**
10523 * load hashes, part III: parse hashes or generate them if benchmark
10524 */
10525
10526 uint hashes_cnt = 0;
10527
10528 if (benchmark == 0)
10529 {
10530 if (keyspace == 1)
10531 {
10532 // useless to read hash file for keyspace, cheat a little bit w/ optind
10533 }
10534 else if (hashes_avail == 0)
10535 {
10536 }
10537 else if (hashlist_mode == HL_MODE_ARG)
10538 {
10539 char *input_buf = myargv[optind];
10540
10541 uint input_len = strlen (input_buf);
10542
10543 logfile_top_var_string ("target", input_buf);
10544
10545 char *hash_buf = NULL;
10546 int hash_len = 0;
10547
10548 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10549
10550 if (hash_len)
10551 {
10552 if (opts_type & OPTS_TYPE_HASH_COPY)
10553 {
10554 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10555
10556 hash_info_tmp->orighash = mystrdup (hash_buf);
10557 }
10558
10559 if (isSalted)
10560 {
10561 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10562 }
10563
10564 int parser_status = PARSER_OK;
10565
10566 if (hash_mode == 2500)
10567 {
10568 if (hash_len == 0)
10569 {
10570 log_error ("ERROR: hccap file not specified");
10571
10572 return (-1);
10573 }
10574
10575 hashlist_mode = HL_MODE_FILE;
10576
10577 data.hashlist_mode = hashlist_mode;
10578
10579 FILE *fp = fopen (hash_buf, "rb");
10580
10581 if (fp == NULL)
10582 {
10583 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10584
10585 return (-1);
10586 }
10587
10588 if (hashes_avail < 1)
10589 {
10590 log_error ("ERROR: hccap file is empty or corrupt");
10591
10592 fclose (fp);
10593
10594 return (-1);
10595 }
10596
10597 uint hccap_size = sizeof (hccap_t);
10598
10599 char in[hccap_size];
10600
10601 while (!feof (fp))
10602 {
10603 int n = fread (&in, hccap_size, 1, fp);
10604
10605 if (n != 1)
10606 {
10607 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
10608
10609 break;
10610 }
10611
10612 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
10613
10614 if (parser_status != PARSER_OK)
10615 {
10616 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
10617
10618 continue;
10619 }
10620
10621 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
10622
10623 if ((show == 1) || (left == 1))
10624 {
10625 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
10626
10627 char *salt_ptr = (char *) tmp_salt->salt_buf;
10628
10629 int cur_pos = tmp_salt->salt_len;
10630 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10631
10632 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
10633
10634 unsigned char *pke_ptr = (unsigned char *) wpa->pke;
10635
10636 // do the appending task
10637
10638 snprintf (salt_ptr + cur_pos,
10639 rem_len,
10640 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
10641 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
10642 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
10643
10644
10645 // memset () the remaining part of the salt
10646
10647 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
10648 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10649
10650 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
10651
10652 tmp_salt->salt_len += 1 + 12 + 1 + 12;
10653 }
10654
10655 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);
10656 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);
10657
10658 hashes_cnt++;
10659 }
10660
10661 fclose (fp);
10662 }
10663 else if (hash_mode == 3000)
10664 {
10665 if (hash_len == 32)
10666 {
10667 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10668
10669 hash_t *lm_hash_left = NULL;
10670
10671 if (parser_status == PARSER_OK)
10672 {
10673 lm_hash_left = &hashes_buf[hashes_cnt];
10674
10675 hashes_cnt++;
10676 }
10677 else
10678 {
10679 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10680 }
10681
10682
10683 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10684
10685 hash_t *lm_hash_right = NULL;
10686
10687 if (parser_status == PARSER_OK)
10688 {
10689 lm_hash_right = &hashes_buf[hashes_cnt];
10690
10691 hashes_cnt++;
10692 }
10693 else
10694 {
10695 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10696 }
10697
10698 // show / left
10699
10700 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
10701 {
10702 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);
10703 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);
10704 }
10705 }
10706 else
10707 {
10708 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10709
10710 if (parser_status == PARSER_OK)
10711 {
10712 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10713 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10714 }
10715
10716 if (parser_status == PARSER_OK)
10717 {
10718 hashes_cnt++;
10719 }
10720 else
10721 {
10722 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10723 }
10724 }
10725 }
10726 else
10727 {
10728 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10729
10730 if (parser_status == PARSER_OK)
10731 {
10732 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10733 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10734 }
10735
10736 if (parser_status == PARSER_OK)
10737 {
10738 hashes_cnt++;
10739 }
10740 else
10741 {
10742 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10743 }
10744 }
10745 }
10746 }
10747 else if (hashlist_mode == HL_MODE_FILE)
10748 {
10749 char *hashfile = data.hashfile;
10750
10751 FILE *fp;
10752
10753 if ((fp = fopen (hashfile, "rb")) == NULL)
10754 {
10755 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10756
10757 return (-1);
10758 }
10759
10760 uint line_num = 0;
10761
10762 while (!feof (fp))
10763 {
10764 line_num++;
10765
10766 char line_buf[BUFSIZ];
10767
10768 int line_len = fgetl (fp, line_buf);
10769
10770 if (line_len == 0) continue;
10771
10772 char *hash_buf = NULL;
10773 int hash_len = 0;
10774
10775 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
10776
10777 if (username)
10778 {
10779 char *user_buf = NULL;
10780 int user_len = 0;
10781
10782 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
10783
10784 if (remove || show)
10785 {
10786 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
10787
10788 *user = (user_t *) malloc (sizeof (user_t));
10789
10790 user_t *user_ptr = *user;
10791
10792 if (user_buf != NULL)
10793 {
10794 user_ptr->user_name = mystrdup (user_buf);
10795 }
10796 else
10797 {
10798 user_ptr->user_name = mystrdup ("");
10799 }
10800
10801 user_ptr->user_len = user_len;
10802 }
10803 }
10804
10805 if (opts_type & OPTS_TYPE_HASH_COPY)
10806 {
10807 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10808
10809 hash_info_tmp->orighash = mystrdup (hash_buf);
10810 }
10811
10812 if (isSalted)
10813 {
10814 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
10815 }
10816
10817 if (hash_mode == 3000)
10818 {
10819 if (hash_len == 32)
10820 {
10821 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10822
10823 if (parser_status < PARSER_GLOBAL_ZERO)
10824 {
10825 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10826
10827 continue;
10828 }
10829
10830 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
10831
10832 hashes_cnt++;
10833
10834 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10835
10836 if (parser_status < PARSER_GLOBAL_ZERO)
10837 {
10838 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10839
10840 continue;
10841 }
10842
10843 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
10844
10845 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);
10846
10847 hashes_cnt++;
10848
10849 // show / left
10850
10851 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);
10852 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);
10853 }
10854 else
10855 {
10856 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10857
10858 if (parser_status < PARSER_GLOBAL_ZERO)
10859 {
10860 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10861
10862 continue;
10863 }
10864
10865 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);
10866
10867 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10868 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10869
10870 hashes_cnt++;
10871 }
10872 }
10873 else
10874 {
10875 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10876
10877 if (parser_status < PARSER_GLOBAL_ZERO)
10878 {
10879 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10880
10881 continue;
10882 }
10883
10884 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);
10885
10886 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10887 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10888
10889 hashes_cnt++;
10890 }
10891 }
10892
10893 fclose (fp);
10894
10895 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
10896
10897 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
10898 }
10899 }
10900 else
10901 {
10902 if (isSalted)
10903 {
10904 hashes_buf[0].salt->salt_len = 8;
10905
10906 // special salt handling
10907
10908 switch (hash_mode)
10909 {
10910 case 1500: hashes_buf[0].salt->salt_len = 2;
10911 break;
10912 case 1731: hashes_buf[0].salt->salt_len = 4;
10913 break;
10914 case 2410: hashes_buf[0].salt->salt_len = 4;
10915 break;
10916 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
10917 break;
10918 case 3100: hashes_buf[0].salt->salt_len = 1;
10919 break;
10920 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
10921 break;
10922 case 5800: hashes_buf[0].salt->salt_len = 16;
10923 break;
10924 case 6800: hashes_buf[0].salt->salt_len = 32;
10925 break;
10926 case 8400: hashes_buf[0].salt->salt_len = 40;
10927 break;
10928 case 8800: hashes_buf[0].salt->salt_len = 16;
10929 break;
10930 case 8900: hashes_buf[0].salt->salt_len = 16;
10931 hashes_buf[0].salt->scrypt_N = 1024;
10932 hashes_buf[0].salt->scrypt_r = 1;
10933 hashes_buf[0].salt->scrypt_p = 1;
10934 break;
10935 case 9100: hashes_buf[0].salt->salt_len = 16;
10936 break;
10937 case 9300: hashes_buf[0].salt->salt_len = 14;
10938 hashes_buf[0].salt->scrypt_N = 16384;
10939 hashes_buf[0].salt->scrypt_r = 1;
10940 hashes_buf[0].salt->scrypt_p = 1;
10941 break;
10942 case 9400: hashes_buf[0].salt->salt_len = 16;
10943 break;
10944 case 9500: hashes_buf[0].salt->salt_len = 16;
10945 break;
10946 case 9600: hashes_buf[0].salt->salt_len = 16;
10947 break;
10948 case 9700: hashes_buf[0].salt->salt_len = 16;
10949 break;
10950 case 9710: hashes_buf[0].salt->salt_len = 16;
10951 break;
10952 case 9720: hashes_buf[0].salt->salt_len = 16;
10953 break;
10954 case 9800: hashes_buf[0].salt->salt_len = 16;
10955 break;
10956 case 9810: hashes_buf[0].salt->salt_len = 16;
10957 break;
10958 case 9820: hashes_buf[0].salt->salt_len = 16;
10959 break;
10960 case 10300: hashes_buf[0].salt->salt_len = 12;
10961 break;
10962 case 11500: hashes_buf[0].salt->salt_len = 4;
10963 break;
10964 case 11600: hashes_buf[0].salt->salt_len = 4;
10965 break;
10966 case 12400: hashes_buf[0].salt->salt_len = 4;
10967 break;
10968 case 12500: hashes_buf[0].salt->salt_len = 8;
10969 break;
10970 case 12600: hashes_buf[0].salt->salt_len = 64;
10971 break;
10972 }
10973
10974 // special esalt handling
10975
10976 switch (hash_mode)
10977 {
10978 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
10979 break;
10980 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
10981 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
10982 break;
10983 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
10984 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
10985 break;
10986 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
10987 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
10988 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
10989 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
10990 break;
10991 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
10992 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
10993 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
10994 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
10995 break;
10996 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
10997 break;
10998 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10999 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11000 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11001 break;
11002 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11003 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11004 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11005 break;
11006 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11007 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11008 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11009 break;
11010 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11011 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11012 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11013 break;
11014 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11015 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11016 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11017 break;
11018 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11019 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11020 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11021 break;
11022 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11023 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11024 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11025 break;
11026 }
11027 }
11028
11029 // set hashfile
11030
11031 switch (hash_mode)
11032 {
11033 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11034 break;
11035 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11036 break;
11037 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11038 break;
11039 case 6211:
11040 case 6212:
11041 case 6213:
11042 case 6221:
11043 case 6222:
11044 case 6223:
11045 case 6231:
11046 case 6232:
11047 case 6233:
11048 case 6241:
11049 case 6242:
11050 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11051 break;
11052 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11053 break;
11054 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11055 break;
11056 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11057 break;
11058 }
11059
11060 // set default iterations
11061
11062 switch (hash_mode)
11063 {
11064 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11065 break;
11066 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11067 break;
11068 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11069 break;
11070 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11071 break;
11072 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11073 break;
11074 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11075 break;
11076 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11077 break;
11078 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11079 break;
11080 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11081 break;
11082 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11083 break;
11084 case 6211:
11085 case 6212:
11086 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11087 break;
11088 case 6221:
11089 case 6222:
11090 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11091 break;
11092 case 6231:
11093 case 6232:
11094 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11095 break;
11096 case 6241:
11097 case 6242:
11098 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11099 break;
11100 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11101 break;
11102 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11103 break;
11104 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11105 break;
11106 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11107 break;
11108 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11109 break;
11110 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11111 break;
11112 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11113 break;
11114 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11115 break;
11116 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11117 break;
11118 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11119 break;
11120 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11121 break;
11122 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11123 break;
11124 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11125 break;
11126 case 8900: hashes_buf[0].salt->salt_iter = 1;
11127 break;
11128 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11129 break;
11130 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11131 break;
11132 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11133 break;
11134 case 9300: hashes_buf[0].salt->salt_iter = 1;
11135 break;
11136 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11137 break;
11138 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11139 break;
11140 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11141 break;
11142 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11143 break;
11144 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11145 break;
11146 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11147 break;
11148 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11149 break;
11150 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11151 break;
11152 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11153 break;
11154 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11155 break;
11156 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11157 break;
11158 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11159 break;
11160 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11161 break;
11162 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11163 break;
11164 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11165 break;
11166 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11167 break;
11168 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11169 break;
11170 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11171 break;
11172 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11173 break;
11174 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11175 break;
11176 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11177 break;
11178 }
11179
11180 // set special tuning for benchmark-mode 1
11181
11182 if (benchmark_mode == 1)
11183 {
11184 kernel_loops *= 8;
11185 kernel_accel *= 4;
11186
11187 switch (hash_mode)
11188 {
11189 case 400: kernel_loops = ROUNDS_PHPASS;
11190 kernel_accel = 32;
11191 break;
11192 case 500: kernel_loops = ROUNDS_MD5CRYPT;
11193 kernel_accel = 32;
11194 break;
11195 case 501: kernel_loops = ROUNDS_MD5CRYPT;
11196 kernel_accel = 32;
11197 break;
11198 case 1600: kernel_loops = ROUNDS_MD5CRYPT;
11199 kernel_accel = 32;
11200 break;
11201 case 1800: kernel_loops = ROUNDS_SHA512CRYPT;
11202 kernel_accel = 16;
11203 break;
11204 case 2100: kernel_loops = ROUNDS_DCC2;
11205 kernel_accel = 16;
11206 break;
11207 case 2500: kernel_loops = ROUNDS_WPA2;
11208 kernel_accel = 32;
11209 break;
11210 case 3200: kernel_loops = ROUNDS_BCRYPT;
11211 kernel_accel = 8;
11212 break;
11213 case 5200: kernel_loops = ROUNDS_PSAFE3;
11214 kernel_accel = 16;
11215 break;
11216 case 5800: kernel_loops = ROUNDS_ANDROIDPIN;
11217 kernel_accel = 16;
11218 break;
11219 case 6211: kernel_loops = ROUNDS_TRUECRYPT_2K;
11220 kernel_accel = 64;
11221 break;
11222 case 6212: kernel_loops = ROUNDS_TRUECRYPT_2K;
11223 kernel_accel = 32;
11224 break;
11225 case 6213: kernel_loops = ROUNDS_TRUECRYPT_2K;
11226 kernel_accel = 32;
11227 break;
11228 case 6221: kernel_loops = ROUNDS_TRUECRYPT_1K;
11229 kernel_accel = 8;
11230 break;
11231 case 6222: kernel_loops = ROUNDS_TRUECRYPT_1K;
11232 kernel_accel = 8;
11233 break;
11234 case 6223: kernel_loops = ROUNDS_TRUECRYPT_1K;
11235 kernel_accel = 8;
11236 break;
11237 case 6231: kernel_loops = ROUNDS_TRUECRYPT_1K;
11238 kernel_accel = 8;
11239 break;
11240 case 6232: kernel_loops = ROUNDS_TRUECRYPT_1K;
11241 kernel_accel = 8;
11242 break;
11243 case 6233: kernel_loops = ROUNDS_TRUECRYPT_1K;
11244 kernel_accel = 8;
11245 break;
11246 case 6241: kernel_loops = ROUNDS_TRUECRYPT_1K;
11247 kernel_accel = 128;
11248 break;
11249 case 6242: kernel_loops = ROUNDS_TRUECRYPT_1K;
11250 kernel_accel = 64;
11251 break;
11252 case 6243: kernel_loops = ROUNDS_TRUECRYPT_1K;
11253 kernel_accel = 64;
11254 break;
11255 case 6300: kernel_loops = ROUNDS_MD5CRYPT;
11256 kernel_accel = 32;
11257 break;
11258 case 6700: kernel_loops = ROUNDS_SHA1AIX;
11259 kernel_accel = 128;
11260 break;
11261 case 6400: kernel_loops = ROUNDS_SHA256AIX;
11262 kernel_accel = 128;
11263 break;
11264 case 6500: kernel_loops = ROUNDS_SHA512AIX;
11265 kernel_accel = 32;
11266 break;
11267 case 6600: kernel_loops = ROUNDS_AGILEKEY;
11268 kernel_accel = 64;
11269 break;
11270 case 6800: kernel_loops = ROUNDS_LASTPASS;
11271 kernel_accel = 64;
11272 break;
11273 case 7100: kernel_loops = ROUNDS_SHA512OSX;
11274 kernel_accel = 8;
11275 break;
11276 case 7200: kernel_loops = ROUNDS_GRUB;
11277 kernel_accel = 16;
11278 break;
11279 case 7400: kernel_loops = ROUNDS_SHA256CRYPT;
11280 kernel_accel = 8;
11281 break;
11282 case 7900: kernel_loops = ROUNDS_DRUPAL7;
11283 kernel_accel = 8;
11284 break;
11285 case 8200: kernel_loops = ROUNDS_CLOUDKEY;
11286 kernel_accel = 8;
11287 break;
11288 case 8800: kernel_loops = ROUNDS_ANDROIDFDE;
11289 kernel_accel = 32;
11290 break;
11291 case 8900: kernel_loops = 1;
11292 kernel_accel = 64;
11293 break;
11294 case 9000: kernel_loops = ROUNDS_PSAFE2;
11295 kernel_accel = 16;
11296 break;
11297 case 9100: kernel_loops = ROUNDS_LOTUS8;
11298 kernel_accel = 64;
11299 break;
11300 case 9200: kernel_loops = ROUNDS_CISCO8;
11301 kernel_accel = 8;
11302 break;
11303 case 9300: kernel_loops = 1;
11304 kernel_accel = 4;
11305 break;
11306 case 9400: kernel_loops = ROUNDS_OFFICE2007;
11307 kernel_accel = 32;
11308 break;
11309 case 9500: kernel_loops = ROUNDS_OFFICE2010;
11310 kernel_accel = 32;
11311 break;
11312 case 9600: kernel_loops = ROUNDS_OFFICE2013;
11313 kernel_accel = 8;
11314 break;
11315 case 10000: kernel_loops = ROUNDS_DJANGOPBKDF2;
11316 kernel_accel = 8;
11317 break;
11318 case 10300: kernel_loops = ROUNDS_SAPH_SHA1;
11319 kernel_accel = 16;
11320 break;
11321 case 10500: kernel_loops = ROUNDS_PDF14;
11322 kernel_accel = 256;
11323 break;
11324 case 10700: kernel_loops = ROUNDS_PDF17L8;
11325 kernel_accel = 8;
11326 break;
11327 case 10900: kernel_loops = ROUNDS_PBKDF2_SHA256;
11328 kernel_accel = 8;
11329 break;
11330 case 11300: kernel_loops = ROUNDS_BITCOIN_WALLET;
11331 kernel_accel = 8;
11332 break;
11333 case 11600: kernel_loops = ROUNDS_SEVEN_ZIP;
11334 kernel_accel = 8;
11335 break;
11336 case 11900: kernel_loops = ROUNDS_PBKDF2_MD5;
11337 kernel_accel = 8;
11338 break;
11339 case 12000: kernel_loops = ROUNDS_PBKDF2_SHA1;
11340 kernel_accel = 8;
11341 break;
11342 case 12100: kernel_loops = ROUNDS_PBKDF2_SHA512;
11343 kernel_accel = 8;
11344 break;
11345 case 12200: kernel_loops = ROUNDS_ECRYPTFS;
11346 kernel_accel = 8;
11347 break;
11348 case 12300: kernel_loops = ROUNDS_ORACLET;
11349 kernel_accel = 8;
11350 break;
11351 case 12500: kernel_loops = ROUNDS_RAR3;
11352 kernel_accel = 32;
11353 break;
11354 case 12700: kernel_loops = ROUNDS_MYWALLET;
11355 kernel_accel = 512;
11356 break;
11357 case 12800: kernel_loops = ROUNDS_MS_DRSR;
11358 kernel_accel = 512;
11359 break;
11360 case 12900: kernel_loops = ROUNDS_ANDROIDFDE_SAMSUNG;
11361 kernel_accel = 8;
11362 break;
11363 case 13000: kernel_loops = ROUNDS_RAR5;
11364 kernel_accel = 8;
11365 break;
11366 }
11367
11368 // some algorithm collide too fast, make that impossible
11369
11370 switch (hash_mode)
11371 {
11372 case 11500: ((uint *) digests_buf)[1] = 1;
11373 break;
11374 }
11375
11376 if (kernel_loops > 1024) kernel_loops = 1024;
11377 if (kernel_accel > 256) kernel_accel = 256; // causes memory problems otherwise
11378 }
11379
11380 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
11381 {
11382 kernel_loops = 1024;
11383 }
11384
11385 if (hash_mode == 12500)
11386 {
11387 kernel_loops = ROUNDS_RAR3 / 16;
11388 }
11389
11390 data.kernel_accel = kernel_accel;
11391 data.kernel_loops = kernel_loops;
11392
11393 hashes_cnt = 1;
11394 }
11395
11396 if (show == 1 || left == 1)
11397 {
11398 for (uint i = 0; i < pot_cnt; i++)
11399 {
11400 pot_t *pot_ptr = &pot[i];
11401
11402 hash_t *hashes_buf = &pot_ptr->hash;
11403
11404 local_free (hashes_buf->digest);
11405
11406 if (isSalted)
11407 {
11408 local_free (hashes_buf->salt);
11409 }
11410 }
11411
11412 local_free (pot);
11413
11414 if (data.quiet == 0) log_info_nn ("");
11415
11416 return (0);
11417 }
11418
11419 if (keyspace == 0)
11420 {
11421 if (hashes_cnt == 0)
11422 {
11423 log_error ("ERROR: No hashes loaded");
11424
11425 return (-1);
11426 }
11427 }
11428
11429 /**
11430 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11431 */
11432
11433 if (data.outfile != NULL)
11434 {
11435 if (data.hashfile != NULL)
11436 {
11437 #ifdef _POSIX
11438 struct stat tmpstat_outfile;
11439 struct stat tmpstat_hashfile;
11440 #endif
11441
11442 #ifdef _WIN
11443 struct stat64 tmpstat_outfile;
11444 struct stat64 tmpstat_hashfile;
11445 #endif
11446
11447 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11448
11449 if (tmp_outfile_fp)
11450 {
11451 #ifdef _POSIX
11452 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11453 #endif
11454
11455 #ifdef _WIN
11456 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11457 #endif
11458
11459 fclose (tmp_outfile_fp);
11460 }
11461
11462 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11463
11464 if (tmp_hashfile_fp)
11465 {
11466 #ifdef _POSIX
11467 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11468 #endif
11469
11470 #ifdef _WIN
11471 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11472 #endif
11473
11474 fclose (tmp_hashfile_fp);
11475 }
11476
11477 if (tmp_outfile_fp && tmp_outfile_fp)
11478 {
11479 tmpstat_outfile.st_mode = 0;
11480 tmpstat_outfile.st_nlink = 0;
11481 tmpstat_outfile.st_uid = 0;
11482 tmpstat_outfile.st_gid = 0;
11483 tmpstat_outfile.st_rdev = 0;
11484 tmpstat_outfile.st_atime = 0;
11485
11486 tmpstat_hashfile.st_mode = 0;
11487 tmpstat_hashfile.st_nlink = 0;
11488 tmpstat_hashfile.st_uid = 0;
11489 tmpstat_hashfile.st_gid = 0;
11490 tmpstat_hashfile.st_rdev = 0;
11491 tmpstat_hashfile.st_atime = 0;
11492
11493 #ifdef _POSIX
11494 tmpstat_outfile.st_blksize = 0;
11495 tmpstat_outfile.st_blocks = 0;
11496
11497 tmpstat_hashfile.st_blksize = 0;
11498 tmpstat_hashfile.st_blocks = 0;
11499 #endif
11500
11501 #ifdef _POSIX
11502 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11503 {
11504 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11505
11506 return (-1);
11507 }
11508 #endif
11509
11510 #ifdef _WIN
11511 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11512 {
11513 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11514
11515 return (-1);
11516 }
11517 #endif
11518 }
11519 }
11520 }
11521
11522 /**
11523 * Remove duplicates
11524 */
11525
11526 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11527
11528 if (isSalted)
11529 {
11530 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11531 }
11532 else
11533 {
11534 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11535 }
11536
11537 uint hashes_cnt_orig = hashes_cnt;
11538
11539 hashes_cnt = 1;
11540
11541 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11542 {
11543 if (isSalted)
11544 {
11545 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11546 {
11547 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11548 }
11549 }
11550 else
11551 {
11552 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11553 }
11554
11555 if (hashes_pos > hashes_cnt)
11556 {
11557 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11558 }
11559
11560 hashes_cnt++;
11561 }
11562
11563 /**
11564 * Potfile removes
11565 */
11566
11567 uint potfile_remove_cracks = 0;
11568
11569 if (potfile_disable == 0)
11570 {
11571 hash_t hash_buf;
11572
11573 hash_buf.digest = mymalloc (dgst_size);
11574 hash_buf.salt = NULL;
11575 hash_buf.esalt = NULL;
11576 hash_buf.hash_info = NULL;
11577 hash_buf.cracked = 0;
11578
11579 if (isSalted)
11580 {
11581 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11582 }
11583
11584 if (esalt_size)
11585 {
11586 hash_buf.esalt = mymalloc (esalt_size);
11587 }
11588
11589 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11590
11591 // no solution for these special hash types (for instane because they use hashfile in output etc)
11592 if ((hash_mode != 5200) &&
11593 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11594 (hash_mode != 9000))
11595 {
11596 FILE *fp = fopen (potfile, "rb");
11597
11598 if (fp != NULL)
11599 {
11600 while (!feof (fp))
11601 {
11602 char line_buf[BUFSIZ];
11603
11604 memset (line_buf, 0, BUFSIZ);
11605
11606 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11607
11608 if (ptr == NULL) break;
11609
11610 int line_len = strlen (line_buf);
11611
11612 if (line_len == 0) continue;
11613
11614 int iter = MAX_CUT_TRIES;
11615
11616 for (int i = line_len - 1; i && iter; i--, line_len--)
11617 {
11618 if (line_buf[i] != ':') continue;
11619
11620 if (isSalted)
11621 {
11622 memset (hash_buf.salt, 0, sizeof (salt_t));
11623 }
11624
11625 hash_t *found = NULL;
11626
11627 if (hash_mode == 6800)
11628 {
11629 if (i < 48) // 48 = 12 * uint in salt_buf[]
11630 {
11631 // manipulate salt_buf
11632 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11633
11634 hash_buf.salt->salt_len = i;
11635
11636 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11637 }
11638 }
11639 else if (hash_mode == 2500)
11640 {
11641 if (i < 48) // 48 = 12 * uint in salt_buf[]
11642 {
11643 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11644 // manipulate salt_buf
11645
11646 // to be safe work with a copy (because of line_len loop, i etc)
11647
11648 char line_buf_cpy[BUFSIZ];
11649 memset (line_buf_cpy, 0, BUFSIZ);
11650
11651 memset (line_buf_cpy, 0, sizeof (line_buf_cpy));
11652
11653 memcpy (line_buf_cpy, line_buf, i);
11654
11655 char *mac2_pos = strrchr (line_buf_cpy, ':');
11656
11657 if (mac2_pos == NULL) continue;
11658
11659 mac2_pos[0] = 0;
11660 mac2_pos++;
11661
11662 if (strlen (mac2_pos) != 12) continue;
11663
11664 char *mac1_pos = strrchr (line_buf_cpy, ':');
11665
11666 if (mac1_pos == NULL) continue;
11667
11668 mac1_pos[0] = 0;
11669 mac1_pos++;
11670
11671 if (strlen (mac1_pos) != 12) continue;
11672
11673 uint essid_length = mac1_pos - line_buf_cpy - 1;
11674
11675 // here we need the ESSID
11676 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11677
11678 hash_buf.salt->salt_len = essid_length;
11679
11680 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11681
11682 if (found)
11683 {
11684 wpa_t *wpa = (wpa_t *) found->esalt;
11685
11686 uint pke[25];
11687
11688 char *pke_ptr = (char *) pke;
11689
11690 for (uint i = 0; i < 25; i++)
11691 {
11692 pke[i] = byte_swap_32 (wpa->pke[i]);
11693 }
11694
11695 unsigned char mac1[6];
11696 unsigned char mac2[6];
11697
11698 memcpy (mac1, pke_ptr + 23, 6);
11699 memcpy (mac2, pke_ptr + 29, 6);
11700
11701 // compare hex string(s) vs binary MAC address(es)
11702
11703 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11704 {
11705 if (mac1[i] != (unsigned char) hex_to_char (&mac1_pos[j]))
11706 {
11707 found = NULL;
11708 break;
11709 }
11710 }
11711
11712 // early skip ;)
11713 if (!found) continue;
11714
11715 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11716 {
11717 if (mac2[i] != (unsigned char) hex_to_char (&mac2_pos[j]))
11718 {
11719 found = NULL;
11720 break;
11721 }
11722 }
11723 }
11724 }
11725 }
11726 else
11727 {
11728 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11729
11730 if (parser_status == PARSER_OK)
11731 {
11732 if (isSalted)
11733 {
11734 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11735 }
11736 else
11737 {
11738 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11739 }
11740 }
11741 }
11742
11743 if (found == NULL) continue;
11744
11745 if (!found->cracked) potfile_remove_cracks++;
11746
11747 found->cracked = 1;
11748
11749 if (found) break;
11750
11751 iter--;
11752 }
11753 }
11754
11755 fclose (fp);
11756 }
11757 }
11758
11759 if (esalt_size)
11760 {
11761 local_free (hash_buf.esalt);
11762 }
11763
11764 if (isSalted)
11765 {
11766 local_free (hash_buf.salt);
11767 }
11768
11769 local_free (hash_buf.digest);
11770 }
11771
11772 /**
11773 * Now generate all the buffers required for later
11774 */
11775
11776 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11777
11778 salt_t *salts_buf_new = NULL;
11779 void *esalts_buf_new = NULL;
11780
11781 if (isSalted)
11782 {
11783 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11784
11785 if (esalt_size)
11786 {
11787 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
11788 }
11789 }
11790 else
11791 {
11792 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
11793 }
11794
11795 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
11796
11797 uint digests_cnt = hashes_cnt;
11798 uint digests_done = 0;
11799
11800 uint size_digests = digests_cnt * dgst_size;
11801 uint size_shown = digests_cnt * sizeof (uint);
11802
11803 uint *digests_shown = (uint *) mymalloc (size_shown);
11804 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
11805
11806 uint salts_cnt = 0;
11807 uint salts_done = 0;
11808
11809 hashinfo_t **hash_info = NULL;
11810
11811 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11812 {
11813 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
11814
11815 if (username && (remove || show))
11816 {
11817 uint user_pos;
11818
11819 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
11820 {
11821 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
11822
11823 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
11824 }
11825 }
11826 }
11827
11828 uint *salts_shown = (uint *) mymalloc (size_shown);
11829
11830 salt_t *salt_buf;
11831
11832 {
11833 // copied from inner loop
11834
11835 salt_buf = &salts_buf_new[salts_cnt];
11836
11837 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
11838
11839 if (esalt_size)
11840 {
11841 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
11842 }
11843
11844 salt_buf->digests_cnt = 0;
11845 salt_buf->digests_done = 0;
11846 salt_buf->digests_offset = 0;
11847
11848 salts_cnt++;
11849 }
11850
11851 if (hashes_buf[0].cracked == 1)
11852 {
11853 digests_shown[0] = 1;
11854
11855 digests_done++;
11856
11857 salt_buf->digests_done++;
11858 }
11859
11860 salt_buf->digests_cnt++;
11861
11862 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
11863
11864 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11865 {
11866 hash_info[0] = hashes_buf[0].hash_info;
11867 }
11868
11869 // copy from inner loop
11870
11871 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
11872 {
11873 if (isSalted)
11874 {
11875 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
11876 {
11877 salt_buf = &salts_buf_new[salts_cnt];
11878
11879 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
11880
11881 if (esalt_size)
11882 {
11883 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
11884 }
11885
11886 salt_buf->digests_cnt = 0;
11887 salt_buf->digests_done = 0;
11888 salt_buf->digests_offset = hashes_pos;
11889
11890 salts_cnt++;
11891 }
11892 }
11893
11894 if (hashes_buf[hashes_pos].cracked == 1)
11895 {
11896 digests_shown[hashes_pos] = 1;
11897
11898 digests_done++;
11899
11900 salt_buf->digests_done++;
11901 }
11902
11903 salt_buf->digests_cnt++;
11904
11905 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
11906
11907 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11908 {
11909 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
11910 }
11911 }
11912
11913 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
11914 {
11915 salt_t *salt_buf = &salts_buf_new[salt_pos];
11916
11917 if (salt_buf->digests_done == salt_buf->digests_cnt)
11918 {
11919 salts_shown[salt_pos] = 1;
11920
11921 salts_done++;
11922 }
11923
11924 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
11925 }
11926
11927 local_free (digests_buf);
11928 local_free (salts_buf);
11929 local_free (esalts_buf);
11930
11931 digests_buf = digests_buf_new;
11932 salts_buf = salts_buf_new;
11933 esalts_buf = esalts_buf_new;
11934
11935 local_free (hashes_buf);
11936
11937 /**
11938 * special modification not set from parser
11939 */
11940
11941 switch (hash_mode)
11942 {
11943 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
11944 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
11945 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
11946 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
11947 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
11948 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
11949 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
11950 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
11951 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
11952 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
11953 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
11954 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
11955 }
11956
11957 if (truecrypt_keyfiles)
11958 {
11959 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
11960
11961 char *keyfiles = strdup (truecrypt_keyfiles);
11962
11963 char *keyfile = strtok (keyfiles, ",");
11964
11965 do
11966 {
11967 truecrypt_crc32 (keyfile, (unsigned char *) keyfile_buf);
11968
11969 } while ((keyfile = strtok (NULL, ",")) != NULL);
11970
11971 free (keyfiles);
11972 }
11973
11974 data.digests_cnt = digests_cnt;
11975 data.digests_done = digests_done;
11976 data.digests_buf = digests_buf;
11977 data.digests_shown = digests_shown;
11978 data.digests_shown_tmp = digests_shown_tmp;
11979
11980 data.salts_cnt = salts_cnt;
11981 data.salts_done = salts_done;
11982 data.salts_buf = salts_buf;
11983 data.salts_shown = salts_shown;
11984
11985 data.esalts_buf = esalts_buf;
11986 data.hash_info = hash_info;
11987
11988 /**
11989 * Automatic Optimizers
11990 */
11991
11992 if (salts_cnt == 1)
11993 opti_type |= OPTI_TYPE_SINGLE_SALT;
11994
11995 if (digests_cnt == 1)
11996 opti_type |= OPTI_TYPE_SINGLE_HASH;
11997
11998 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11999 opti_type |= OPTI_TYPE_NOT_ITERATED;
12000
12001 if (attack_mode == ATTACK_MODE_BF)
12002 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12003
12004 data.opti_type = opti_type;
12005
12006 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12007 {
12008 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12009 {
12010 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12011 {
12012 if (opts_type & OPTS_TYPE_ST_ADD80)
12013 {
12014 opts_type &= ~OPTS_TYPE_ST_ADD80;
12015 opts_type |= OPTS_TYPE_PT_ADD80;
12016 }
12017
12018 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12019 {
12020 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12021 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12022 }
12023
12024 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12025 {
12026 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12027 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12028 }
12029 }
12030 }
12031 }
12032
12033 /**
12034 * Some algorithm, like descrypt, can benefit from JIT compilation
12035 */
12036
12037 uint force_jit_compilation = 0;
12038
12039 if (hash_mode == 8900)
12040 {
12041 force_jit_compilation = 8900;
12042 }
12043 else if (hash_mode == 9300)
12044 {
12045 force_jit_compilation = 8900;
12046 }
12047 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12048 {
12049 force_jit_compilation = 1500;
12050 }
12051
12052 /**
12053 * generate bitmap tables
12054 */
12055
12056 const uint bitmap_shift1 = 5;
12057 const uint bitmap_shift2 = 13;
12058
12059 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12060
12061 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12062 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12063 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12064 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12065 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12066 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12067 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12068 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12069
12070 uint bitmap_bits;
12071 uint bitmap_nums;
12072 uint bitmap_mask;
12073 uint bitmap_size;
12074
12075 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12076 {
12077 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12078
12079 bitmap_nums = 1 << bitmap_bits;
12080
12081 bitmap_mask = bitmap_nums - 1;
12082
12083 bitmap_size = bitmap_nums * sizeof (uint);
12084
12085 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12086
12087 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;
12088 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;
12089
12090 break;
12091 }
12092
12093 bitmap_nums = 1 << bitmap_bits;
12094
12095 bitmap_mask = bitmap_nums - 1;
12096
12097 bitmap_size = bitmap_nums * sizeof (uint);
12098
12099 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);
12100 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);
12101
12102 /**
12103 * prepare quick rule
12104 */
12105
12106 data.rule_buf_l = rule_buf_l;
12107 data.rule_buf_r = rule_buf_r;
12108
12109 int rule_len_l = (int) strlen (rule_buf_l);
12110 int rule_len_r = (int) strlen (rule_buf_r);
12111
12112 data.rule_len_l = rule_len_l;
12113 data.rule_len_r = rule_len_r;
12114
12115 /**
12116 * load rules
12117 */
12118
12119 uint *all_kernel_rules_cnt = NULL;
12120
12121 kernel_rule_t **all_kernel_rules_buf = NULL;
12122
12123 if (rp_files_cnt)
12124 {
12125 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12126
12127 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12128 }
12129
12130 char rule_buf[BUFSIZ];
12131
12132 int rule_len = 0;
12133
12134 for (uint i = 0; i < rp_files_cnt; i++)
12135 {
12136 uint kernel_rules_avail = 0;
12137
12138 uint kernel_rules_cnt = 0;
12139
12140 kernel_rule_t *kernel_rules_buf = NULL;
12141
12142 char *rp_file = rp_files[i];
12143
12144 char in[BLOCK_SIZE];
12145 char out[BLOCK_SIZE];
12146
12147 FILE *fp = NULL;
12148
12149 uint rule_line = 0;
12150
12151 if ((fp = fopen (rp_file, "rb")) == NULL)
12152 {
12153 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12154
12155 return (-1);
12156 }
12157
12158 while (!feof (fp))
12159 {
12160 memset (rule_buf, 0, BUFSIZ);
12161
12162 rule_len = fgetl (fp, rule_buf);
12163
12164 rule_line++;
12165
12166 if (rule_len == 0) continue;
12167
12168 if (rule_buf[0] == '#') continue;
12169
12170 if (kernel_rules_avail == kernel_rules_cnt)
12171 {
12172 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12173
12174 kernel_rules_avail += INCR_RULES;
12175 }
12176
12177 memset (in, 0, BLOCK_SIZE);
12178 memset (out, 0, BLOCK_SIZE);
12179
12180 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12181
12182 if (result == -1)
12183 {
12184 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12185
12186 continue;
12187 }
12188
12189 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12190 {
12191 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12192
12193 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12194
12195 continue;
12196 }
12197
12198 /* its so slow
12199 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12200 {
12201 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12202
12203 continue;
12204 }
12205 */
12206
12207 kernel_rules_cnt++;
12208 }
12209
12210 fclose (fp);
12211
12212 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12213
12214 all_kernel_rules_buf[i] = kernel_rules_buf;
12215 }
12216
12217 /**
12218 * merge rules or automatic rule generator
12219 */
12220
12221 uint kernel_rules_cnt = 0;
12222
12223 kernel_rule_t *kernel_rules_buf = NULL;
12224
12225 if (attack_mode == ATTACK_MODE_STRAIGHT)
12226 {
12227 if (rp_files_cnt)
12228 {
12229 kernel_rules_cnt = 1;
12230
12231 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12232
12233 repeats[0] = kernel_rules_cnt;
12234
12235 for (uint i = 0; i < rp_files_cnt; i++)
12236 {
12237 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12238
12239 repeats[i + 1] = kernel_rules_cnt;
12240 }
12241
12242 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12243
12244 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12245
12246 for (uint i = 0; i < kernel_rules_cnt; i++)
12247 {
12248 uint out_pos = 0;
12249
12250 kernel_rule_t *out = &kernel_rules_buf[i];
12251
12252 for (uint j = 0; j < rp_files_cnt; j++)
12253 {
12254 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12255 uint in_pos;
12256
12257 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12258
12259 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12260 {
12261 if (out_pos == RULES_MAX - 1)
12262 {
12263 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12264
12265 break;
12266 }
12267
12268 out->cmds[out_pos] = in->cmds[in_pos];
12269 }
12270 }
12271 }
12272
12273 local_free (repeats);
12274 }
12275 else if (rp_gen)
12276 {
12277 uint kernel_rules_avail = 0;
12278
12279 while (kernel_rules_cnt < rp_gen)
12280 {
12281 if (kernel_rules_avail == kernel_rules_cnt)
12282 {
12283 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12284
12285 kernel_rules_avail += INCR_RULES;
12286 }
12287
12288 memset (rule_buf, 0, BLOCK_SIZE);
12289
12290 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12291
12292 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12293
12294 kernel_rules_cnt++;
12295 }
12296 }
12297 }
12298
12299 /**
12300 * generate NOP rules
12301 */
12302
12303 if (kernel_rules_cnt == 0)
12304 {
12305 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12306
12307 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12308
12309 kernel_rules_cnt++;
12310 }
12311
12312 data.kernel_rules_cnt = kernel_rules_cnt;
12313 data.kernel_rules_buf = kernel_rules_buf;
12314
12315 /**
12316 * platform
12317 */
12318
12319 cl_platform_id CL_platforms[CL_PLATFORMS_MAX];
12320
12321 uint CL_platforms_cnt = 0;
12322
12323 hc_clGetPlatformIDs (CL_PLATFORMS_MAX, CL_platforms, &CL_platforms_cnt);
12324
12325 if (CL_platforms_cnt == 0)
12326 {
12327 log_error ("ERROR: No OpenCL compatible platform found");
12328
12329 return (-1);
12330 }
12331
12332 int CL_platform_sel = 1;
12333
12334 if (opencl_platform != NULL)
12335 {
12336 CL_platform_sel = atoi (opencl_platform);
12337 }
12338
12339 if (CL_platforms_cnt > 1)
12340 {
12341 if (opencl_platform == NULL)
12342 {
12343 log_error ("ERROR: Too many OpenCL compatible platforms found");
12344
12345 log_info ("Please select a single platform using the --opencl-platform option");
12346 log_info ("");
12347 log_info ("Available OpenCL platforms:");
12348 log_info ("");
12349
12350 for (uint i = 0; i < CL_platforms_cnt; i++)
12351 {
12352 char CL_platform_vendor[INFOSZ];
12353
12354 memset (CL_platform_vendor, 0, sizeof (CL_platform_vendor));
12355
12356 hc_clGetPlatformInfo (CL_platforms[i], CL_PLATFORM_VENDOR, sizeof (CL_platform_vendor), CL_platform_vendor, NULL);
12357
12358 log_info ("* %d = %s", i + 1, CL_platform_vendor);
12359 }
12360
12361 log_info ("");
12362
12363 return (-1);
12364 }
12365 else
12366 {
12367 if (CL_platform_sel < 1)
12368 {
12369 log_error ("ERROR: --opencl-platform < 1");
12370
12371 return (-1);
12372 }
12373
12374 if (CL_platform_sel > (int) CL_platforms_cnt)
12375 {
12376 log_error ("ERROR: invalid OpenCL platforms selected");
12377
12378 return (-1);
12379 }
12380 }
12381 }
12382 else
12383 {
12384 if (CL_platform_sel != 1)
12385 {
12386 log_error ("ERROR: OpenCL platform number %d is not available", CL_platform_sel);
12387
12388 return (-1);
12389 }
12390 }
12391
12392 // zero-indexed: not starting to count at 1, as user does
12393
12394 CL_platform_sel -= 1;
12395
12396
12397 cl_platform_id CL_platform = CL_platforms[CL_platform_sel];
12398
12399 char CL_platform_vendor[INFOSZ];
12400
12401 memset (CL_platform_vendor, 0, sizeof (CL_platform_vendor));
12402
12403 hc_clGetPlatformInfo (CL_platform, CL_PLATFORM_VENDOR, sizeof (CL_platform_vendor), CL_platform_vendor, NULL);
12404
12405 cl_device_type device_type_filter;
12406
12407 uint vendor_id;
12408
12409 if (strcmp (CL_platform_vendor, CL_VENDOR_AMD) == 0)
12410 {
12411 vendor_id = VENDOR_ID_AMD;
12412
12413 device_type_filter = CL_DEVICE_TYPE_GPU;
12414 }
12415 else if (strcmp (CL_platform_vendor, CL_VENDOR_NV) == 0)
12416 {
12417 vendor_id = VENDOR_ID_NV;
12418
12419 device_type_filter = CL_DEVICE_TYPE_GPU;
12420
12421 // make sure that we do not directly control the fan for NVidia
12422
12423 gpu_temp_retain = 0;
12424
12425 data.gpu_temp_retain = gpu_temp_retain;
12426 }
12427 else if (strcmp (CL_platform_vendor, CL_VENDOR_POCL) == 0)
12428 {
12429 if (force == 0)
12430 {
12431 log_error ("");
12432 log_error ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12433 log_error ("You are STRONGLY encouraged not to use it");
12434 log_error ("You can use --force to override this but do not post error reports if you do so");
12435
12436 return (-1);
12437 }
12438
12439 vendor_id = VENDOR_ID_GENERIC;
12440
12441 device_type_filter = CL_DEVICE_TYPE_DEFAULT;
12442 }
12443 else
12444 {
12445 vendor_id = VENDOR_ID_GENERIC;
12446
12447 device_type_filter = CL_DEVICE_TYPE_DEFAULT;
12448 }
12449
12450 if (vendor_id == VENDOR_ID_GENERIC)
12451 {
12452 log_error ("Warning: unknown OpenCL vendor '%s' detected", CL_platform_vendor);
12453
12454 gpu_temp_disable = 1;
12455 }
12456
12457 data.vendor_id = vendor_id;
12458
12459 /**
12460 * cached kernel path depends on vendor_id which we don't know, so create it here
12461 */
12462
12463 int vendor_id_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 10 + 1;
12464
12465 char *vendor_id_folder = (char *) mymalloc (vendor_id_folder_size);
12466
12467 snprintf (vendor_id_folder, vendor_id_folder_size - 1, "%s/kernels", profile_dir);
12468
12469 mkdir (vendor_id_folder, 0700);
12470
12471 snprintf (vendor_id_folder, vendor_id_folder_size - 1, "%s/kernels/%d", profile_dir, vendor_id);
12472
12473 mkdir (vendor_id_folder, 0700);
12474
12475 myfree (vendor_id_folder);
12476
12477 /**
12478 * devices
12479 */
12480
12481 cl_device_id devices_all[DEVICES_MAX];
12482 cl_device_id devices[DEVICES_MAX];
12483
12484 uint devices_all_cnt = 0;
12485
12486 hc_clGetDeviceIDs (CL_platform, device_type_filter, DEVICES_MAX, devices_all, (uint *) &devices_all_cnt);
12487
12488 int hm_adapters_all = devices_all_cnt;
12489
12490 hm_attrs_t hm_adapter_all[DEVICES_MAX];
12491
12492 memset (hm_adapter_all, 0, sizeof (hm_adapter_all));
12493
12494 if (gpu_temp_disable == 0)
12495 {
12496 if (vendor_id == VENDOR_ID_NV)
12497 {
12498 #ifdef LINUX
12499 HM_LIB hm_dll = hm_init ();
12500
12501 data.hm_dll = hm_dll;
12502
12503 if (hc_NVML_nvmlInit (hm_dll) == NVML_SUCCESS)
12504 {
12505 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX];
12506
12507 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12508
12509 int tmp_out = 0;
12510
12511 for (int i = 0; i < tmp_in; i++)
12512 {
12513 hm_adapter_all[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12514 }
12515
12516 hm_adapters_all = tmp_out;
12517
12518 for (int i = 0; i < tmp_out; i++)
12519 {
12520 unsigned int speed;
12521
12522 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;
12523 }
12524 }
12525 #endif
12526
12527 #ifdef WIN
12528 if (NvAPI_Initialize () == NVAPI_OK)
12529 {
12530 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX];
12531
12532 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12533
12534 int tmp_out = 0;
12535
12536 for (int i = 0; i < tmp_in; i++)
12537 {
12538 hm_adapter_all[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12539 }
12540
12541 hm_adapters_all = tmp_out;
12542
12543 for (int i = 0; i < tmp_out; i++)
12544 {
12545 NvU32 speed;
12546
12547 if (NvAPI_GPU_GetTachReading (hm_adapter_all[i].adapter_index.nv, &speed) != NVAPI_NOT_SUPPORTED) hm_adapter_all[i].fan_supported = 1;
12548 }
12549 }
12550 #endif
12551 }
12552
12553 if (vendor_id == VENDOR_ID_AMD)
12554 {
12555 HM_LIB hm_dll = hm_init ();
12556
12557 data.hm_dll = hm_dll;
12558
12559 if (hc_ADL_Main_Control_Create (hm_dll, ADL_Main_Memory_Alloc, 0) == ADL_OK)
12560 {
12561 // total number of adapters
12562
12563 int hm_adapters_num;
12564
12565 if (get_adapters_num_amd (hm_dll, &hm_adapters_num) != 0) return (-1);
12566
12567 // adapter info
12568
12569 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (hm_dll, hm_adapters_num);
12570
12571 if (lpAdapterInfo == NULL) return (-1);
12572
12573 // get a list (of ids of) valid/usable adapters
12574
12575 int num_adl_adapters = 0;
12576
12577 uint32_t *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
12578
12579 if (num_adl_adapters > 0)
12580 {
12581 hc_thread_mutex_lock (mux_adl);
12582
12583 // hm_get_opencl_busid_devid (hm_adapter_all, devices_all_cnt, devices_all);
12584
12585 hm_get_adapter_index_amd (hm_adapter_all, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12586
12587 hm_get_overdrive_version (hm_dll, hm_adapter_all, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12588 hm_check_fanspeed_control (hm_dll, hm_adapter_all, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12589
12590 hc_thread_mutex_unlock (mux_adl);
12591 }
12592
12593 hm_adapters_all = num_adl_adapters;
12594
12595 myfree (valid_adl_device_list);
12596 myfree (lpAdapterInfo);
12597 }
12598 }
12599 }
12600
12601 if (hm_adapters_all == 0)
12602 {
12603 gpu_temp_disable = 1;
12604 }
12605
12606 if (gpu_temp_disable == 1)
12607 {
12608 gpu_temp_abort = 0;
12609 gpu_temp_retain = 0;
12610 }
12611
12612 /**
12613 * enable custom signal handler(s)
12614 */
12615
12616 if (benchmark == 0)
12617 {
12618 hc_signal (sigHandler_default);
12619 }
12620 else
12621 {
12622 hc_signal (sigHandler_benchmark);
12623 }
12624
12625 /**
12626 * devices mask and properties
12627 */
12628
12629 uint devices_cnt = 0;
12630
12631 for (uint device_all_id = 0; device_all_id < devices_all_cnt; device_all_id++)
12632 {
12633 if (opencl_devicemask)
12634 {
12635 uint device_all_id_mask = 1 << device_all_id;
12636
12637 if ((device_all_id_mask & opencl_devicemask) != device_all_id_mask)
12638 {
12639 if (quiet == 0 && algorithm_pos == 0) log_info ("Device #%d: skipped by user", device_all_id_mask + 1);
12640
12641 continue;
12642 }
12643 }
12644
12645 const uint device_id = devices_cnt;
12646
12647 devices[device_id] = devices_all[device_all_id];
12648
12649 char device_name[INFOSZ];
12650
12651 memset (device_name, 0, sizeof (device_name));
12652
12653 cl_ulong global_mem_size;
12654 cl_ulong max_mem_alloc_size;
12655 cl_uint max_clock_frequency;
12656 cl_uint max_compute_units;
12657 cl_device_type device_type;
12658
12659 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_NAME, sizeof (device_name), &device_name, NULL);
12660 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (global_mem_size), &global_mem_size, NULL);
12661 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (max_mem_alloc_size), &max_mem_alloc_size, NULL);
12662 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (max_clock_frequency), &max_clock_frequency, NULL);
12663 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (max_compute_units), &max_compute_units, NULL);
12664 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12665
12666 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12667 {
12668 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12669 device_all_id + 1,
12670 device_name,
12671 (unsigned int) (max_mem_alloc_size / 1024 / 1024),
12672 (unsigned int) (global_mem_size / 1024 / 1024),
12673 (unsigned int) (max_clock_frequency),
12674 (unsigned int) max_compute_units);
12675 }
12676
12677 // do something with device_type
12678
12679 memcpy (&data.hm_device[device_id], &hm_adapter_all[device_all_id], sizeof (hm_attrs_t));
12680
12681 devices_cnt++;
12682 }
12683
12684 if (devices_cnt == 0)
12685 {
12686 log_error ("ERROR: No devices left that matches your specification.");
12687
12688 return (-1);
12689 }
12690
12691 data.devices_cnt = devices_cnt;
12692
12693 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12694 {
12695 log_info ("");
12696 }
12697
12698 /**
12699 * inform the user
12700 */
12701
12702 // gpu temp sanity check
12703
12704 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
12705 {
12706 if (gpu_temp_abort < gpu_temp_retain)
12707 {
12708 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
12709
12710 return (-1);
12711 }
12712 }
12713
12714 data.gpu_temp_disable = gpu_temp_disable;
12715 data.gpu_temp_abort = gpu_temp_abort;
12716 data.gpu_temp_retain = gpu_temp_retain;
12717
12718 if (data.quiet == 0)
12719 {
12720 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
12721
12722 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);
12723
12724 if (attack_mode == ATTACK_MODE_STRAIGHT)
12725 {
12726 log_info ("Rules: %u", kernel_rules_cnt);
12727 }
12728
12729 if (opti_type)
12730 {
12731 log_info ("Applicable Optimizers:");
12732
12733 for (uint i = 0; i < 32; i++)
12734 {
12735 const uint opti_bit = 1 << i;
12736
12737 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
12738 }
12739 }
12740
12741 /**
12742 * Watchdog and Temperature balance
12743 */
12744
12745 if (gpu_temp_abort == 0)
12746 {
12747 log_info ("Watchdog: Temperature abort trigger disabled");
12748 }
12749 else
12750 {
12751 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
12752 }
12753
12754 if (gpu_temp_retain == 0)
12755 {
12756 log_info ("Watchdog: Temperature retain trigger disabled");
12757 }
12758 else
12759 {
12760 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
12761 }
12762 }
12763
12764 /**
12765 * devices init
12766 */
12767
12768 int *temp_retain_fanspeed_value = (int *) mycalloc (devices_cnt, sizeof (int));
12769
12770 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (devices_cnt, sizeof (ADLOD6MemClockState));
12771
12772 int *od_power_control_status = (int *) mycalloc (devices_cnt, sizeof (int));
12773
12774 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (devices_cnt, sizeof (hc_device_param_t));
12775
12776 data.devices_param = devices_param;
12777
12778 for (uint device_id = 0; device_id < devices_cnt; device_id++)
12779 {
12780 hc_device_param_t *device_param = &data.devices_param[device_id];
12781
12782 cl_device_id device = devices[device_id];
12783
12784 device_param->device = device;
12785
12786 cl_device_type device_type = 0;
12787
12788 hc_clGetDeviceInfo (device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12789
12790 device_param->device_type = device_type;
12791
12792 cl_uint max_compute_units = 0;
12793
12794 hc_clGetDeviceInfo (device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (max_compute_units), &max_compute_units, NULL);
12795
12796 device_param->device_processors = max_compute_units;
12797
12798 cl_ulong max_mem_alloc_size = 0;
12799
12800 hc_clGetDeviceInfo (device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (max_mem_alloc_size), &max_mem_alloc_size, NULL);
12801
12802 device_param->device_maxmem_alloc = max_mem_alloc_size;
12803
12804 char tmp[INFOSZ], t1[64];
12805
12806 memset (tmp, 0, sizeof (tmp));
12807
12808 hc_clGetDeviceInfo (device, CL_DEVICE_NAME, sizeof (tmp), &tmp, NULL);
12809
12810 device_param->device_name = mystrdup (tmp);
12811
12812 memset (tmp, 0, sizeof (tmp));
12813
12814 hc_clGetDeviceInfo (device, CL_DEVICE_VERSION, sizeof (tmp), &tmp, NULL);
12815
12816 memset (t1, 0, sizeof (t1));
12817
12818 sscanf (tmp, "%*16s %*16s %*16s (%[^)]16s)", t1);
12819
12820 device_param->device_version = mystrdup (t1);
12821
12822 memset (tmp, 0, sizeof (tmp));
12823
12824 hc_clGetDeviceInfo (device, CL_DRIVER_VERSION, sizeof (tmp), &tmp, NULL);
12825
12826 device_param->driver_version = mystrdup (tmp);
12827
12828 // create some filename that is easier to read on cached folder
12829
12830 snprintf (tmp, sizeof (tmp) - 1, "%s-%s-%s-%d", device_param->device_name, device_param->device_version, device_param->driver_version, COMPTIME);
12831
12832 uint device_name_digest[4];
12833
12834 device_name_digest[0] = 0;
12835 device_name_digest[1] = 0;
12836 device_name_digest[2] = 0;
12837 device_name_digest[3] = 0;
12838
12839 md5_64 ((uint *) tmp, device_name_digest);
12840
12841 sprintf (tmp, "%08x", device_name_digest[0]);
12842
12843 device_param->device_name_chksum = mystrdup (tmp);
12844
12845 if (device_type & CL_DEVICE_TYPE_CPU)
12846 {
12847 cl_uint device_processor_cores = 1;
12848
12849 device_param->device_processor_cores = device_processor_cores;
12850 }
12851
12852 if (device_type & CL_DEVICE_TYPE_GPU)
12853 {
12854 if (vendor_id == VENDOR_ID_AMD)
12855 {
12856 cl_uint device_processor_cores = 0;
12857
12858 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12859
12860 hc_clGetDeviceInfo (device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12861
12862 device_param->device_processor_cores = device_processor_cores;
12863 }
12864
12865 if (vendor_id == VENDOR_ID_NV)
12866 {
12867 cl_uint kernel_exec_timeout = 0;
12868
12869 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12870
12871 hc_clGetDeviceInfo (device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12872
12873 device_param->kernel_exec_timeout = kernel_exec_timeout;
12874
12875 cl_uint device_processor_cores = 0;
12876
12877 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12878
12879 hc_clGetDeviceInfo (device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12880
12881 device_param->device_processor_cores = device_processor_cores;
12882
12883 cl_uint sm_minor = 0;
12884 cl_uint sm_major = 0;
12885
12886 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12887 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12888
12889 hc_clGetDeviceInfo (device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12890 hc_clGetDeviceInfo (device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12891
12892 device_param->sm_minor = sm_minor;
12893 device_param->sm_major = sm_major;
12894 }
12895 }
12896
12897 /**
12898 * common driver check
12899 */
12900
12901 if (device_type & CL_DEVICE_TYPE_GPU)
12902 {
12903 if (vendor_id == VENDOR_ID_NV)
12904 {
12905 if (device_param->kernel_exec_timeout != 0)
12906 {
12907 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);
12908 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12909 }
12910 }
12911
12912 if (vendor_id == VENDOR_ID_AMD)
12913 {
12914 int catalyst_check = (force == 1) ? 0 : 1;
12915
12916 int catalyst_warn = 0;
12917
12918 int catalyst_broken = 0;
12919
12920 if (catalyst_check == 1)
12921 {
12922 catalyst_warn = 1;
12923
12924 // v14.9 and higher
12925 if ((atoi (device_param->device_version) >= 1573)
12926 && (atoi (device_param->driver_version) >= 1573))
12927 {
12928 catalyst_warn = 0;
12929 }
12930
12931 catalyst_check = 0;
12932 }
12933
12934 if (catalyst_broken == 1)
12935 {
12936 log_error ("");
12937 log_error ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12938 log_error ("It will pass over cracked hashes and does not report them as cracked");
12939 log_error ("You are STRONGLY encouraged not to use it");
12940 log_error ("You can use --force to override this but do not post error reports if you do so");
12941
12942 return (-1);
12943 }
12944
12945 if (catalyst_warn == 1)
12946 {
12947 log_error ("");
12948 log_error ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12949 log_error ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12950 log_error ("See oclHashcat's homepage for official supported catalyst drivers");
12951 #ifdef _WIN
12952 log_error ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12953 #endif
12954 log_error ("You can use --force to override this but do not post error reports if you do so");
12955
12956 return (-1);
12957 }
12958 }
12959 }
12960 }
12961
12962 /*
12963 * Temporary fix:
12964 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
12965 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
12966 * were not working @ full speed (setting hc_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
12967 * Driver / ADL bug?
12968 */
12969
12970 if (vendor_id == VENDOR_ID_AMD)
12971 {
12972 if (powertune_enable == 1)
12973 {
12974 hc_thread_mutex_lock (mux_adl);
12975
12976 for (uint i = 0; i < devices_cnt; i++)
12977 {
12978 if (data.hm_device[i].od_version == 6)
12979 {
12980 // set powertune value only
12981
12982 int powertune_supported = 0;
12983
12984 int ADL_rc = 0;
12985
12986 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll, data.hm_device[i].adapter_index.amd, &powertune_supported)) != ADL_OK)
12987 {
12988 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
12989
12990 return (-1);
12991 }
12992
12993 if (powertune_supported != 0)
12994 {
12995 // powertune set
12996 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
12997
12998 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll, data.hm_device[i].adapter_index.amd, &powertune)) != ADL_OK)
12999 {
13000 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13001
13002 return (-1);
13003 }
13004
13005 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll, data.hm_device[i].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13006 {
13007 log_error ("ERROR: Failed to set new ADL PowerControl values");
13008
13009 return (-1);
13010 }
13011 }
13012 }
13013 }
13014
13015 hc_thread_mutex_unlock (mux_adl);
13016 }
13017 }
13018
13019 uint kernel_blocks_all = 0;
13020
13021 for (uint device_id = 0; device_id < devices_cnt; device_id++)
13022 {
13023 /**
13024 * host buffer
13025 */
13026
13027 hc_device_param_t *device_param = &data.devices_param[device_id];
13028
13029 /**
13030 * device properties
13031 */
13032
13033 char *device_name_chksum = device_param->device_name_chksum;
13034
13035 uint device_processors = device_param->device_processors;
13036
13037 uint device_processor_cores = device_param->device_processor_cores;
13038
13039 cl_device_type device_type = device_param->device_type;
13040
13041 /**
13042 * create context for each device
13043 */
13044
13045 device_param->context = hc_clCreateContext (NULL, 1, &device_param->device, NULL, NULL);
13046
13047 /**
13048 * create command-queue
13049 */
13050
13051 // not support with NV
13052 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13053
13054 device_param->command_queue = hc_clCreateCommandQueue (device_param->context, device_param->device, 0);
13055
13056 /**
13057 * create input buffers on device
13058 */
13059
13060 uint kernel_threads = KERNEL_THREADS;
13061
13062 // bcrypt
13063 if (hash_mode == 3200) kernel_threads = 8;
13064 if (hash_mode == 9000) kernel_threads = 8;
13065
13066 if (device_type & CL_DEVICE_TYPE_CPU)
13067 {
13068 // CPU still need lots of workitems, don't know why...
13069 // for testing phase, lets start with this
13070
13071 kernel_accel = 1;
13072 }
13073
13074 uint kernel_power = device_processors * kernel_threads * kernel_accel;
13075 uint kernel_blocks = kernel_power;
13076
13077 device_param->kernel_threads = kernel_threads;
13078 device_param->kernel_power_user = kernel_power;
13079 device_param->kernel_blocks_user = kernel_blocks;
13080
13081 kernel_blocks_all += kernel_blocks;
13082
13083 uint size_pws = kernel_power * sizeof (pw_t);
13084
13085 uint size_tmps = 4;
13086
13087 switch (hash_mode)
13088 {
13089 case 400: size_tmps = kernel_blocks * sizeof (phpass_tmp_t); break;
13090 case 500: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13091 case 501: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13092 case 1600: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13093 case 1800: size_tmps = kernel_blocks * sizeof (sha512crypt_tmp_t); break;
13094 case 2100: size_tmps = kernel_blocks * sizeof (dcc2_tmp_t); break;
13095 case 2500: size_tmps = kernel_blocks * sizeof (wpa_tmp_t); break;
13096 case 3200: size_tmps = kernel_blocks * sizeof (bcrypt_tmp_t); break;
13097 case 5200: size_tmps = kernel_blocks * sizeof (pwsafe3_tmp_t); break;
13098 case 5800: size_tmps = kernel_blocks * sizeof (androidpin_tmp_t); break;
13099 case 6211:
13100 case 6212:
13101 case 6213: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13102 case 6221:
13103 case 6222:
13104 case 6223: size_tmps = kernel_blocks * sizeof (tc64_tmp_t); break;
13105 case 6231:
13106 case 6232:
13107 case 6233: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13108 case 6241:
13109 case 6242:
13110 case 6243: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13111 case 6300: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13112 case 6400: size_tmps = kernel_blocks * sizeof (sha256aix_tmp_t); break;
13113 case 6500: size_tmps = kernel_blocks * sizeof (sha512aix_tmp_t); break;
13114 case 6600: size_tmps = kernel_blocks * sizeof (agilekey_tmp_t); break;
13115 case 6700: size_tmps = kernel_blocks * sizeof (sha1aix_tmp_t); break;
13116 case 6800: size_tmps = kernel_blocks * sizeof (lastpass_tmp_t); break;
13117 case 7100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13118 case 7200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13119 case 7400: size_tmps = kernel_blocks * sizeof (sha256crypt_tmp_t); break;
13120 case 7900: size_tmps = kernel_blocks * sizeof (drupal7_tmp_t); break;
13121 case 8200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13122 case 8800: size_tmps = kernel_blocks * sizeof (androidfde_tmp_t); break;
13123 case 8900: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13124 case 9000: size_tmps = kernel_blocks * sizeof (pwsafe2_tmp_t); break;
13125 case 9100: size_tmps = kernel_blocks * sizeof (lotus8_tmp_t); break;
13126 case 9200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13127 case 9300: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13128 case 9400: size_tmps = kernel_blocks * sizeof (office2007_tmp_t); break;
13129 case 9500: size_tmps = kernel_blocks * sizeof (office2010_tmp_t); break;
13130 case 9600: size_tmps = kernel_blocks * sizeof (office2013_tmp_t); break;
13131 case 10000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13132 case 10200: size_tmps = kernel_blocks * sizeof (cram_md5_t); break;
13133 case 10300: size_tmps = kernel_blocks * sizeof (saph_sha1_tmp_t); break;
13134 case 10500: size_tmps = kernel_blocks * sizeof (pdf14_tmp_t); break;
13135 case 10700: size_tmps = kernel_blocks * sizeof (pdf17l8_tmp_t); break;
13136 case 10900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13137 case 11300: size_tmps = kernel_blocks * sizeof (bitcoin_wallet_tmp_t); break;
13138 case 11600: size_tmps = kernel_blocks * sizeof (seven_zip_tmp_t); break;
13139 case 11900: size_tmps = kernel_blocks * sizeof (pbkdf2_md5_tmp_t); break;
13140 case 12000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha1_tmp_t); break;
13141 case 12100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13142 case 12200: size_tmps = kernel_blocks * sizeof (ecryptfs_tmp_t); break;
13143 case 12300: size_tmps = kernel_blocks * sizeof (oraclet_tmp_t); break;
13144 case 12400: size_tmps = kernel_blocks * sizeof (bsdicrypt_tmp_t); break;
13145 case 12500: size_tmps = kernel_blocks * sizeof (rar3_tmp_t); break;
13146 case 12700: size_tmps = kernel_blocks * sizeof (mywallet_tmp_t); break;
13147 case 12800: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13148 case 12900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13149 case 13000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13150 };
13151
13152 uint size_hooks = 4;
13153
13154 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13155 {
13156 // insert correct hook size
13157 }
13158
13159 // we can optimize some stuff here...
13160
13161 device_param->size_pws = size_pws;
13162 device_param->size_tmps = size_tmps;
13163 device_param->size_hooks = size_hooks;
13164
13165 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13166 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13167
13168 device_param->size_root_css = size_root_css;
13169 device_param->size_markov_css = size_markov_css;
13170
13171 uint size_results = KERNEL_THREADS * sizeof (uint);
13172
13173 device_param->size_results = size_results;
13174
13175 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13176 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13177
13178 uint size_plains = digests_cnt * sizeof (plain_t);
13179 uint size_salts = salts_cnt * sizeof (salt_t);
13180 uint size_esalts = salts_cnt * esalt_size;
13181
13182 device_param->size_plains = size_plains;
13183 device_param->size_digests = size_digests;
13184 device_param->size_shown = size_shown;
13185 device_param->size_salts = size_salts;
13186
13187 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13188 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13189 uint size_tm = 32 * sizeof (bs_word_t);
13190
13191 uint64_t size_scryptV = 1;
13192
13193 if ((hash_mode == 8900) || (hash_mode == 9300))
13194 {
13195 uint tmto_start = 0;
13196 uint tmto_stop = 10;
13197
13198 if (scrypt_tmto)
13199 {
13200 tmto_start = scrypt_tmto;
13201 }
13202 else
13203 {
13204 // in case the user did not specify the tmto manually
13205 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13206 // but set the lower end only in case the user has a device with too less memory
13207
13208 if (hash_mode == 8900)
13209 {
13210 if (vendor_id == VENDOR_ID_AMD)
13211 {
13212 tmto_start = 1;
13213 }
13214 else if (vendor_id == VENDOR_ID_NV)
13215 {
13216 tmto_start = 3;
13217 }
13218 }
13219 else if (hash_mode == 9300)
13220 {
13221 if (vendor_id == VENDOR_ID_AMD)
13222 {
13223 tmto_start = 3;
13224 }
13225 else if (vendor_id == VENDOR_ID_NV)
13226 {
13227 tmto_start = 5;
13228 }
13229 }
13230 }
13231
13232 if (quiet == 0) log_info ("");
13233
13234 uint shader_per_mp = 1;
13235
13236 if (vendor_id == VENDOR_ID_AMD)
13237 {
13238 shader_per_mp = 8;
13239 }
13240
13241 if (vendor_id == VENDOR_ID_NV)
13242 {
13243 shader_per_mp = 32;
13244 }
13245
13246 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13247 {
13248 // TODO: in theory the following calculation needs to be done per salt, not global
13249 // we assume all hashes have the same scrypt settings
13250
13251 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13252
13253 size_scryptV /= 1 << tmto;
13254
13255 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13256
13257 if (size_scryptV > device_param->device_maxmem_alloc)
13258 {
13259 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13260
13261 continue;
13262 }
13263
13264 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13265 {
13266 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13267 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13268 }
13269
13270 break;
13271 }
13272
13273 if (data.salts_buf[0].scrypt_phy == 0)
13274 {
13275 log_error ("ERROR: can't allocate enough device memory");
13276
13277 return -1;
13278 }
13279
13280 if (quiet == 0) log_info ("");
13281 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13282 }
13283
13284 /**
13285 * default building options
13286 */
13287
13288 char build_opts[1024];
13289
13290 // we don't have sm_* on AMD but it doesn't matter
13291
13292 sprintf (build_opts, "-I%s/ -DVENDOR_ID=%d -DCUDA_ARCH=%d", shared_dir, vendor_id, (device_param->sm_major * 100) + device_param->sm_minor);
13293
13294 /**
13295 * a0 kernel, required for some fast hashes to make weak_hash_check work
13296 */
13297
13298 const uint add_flag = OPTS_TYPE_PT_ADD01
13299 | OPTS_TYPE_PT_ADD02
13300 | OPTS_TYPE_PT_ADD80
13301 | OPTS_TYPE_PT_ADDBITS14
13302 | OPTS_TYPE_PT_ADDBITS15
13303 | OPTS_TYPE_ST_ADD01
13304 | OPTS_TYPE_ST_ADD02
13305 | OPTS_TYPE_ST_ADD80
13306 | OPTS_TYPE_ST_ADDBITS14
13307 | OPTS_TYPE_ST_ADDBITS15;
13308
13309 if ((weak_hash_threshold) && (attack_exec == ATTACK_EXEC_INSIDE_KERNEL) && (opts_type & add_flag))
13310 {
13311 /**
13312 * kernel source filename
13313 */
13314
13315 char source_file[256];
13316
13317 memset (source_file, 0, sizeof (source_file));
13318
13319 generate_source_kernel_filename (attack_exec, ATTACK_KERN_STRAIGHT, kern_type, shared_dir, source_file);
13320
13321 struct stat sst;
13322
13323 if (stat (source_file, &sst) == -1)
13324 {
13325 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13326
13327 return -1;
13328 }
13329
13330 /**
13331 * kernel cached filename
13332 */
13333
13334 char cached_file[256];
13335
13336 memset (cached_file, 0, sizeof (cached_file));
13337
13338 generate_cached_kernel_filename (attack_exec, ATTACK_KERN_STRAIGHT, kern_type, profile_dir, device_name_chksum, vendor_id, cached_file);
13339
13340 int cached = 1;
13341
13342 struct stat cst;
13343
13344 if (stat (cached_file, &cst) == -1)
13345 {
13346 cached = 0;
13347 }
13348
13349 /**
13350 * kernel compile or load
13351 */
13352
13353 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13354
13355 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13356
13357 if (force_jit_compilation == 0)
13358 {
13359 if (cached == 0)
13360 {
13361 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13362
13363 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13364
13365 device_param->program_weak = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13366
13367 hc_clBuildProgram (device_param->program_weak, 1, &device_param->device, build_opts, NULL, NULL);
13368
13369 size_t binary_size;
13370
13371 clGetProgramInfo (device_param->program_weak, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13372
13373 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13374
13375 clGetProgramInfo (device_param->program_weak, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13376
13377 writeProgramBin (cached_file, binary, binary_size);
13378
13379 local_free (binary);
13380 }
13381 else
13382 {
13383 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13384
13385 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13386
13387 device_param->program_weak = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13388
13389 hc_clBuildProgram (device_param->program_weak, 1, &device_param->device, build_opts, NULL, NULL);
13390 }
13391 }
13392 else
13393 {
13394 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13395
13396 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13397
13398 device_param->program_weak = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13399
13400 if (force_jit_compilation == 1500)
13401 {
13402 sprintf (build_opts, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13403 }
13404 else if (force_jit_compilation == 8900)
13405 {
13406 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);
13407 }
13408
13409 hc_clBuildProgram (device_param->program_weak, 1, &device_param->device, build_opts, NULL, NULL);
13410 }
13411
13412 local_free (kernel_lengths);
13413 local_free (kernel_sources[0]);
13414 local_free (kernel_sources);
13415
13416 // this is mostly for debug
13417
13418 size_t ret_val_size = 0;
13419
13420 clGetProgramBuildInfo (device_param->program_weak, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13421
13422 if (ret_val_size > 2)
13423 {
13424 char *build_log = (char *) mymalloc (ret_val_size + 1);
13425
13426 memset (build_log, 0, ret_val_size + 1);
13427
13428 clGetProgramBuildInfo (device_param->program_weak, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13429
13430 puts (build_log);
13431
13432 myfree (build_log);
13433 }
13434 }
13435
13436 /**
13437 * main kernel
13438 */
13439
13440 {
13441 /**
13442 * kernel source filename
13443 */
13444
13445 char source_file[256];
13446
13447 memset (source_file, 0, sizeof (source_file));
13448
13449 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13450
13451 struct stat sst;
13452
13453 if (stat (source_file, &sst) == -1)
13454 {
13455 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13456
13457 return -1;
13458 }
13459
13460 /**
13461 * kernel cached filename
13462 */
13463
13464 char cached_file[256];
13465
13466 memset (cached_file, 0, sizeof (cached_file));
13467
13468 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, vendor_id, cached_file);
13469
13470 int cached = 1;
13471
13472 struct stat cst;
13473
13474 if (stat (cached_file, &cst) == -1)
13475 {
13476 cached = 0;
13477 }
13478
13479 /**
13480 * kernel compile or load
13481 */
13482
13483 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13484
13485 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13486
13487 if (force_jit_compilation == 0)
13488 {
13489 if (cached == 0)
13490 {
13491 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13492
13493 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13494
13495 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13496
13497 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13498
13499 size_t binary_size;
13500
13501 clGetProgramInfo (device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13502
13503 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13504
13505 clGetProgramInfo (device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13506
13507 writeProgramBin (cached_file, binary, binary_size);
13508
13509 local_free (binary);
13510 }
13511 else
13512 {
13513 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13514
13515 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13516
13517 device_param->program = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13518
13519 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13520 }
13521 }
13522 else
13523 {
13524 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13525
13526 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13527
13528 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13529
13530 if (force_jit_compilation == 1500)
13531 {
13532 sprintf (build_opts, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13533 }
13534 else if (force_jit_compilation == 8900)
13535 {
13536 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);
13537 }
13538
13539 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13540 }
13541
13542 local_free (kernel_lengths);
13543 local_free (kernel_sources[0]);
13544 local_free (kernel_sources);
13545
13546 // this is mostly for debug
13547
13548 size_t ret_val_size = 0;
13549
13550 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13551
13552 if (ret_val_size > 2)
13553 {
13554 char *build_log = (char *) mymalloc (ret_val_size + 1);
13555
13556 memset (build_log, 0, ret_val_size + 1);
13557
13558 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13559
13560 puts (build_log);
13561
13562 myfree (build_log);
13563 }
13564 }
13565
13566 /**
13567 * word generator kernel
13568 */
13569
13570 if (attack_mode != ATTACK_MODE_STRAIGHT)
13571 {
13572 /**
13573 * kernel mp source filename
13574 */
13575
13576 char source_file[256];
13577
13578 memset (source_file, 0, sizeof (source_file));
13579
13580 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
13581
13582 struct stat sst;
13583
13584 if (stat (source_file, &sst) == -1)
13585 {
13586 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13587
13588 return -1;
13589 }
13590
13591 /**
13592 * kernel mp cached filename
13593 */
13594
13595 char cached_file[256];
13596
13597 memset (cached_file, 0, sizeof (cached_file));
13598
13599 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, vendor_id, cached_file);
13600
13601 int cached = 1;
13602
13603 struct stat cst;
13604
13605 if (stat (cached_file, &cst) == -1)
13606 {
13607 cached = 0;
13608 }
13609
13610 /**
13611 * kernel compile or load
13612 */
13613
13614 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13615
13616 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13617
13618 if (cached == 0)
13619 {
13620 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13621
13622 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13623
13624 device_param->program_mp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13625
13626 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13627
13628 size_t binary_size;
13629
13630 clGetProgramInfo (device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13631
13632 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13633
13634 clGetProgramInfo (device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13635
13636 writeProgramBin (cached_file, binary, binary_size);
13637
13638 local_free (binary);
13639 }
13640 else
13641 {
13642 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13643
13644 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13645
13646 device_param->program_mp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13647
13648 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13649 }
13650
13651 local_free (kernel_lengths);
13652 local_free (kernel_sources[0]);
13653 local_free (kernel_sources);
13654
13655 // this is mostly for debug
13656
13657 size_t ret_val_size = 0;
13658
13659 clGetProgramBuildInfo (device_param->program_mp, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13660
13661 if (ret_val_size > 2)
13662 {
13663 char *build_log = (char *) mymalloc (ret_val_size + 1);
13664
13665 memset (build_log, 0, ret_val_size + 1);
13666
13667 clGetProgramBuildInfo (device_param->program_mp, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13668
13669 puts (build_log);
13670
13671 myfree (build_log);
13672 }
13673 }
13674
13675 /**
13676 * amplifier kernel
13677 */
13678
13679 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13680 {
13681
13682 }
13683 else
13684 {
13685 /**
13686 * kernel amp source filename
13687 */
13688
13689 char source_file[256];
13690
13691 memset (source_file, 0, sizeof (source_file));
13692
13693 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
13694
13695 struct stat sst;
13696
13697 if (stat (source_file, &sst) == -1)
13698 {
13699 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13700
13701 return -1;
13702 }
13703
13704 /**
13705 * kernel amp cached filename
13706 */
13707
13708 char cached_file[256];
13709
13710 memset (cached_file, 0, sizeof (cached_file));
13711
13712 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, vendor_id, cached_file);
13713
13714 int cached = 1;
13715
13716 struct stat cst;
13717
13718 if (stat (cached_file, &cst) == -1)
13719 {
13720 cached = 0;
13721 }
13722
13723 /**
13724 * kernel compile or load
13725 */
13726
13727 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13728
13729 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13730
13731 if (cached == 0)
13732 {
13733 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13734
13735 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13736
13737 device_param->program_amp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13738
13739 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13740
13741 size_t binary_size;
13742
13743 clGetProgramInfo (device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13744
13745 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13746
13747 clGetProgramInfo (device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13748
13749 writeProgramBin (cached_file, binary, binary_size);
13750
13751 local_free (binary);
13752 }
13753 else
13754 {
13755 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13756
13757 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13758
13759 device_param->program_amp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13760
13761 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13762 }
13763
13764 local_free (kernel_lengths);
13765 local_free (kernel_sources[0]);
13766 local_free (kernel_sources);
13767
13768 // this is mostly for debug
13769
13770 size_t ret_val_size = 0;
13771
13772 clGetProgramBuildInfo (device_param->program_amp, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13773
13774 if (ret_val_size > 2)
13775 {
13776 char *build_log = (char *) mymalloc (ret_val_size + 1);
13777
13778 memset (build_log, 0, ret_val_size + 1);
13779
13780 clGetProgramBuildInfo (device_param->program_amp, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13781
13782 puts (build_log);
13783
13784 myfree (build_log);
13785 }
13786 }
13787
13788 /**
13789 * global buffers
13790 */
13791
13792 device_param->d_pws_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13793 device_param->d_pws_amp_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13794 device_param->d_tmps = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
13795 device_param->d_hooks = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
13796 device_param->d_bitmap_s1_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13797 device_param->d_bitmap_s1_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13798 device_param->d_bitmap_s1_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13799 device_param->d_bitmap_s1_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13800 device_param->d_bitmap_s2_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13801 device_param->d_bitmap_s2_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13802 device_param->d_bitmap_s2_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13803 device_param->d_bitmap_s2_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13804 device_param->d_plain_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
13805 device_param->d_digests_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
13806 device_param->d_digests_shown = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
13807 device_param->d_salt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
13808 device_param->d_result = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
13809 device_param->d_scryptV_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
13810
13811 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_a, CL_TRUE, 0, bitmap_size, bitmap_s1_a, 0, NULL, NULL);
13812 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_b, CL_TRUE, 0, bitmap_size, bitmap_s1_b, 0, NULL, NULL);
13813 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_c, CL_TRUE, 0, bitmap_size, bitmap_s1_c, 0, NULL, NULL);
13814 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_d, CL_TRUE, 0, bitmap_size, bitmap_s1_d, 0, NULL, NULL);
13815 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_a, CL_TRUE, 0, bitmap_size, bitmap_s2_a, 0, NULL, NULL);
13816 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_b, CL_TRUE, 0, bitmap_size, bitmap_s2_b, 0, NULL, NULL);
13817 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_c, CL_TRUE, 0, bitmap_size, bitmap_s2_c, 0, NULL, NULL);
13818 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_d, CL_TRUE, 0, bitmap_size, bitmap_s2_d, 0, NULL, NULL);
13819 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
13820 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
13821 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
13822
13823 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
13824 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
13825 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
13826 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
13827 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
13828 run_kernel_bzero (device_param, device_param->d_result, size_results);
13829
13830 /**
13831 * special buffers
13832 */
13833
13834 if (attack_kern == ATTACK_KERN_STRAIGHT)
13835 {
13836 device_param->d_rules = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
13837 device_param->d_rules_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
13838
13839 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
13840
13841 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
13842 }
13843 else if (attack_kern == ATTACK_KERN_COMBI)
13844 {
13845 device_param->d_combs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13846 device_param->d_combs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13847 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13848 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13849
13850 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
13851 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
13852 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13853 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13854 }
13855 else if (attack_kern == ATTACK_KERN_BF)
13856 {
13857 device_param->d_bfs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13858 device_param->d_bfs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13859 device_param->d_tm_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
13860 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13861 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13862
13863 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
13864 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
13865 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
13866 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13867 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13868 }
13869
13870 if (size_esalts)
13871 {
13872 device_param->d_esalt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
13873
13874 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
13875 }
13876
13877 /**
13878 * main host data
13879 */
13880
13881 uint *result = (uint *) mymalloc (size_results);
13882
13883 memset (result, 0, size_results);
13884
13885 device_param->result = result;
13886
13887 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
13888
13889 memset (pws_buf, 0, size_pws);
13890
13891 device_param->pws_buf = pws_buf;
13892
13893 pw_cache_t *pw_caches = (pw_cache_t *) mycalloc (64, sizeof (pw_cache_t));
13894
13895 for (int i = 0; i < 64; i++)
13896 {
13897 pw_caches[i].pw_buf.pw_len = i;
13898 pw_caches[i].cnt = 0;
13899 }
13900
13901 device_param->pw_caches = pw_caches;
13902
13903 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
13904
13905 device_param->combs_buf = combs_buf;
13906
13907 void *hooks_buf = mymalloc (size_hooks);
13908
13909 device_param->hooks_buf = hooks_buf;
13910
13911 device_param->pw_transpose = pw_transpose_to_hi1;
13912 device_param->pw_add = pw_add_to_hc1;
13913
13914 /**
13915 * kernel args
13916 */
13917
13918 device_param->kernel_params_buf32[21] = bitmap_mask;
13919 device_param->kernel_params_buf32[22] = bitmap_shift1;
13920 device_param->kernel_params_buf32[23] = bitmap_shift2;
13921 device_param->kernel_params_buf32[24] = 0; // salt_pos
13922 device_param->kernel_params_buf32[25] = 0; // loop_pos
13923 device_param->kernel_params_buf32[26] = 0; // loop_cnt
13924 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
13925 device_param->kernel_params_buf32[28] = 0; // digests_cnt
13926 device_param->kernel_params_buf32[29] = 0; // digests_offset
13927 device_param->kernel_params_buf32[30] = 0; // combs_mode
13928 device_param->kernel_params_buf32[31] = 0; // gid_max
13929
13930 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13931 ? &device_param->d_pws_buf
13932 : &device_param->d_pws_amp_buf;
13933 device_param->kernel_params[ 1] = &device_param->d_rules_c;
13934 device_param->kernel_params[ 2] = &device_param->d_combs_c;
13935 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
13936 device_param->kernel_params[ 4] = &device_param->d_tmps;
13937 device_param->kernel_params[ 5] = &device_param->d_hooks;
13938 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
13939 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
13940 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
13941 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
13942 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
13943 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
13944 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
13945 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
13946 device_param->kernel_params[14] = &device_param->d_plain_bufs;
13947 device_param->kernel_params[15] = &device_param->d_digests_buf;
13948 device_param->kernel_params[16] = &device_param->d_digests_shown;
13949 device_param->kernel_params[17] = &device_param->d_salt_bufs;
13950 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
13951 device_param->kernel_params[19] = &device_param->d_result;
13952 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
13953 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
13954 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
13955 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
13956 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
13957 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
13958 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
13959 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
13960 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
13961 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
13962 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
13963 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
13964
13965 device_param->kernel_params_mp_buf64[3] = 0;
13966 device_param->kernel_params_mp_buf32[4] = 0;
13967 device_param->kernel_params_mp_buf32[5] = 0;
13968 device_param->kernel_params_mp_buf32[6] = 0;
13969 device_param->kernel_params_mp_buf32[7] = 0;
13970 device_param->kernel_params_mp_buf32[8] = 0;
13971
13972 device_param->kernel_params_mp[0] = NULL;
13973 device_param->kernel_params_mp[1] = NULL;
13974 device_param->kernel_params_mp[2] = NULL;
13975 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
13976 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
13977 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
13978 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
13979 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
13980 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
13981
13982 device_param->kernel_params_mp_l_buf64[3] = 0;
13983 device_param->kernel_params_mp_l_buf32[4] = 0;
13984 device_param->kernel_params_mp_l_buf32[5] = 0;
13985 device_param->kernel_params_mp_l_buf32[6] = 0;
13986 device_param->kernel_params_mp_l_buf32[7] = 0;
13987 device_param->kernel_params_mp_l_buf32[8] = 0;
13988 device_param->kernel_params_mp_l_buf32[9] = 0;
13989
13990 device_param->kernel_params_mp_l[0] = NULL;
13991 device_param->kernel_params_mp_l[1] = NULL;
13992 device_param->kernel_params_mp_l[2] = NULL;
13993 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
13994 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
13995 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
13996 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
13997 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
13998 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
13999 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14000
14001 device_param->kernel_params_mp_r_buf64[3] = 0;
14002 device_param->kernel_params_mp_r_buf32[4] = 0;
14003 device_param->kernel_params_mp_r_buf32[5] = 0;
14004 device_param->kernel_params_mp_r_buf32[6] = 0;
14005 device_param->kernel_params_mp_r_buf32[7] = 0;
14006 device_param->kernel_params_mp_r_buf32[8] = 0;
14007
14008 device_param->kernel_params_mp_r[0] = NULL;
14009 device_param->kernel_params_mp_r[1] = NULL;
14010 device_param->kernel_params_mp_r[2] = NULL;
14011 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14012 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14013 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14014 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14015 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14016 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14017
14018 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14019 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14020
14021 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14022 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14023 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14024 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14025 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14026 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14027 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14028
14029 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
14030
14031 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14032 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14033
14034 /**
14035 * kernel name
14036 */
14037
14038 char kernel_name[64];
14039
14040 memset (kernel_name, 0, sizeof (kernel_name));
14041
14042 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14043 {
14044 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14045 {
14046 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14047
14048 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
14049
14050 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14051
14052 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
14053
14054 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14055
14056 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
14057 }
14058 else
14059 {
14060 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14061
14062 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
14063
14064 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14065
14066 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
14067
14068 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14069
14070 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
14071 }
14072
14073 if (weak_hash_threshold)
14074 {
14075 if (opts_type & add_flag)
14076 {
14077 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14078 {
14079 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14080
14081 device_param->kernel_weak = hc_clCreateKernel (device_param->program_weak, kernel_name);
14082 }
14083 else
14084 {
14085 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14086
14087 device_param->kernel_weak = hc_clCreateKernel (device_param->program_weak, kernel_name);
14088 }
14089 }
14090 else
14091 {
14092 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14093 {
14094 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14095
14096 device_param->kernel_weak = hc_clCreateKernel (device_param->program, kernel_name);
14097 }
14098 else
14099 {
14100 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14101
14102 device_param->kernel_weak = hc_clCreateKernel (device_param->program, kernel_name);
14103 }
14104 }
14105 }
14106
14107 if (data.attack_mode == ATTACK_MODE_BF)
14108 {
14109 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14110 {
14111 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
14112
14113 device_param->kernel_tb = hc_clCreateKernel (device_param->program, kernel_name);
14114
14115 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14116
14117 device_param->kernel_tm = hc_clCreateKernel (device_param->program, kernel_name);
14118 }
14119 }
14120 }
14121 else
14122 {
14123 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14124
14125 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
14126
14127 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14128
14129 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
14130
14131 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14132
14133 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
14134
14135 if (opts_type & OPTS_TYPE_HOOK12)
14136 {
14137 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14138
14139 device_param->kernel12 = hc_clCreateKernel (device_param->program, kernel_name);
14140 }
14141
14142 if (opts_type & OPTS_TYPE_HOOK23)
14143 {
14144 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14145
14146 device_param->kernel23 = hc_clCreateKernel (device_param->program, kernel_name);
14147 }
14148 }
14149
14150 for (uint i = 0; i <= 20; i++)
14151 {
14152 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14153 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14154 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14155
14156 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14157 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14158
14159 if (weak_hash_threshold)
14160 {
14161 hc_clSetKernelArg (device_param->kernel_weak, i, sizeof (cl_mem), device_param->kernel_params[i]);
14162 }
14163 }
14164
14165 for (uint i = 21; i <= 31; i++)
14166 {
14167 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14168 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14169 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14170
14171 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14172 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14173
14174 if (weak_hash_threshold)
14175 {
14176 hc_clSetKernelArg (device_param->kernel_weak, i, sizeof (cl_uint), device_param->kernel_params[i]);
14177 }
14178 }
14179
14180 if (attack_mode == ATTACK_MODE_BF)
14181 {
14182 device_param->kernel_mp_l = hc_clCreateKernel (device_param->program_mp, "l_markov");
14183 device_param->kernel_mp_r = hc_clCreateKernel (device_param->program_mp, "r_markov");
14184
14185 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14186 {
14187 hc_clSetKernelArg (device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
14188
14189 hc_clSetKernelArg (device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14190 hc_clSetKernelArg (device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14191 }
14192 }
14193 else if (attack_mode == ATTACK_MODE_HYBRID1)
14194 {
14195 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
14196 }
14197 else if (attack_mode == ATTACK_MODE_HYBRID2)
14198 {
14199 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
14200 }
14201
14202 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14203 {
14204 // nothing to do
14205 }
14206 else
14207 {
14208 device_param->kernel_amp = hc_clCreateKernel (device_param->program_amp, "amp");
14209 }
14210
14211 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14212 {
14213 // nothing to do
14214 }
14215 else
14216 {
14217 for (uint i = 0; i < 5; i++)
14218 {
14219 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14220 }
14221
14222 for (uint i = 5; i < 7; i++)
14223 {
14224 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14225 }
14226 }
14227
14228 /**
14229 * Store initial fanspeed if gpu_temp_retain is enabled
14230 */
14231
14232 int gpu_temp_retain_set = 0;
14233
14234 if (gpu_temp_disable == 0)
14235 {
14236 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14237 {
14238 hc_thread_mutex_lock (mux_adl);
14239
14240 if (data.hm_device[device_id].fan_supported == 1)
14241 {
14242 if (gpu_temp_retain_chgd == 0)
14243 {
14244 uint cur_temp = 0;
14245 uint default_temp = 0;
14246
14247 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);
14248
14249 if (ADL_rc == ADL_OK)
14250 {
14251 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14252
14253 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14254
14255 // special case with multi gpu setups: always use minimum retain
14256
14257 if (gpu_temp_retain_set == 0)
14258 {
14259 gpu_temp_retain = gpu_temp_retain_target;
14260 gpu_temp_retain_set = 1;
14261 }
14262 else
14263 {
14264 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14265 }
14266
14267 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14268 }
14269 }
14270
14271 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14272
14273 temp_retain_fanspeed_value[device_id] = fan_speed;
14274
14275 if (fan_speed == -1)
14276 {
14277 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14278
14279 temp_retain_fanspeed_value[device_id] = 0;
14280 }
14281 }
14282
14283 hc_thread_mutex_unlock (mux_adl);
14284 }
14285 }
14286
14287 /**
14288 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14289 */
14290
14291 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14292 {
14293 hc_thread_mutex_lock (mux_adl);
14294
14295 if (data.hm_device[device_id].od_version == 6)
14296 {
14297 int ADL_rc;
14298
14299 // check powertune capabilities first, if not available then skip device
14300
14301 int powertune_supported = 0;
14302
14303 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14304 {
14305 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14306
14307 return (-1);
14308 }
14309
14310 if (powertune_supported != 0)
14311 {
14312 // powercontrol settings
14313
14314 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14315
14316 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14317 {
14318 ADL_rc = hc_ADL_Overdrive_PowerControl_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14319 }
14320
14321 if (ADL_rc != ADL_OK)
14322 {
14323 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14324
14325 return (-1);
14326 }
14327
14328 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14329 {
14330 log_error ("ERROR: Failed to set new ADL PowerControl values");
14331
14332 return (-1);
14333 }
14334
14335 // clocks
14336
14337 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14338
14339 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14340
14341 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)
14342 {
14343 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14344
14345 return (-1);
14346 }
14347
14348 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14349
14350 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14351
14352 if ((ADL_rc = hc_ADL_Overdrive_Capabilities_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14353 {
14354 log_error ("ERROR: Failed to get ADL device capabilities");
14355
14356 return (-1);
14357 }
14358
14359 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14360 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14361
14362 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14363 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14364
14365 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14366 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14367
14368 // warning if profile has to low max values
14369
14370 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14371 {
14372 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14373 }
14374
14375 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14376 {
14377 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14378 }
14379
14380 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14381
14382 performance_state->iNumberOfPerformanceLevels = 2;
14383
14384 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14385 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14386 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14387 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14388
14389 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)
14390 {
14391 log_info ("ERROR: Failed to set ADL performance state");
14392
14393 return (-1);
14394 }
14395
14396 local_free (performance_state);
14397 }
14398 }
14399
14400 hc_thread_mutex_unlock (mux_adl);
14401 }
14402 }
14403
14404 data.kernel_blocks_all = kernel_blocks_all;
14405
14406 if (data.quiet == 0) log_info ("");
14407
14408 /**
14409 * Inform user which algorithm is checked and at which workload setting
14410 */
14411
14412 if (benchmark == 1)
14413 {
14414 quiet = 0;
14415
14416 data.quiet = quiet;
14417
14418 char *hash_type = strhashtype (data.hash_mode); // not a bug
14419
14420 log_info ("Hashtype: %s", hash_type);
14421 log_info ("Workload: %u loops, %u accel", kernel_loops, kernel_accel);
14422 log_info ("");
14423 }
14424
14425 /**
14426 * keep track of the progress
14427 */
14428
14429 data.words_progress_done = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
14430 data.words_progress_rejected = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
14431 data.words_progress_restored = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
14432
14433 /**
14434 * open filehandles
14435 */
14436
14437 #if _WIN
14438 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14439 {
14440 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14441
14442 return (-1);
14443 }
14444
14445 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14446 {
14447 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14448
14449 return (-1);
14450 }
14451
14452 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14453 {
14454 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14455
14456 return (-1);
14457 }
14458 #endif
14459
14460 /**
14461 * dictionary pad
14462 */
14463
14464 segment_size *= (1024 * 1024);
14465
14466 data.segment_size = segment_size;
14467
14468 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14469
14470 wl_data->buf = (char *) mymalloc (segment_size);
14471 wl_data->avail = segment_size;
14472 wl_data->incr = segment_size;
14473 wl_data->cnt = 0;
14474 wl_data->pos = 0;
14475
14476 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14477
14478 data.wordlist_mode = wordlist_mode;
14479
14480 cs_t *css_buf = NULL;
14481 uint css_cnt = 0;
14482 uint dictcnt = 0;
14483 uint maskcnt = 1;
14484 char **masks = NULL;
14485 char **dictfiles = NULL;
14486
14487 uint mask_from_file = 0;
14488
14489 if (attack_mode == ATTACK_MODE_STRAIGHT)
14490 {
14491 if (wordlist_mode == WL_MODE_FILE)
14492 {
14493 int wls_left = myargc - (optind + 1);
14494
14495 for (int i = 0; i < wls_left; i++)
14496 {
14497 char *l0_filename = myargv[optind + 1 + i];
14498
14499 struct stat l0_stat;
14500
14501 if (stat (l0_filename, &l0_stat) == -1)
14502 {
14503 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14504
14505 return (-1);
14506 }
14507
14508 uint is_dir = S_ISDIR (l0_stat.st_mode);
14509
14510 if (is_dir == 0)
14511 {
14512 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14513
14514 dictcnt++;
14515
14516 dictfiles[dictcnt - 1] = l0_filename;
14517 }
14518 else
14519 {
14520 // do not allow --keyspace w/ a directory
14521
14522 if (keyspace == 1)
14523 {
14524 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14525
14526 return (-1);
14527 }
14528
14529 char **dictionary_files = NULL;
14530
14531 dictionary_files = scan_directory (l0_filename);
14532
14533 if (dictionary_files != NULL)
14534 {
14535 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14536
14537 for (int d = 0; dictionary_files[d] != NULL; d++)
14538 {
14539 char *l1_filename = dictionary_files[d];
14540
14541 struct stat l1_stat;
14542
14543 if (stat (l1_filename, &l1_stat) == -1)
14544 {
14545 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14546
14547 return (-1);
14548 }
14549
14550 if (S_ISREG (l1_stat.st_mode))
14551 {
14552 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14553
14554 dictcnt++;
14555
14556 dictfiles[dictcnt - 1] = strdup (l1_filename);
14557 }
14558 }
14559 }
14560
14561 local_free (dictionary_files);
14562 }
14563 }
14564
14565 if (dictcnt < 1)
14566 {
14567 log_error ("ERROR: No usable dictionary file found.");
14568
14569 return (-1);
14570 }
14571 }
14572 else if (wordlist_mode == WL_MODE_STDIN)
14573 {
14574 dictcnt = 1;
14575 }
14576 }
14577 else if (attack_mode == ATTACK_MODE_COMBI)
14578 {
14579 // display
14580
14581 char *dictfile1 = myargv[optind + 1 + 0];
14582 char *dictfile2 = myargv[optind + 1 + 1];
14583
14584 // find the bigger dictionary and use as base
14585
14586 FILE *fp1;
14587 FILE *fp2;
14588
14589 struct stat tmp_stat;
14590
14591 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14592 {
14593 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14594
14595 return (-1);
14596 }
14597
14598 if (stat (dictfile1, &tmp_stat) == -1)
14599 {
14600 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14601
14602 fclose (fp1);
14603
14604 return (-1);
14605 }
14606
14607 if (S_ISDIR (tmp_stat.st_mode))
14608 {
14609 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14610
14611 fclose (fp1);
14612
14613 return (-1);
14614 }
14615
14616 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14617 {
14618 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14619
14620 fclose (fp1);
14621
14622 return (-1);
14623 }
14624
14625 if (stat (dictfile2, &tmp_stat) == -1)
14626 {
14627 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14628
14629 fclose (fp1);
14630 fclose (fp2);
14631
14632 return (-1);
14633 }
14634
14635 if (S_ISDIR (tmp_stat.st_mode))
14636 {
14637 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14638
14639 fclose (fp1);
14640 fclose (fp2);
14641
14642 return (-1);
14643 }
14644
14645 data.combs_cnt = 1;
14646
14647 data.quiet = 1;
14648
14649 const uint64_t words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14650
14651 data.quiet = quiet;
14652
14653 if (words1_cnt == 0)
14654 {
14655 log_error ("ERROR: %s: empty file", dictfile1);
14656
14657 fclose (fp1);
14658 fclose (fp2);
14659
14660 return (-1);
14661 }
14662
14663 data.combs_cnt = 1;
14664
14665 data.quiet = 1;
14666
14667 const uint64_t words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14668
14669 data.quiet = quiet;
14670
14671 if (words2_cnt == 0)
14672 {
14673 log_error ("ERROR: %s: empty file", dictfile2);
14674
14675 fclose (fp1);
14676 fclose (fp2);
14677
14678 return (-1);
14679 }
14680
14681 fclose (fp1);
14682 fclose (fp2);
14683
14684 data.dictfile = dictfile1;
14685 data.dictfile2 = dictfile2;
14686
14687 if (words1_cnt >= words2_cnt)
14688 {
14689 data.combs_cnt = words2_cnt;
14690 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14691
14692 dictfiles = &data.dictfile;
14693
14694 dictcnt = 1;
14695 }
14696 else
14697 {
14698 data.combs_cnt = words1_cnt;
14699 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14700
14701 dictfiles = &data.dictfile2;
14702
14703 dictcnt = 1;
14704
14705 // we also have to switch wordlist related rules!
14706
14707 char *tmpc = data.rule_buf_l;
14708
14709 data.rule_buf_l = data.rule_buf_r;
14710 data.rule_buf_r = tmpc;
14711
14712 int tmpi = data.rule_len_l;
14713
14714 data.rule_len_l = data.rule_len_r;
14715 data.rule_len_r = tmpi;
14716 }
14717 }
14718 else if (attack_mode == ATTACK_MODE_BF)
14719 {
14720 char *mask = NULL;
14721
14722 maskcnt = 0;
14723
14724 if (benchmark == 0)
14725 {
14726 mask = myargv[optind + 1];
14727
14728 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
14729
14730 if ((optind + 2) <= myargc)
14731 {
14732 struct stat file_stat;
14733
14734 if (stat (mask, &file_stat) == -1)
14735 {
14736 maskcnt = 1;
14737
14738 masks[maskcnt - 1] = mystrdup (mask);
14739 }
14740 else
14741 {
14742 int wls_left = myargc - (optind + 1);
14743
14744 uint masks_avail = INCR_MASKS;
14745
14746 for (int i = 0; i < wls_left; i++)
14747 {
14748 if (i != 0)
14749 {
14750 mask = myargv[optind + 1 + i];
14751
14752 if (stat (mask, &file_stat) == -1)
14753 {
14754 log_error ("ERROR: %s: %s", mask, strerror (errno));
14755
14756 return (-1);
14757 }
14758 }
14759
14760 uint is_file = S_ISREG (file_stat.st_mode);
14761
14762 if (is_file == 1)
14763 {
14764 FILE *mask_fp;
14765
14766 if ((mask_fp = fopen (mask, "r")) == NULL)
14767 {
14768 log_error ("ERROR: %s: %s", mask, strerror (errno));
14769
14770 return (-1);
14771 }
14772
14773 char line_buf[BUFSIZ];
14774
14775 while (!feof (mask_fp))
14776 {
14777 memset (line_buf, 0, BUFSIZ);
14778
14779 int line_len = fgetl (mask_fp, line_buf);
14780
14781 if (line_len == 0) continue;
14782
14783 if (line_buf[0] == '#') continue;
14784
14785 if (masks_avail == maskcnt)
14786 {
14787 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14788
14789 masks_avail += INCR_MASKS;
14790 }
14791
14792 masks[maskcnt] = mystrdup (line_buf);
14793
14794 maskcnt++;
14795 }
14796
14797 fclose (mask_fp);
14798 }
14799 else
14800 {
14801 log_error ("ERROR: %s: unsupported file-type", mask);
14802
14803 return (-1);
14804 }
14805 }
14806
14807 mask_from_file = 1;
14808 }
14809 }
14810 else
14811 {
14812 custom_charset_1 = (char *) "?l?d?u";
14813 custom_charset_2 = (char *) "?l?d";
14814 custom_charset_3 = (char *) "?l?d*!$@_";
14815
14816 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
14817 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
14818 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
14819
14820 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
14821
14822 wordlist_mode = WL_MODE_MASK;
14823
14824 data.wordlist_mode = wordlist_mode;
14825
14826 increment = 1;
14827
14828 maskcnt = 1;
14829 }
14830 }
14831 else
14832 {
14833 /**
14834 * generate full masks and charsets
14835 */
14836
14837 masks = (char **) mymalloc (sizeof (char *));
14838
14839 switch (hash_mode)
14840 {
14841 case 1731: pw_min = 5;
14842 pw_max = 5;
14843 mask = mystrdup ("?b?b?b?b?b");
14844 break;
14845 case 12500: pw_min = 5;
14846 pw_max = 5;
14847 mask = mystrdup ("?b?b?b?b?b");
14848 break;
14849 default: pw_min = 7;
14850 pw_max = 7;
14851 mask = mystrdup ("?b?b?b?b?b?b?b");
14852 break;
14853 }
14854
14855 maskcnt = 1;
14856
14857 masks[maskcnt - 1] = mystrdup (mask);
14858
14859 wordlist_mode = WL_MODE_MASK;
14860
14861 data.wordlist_mode = wordlist_mode;
14862
14863 increment = 1;
14864 }
14865
14866 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
14867
14868 if (increment)
14869 {
14870 if (increment_min > pw_min) pw_min = increment_min;
14871
14872 if (increment_max < pw_max) pw_max = increment_max;
14873 }
14874 }
14875 else if (attack_mode == ATTACK_MODE_HYBRID1)
14876 {
14877 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14878
14879 // display
14880
14881 char *mask = myargv[myargc - 1];
14882
14883 maskcnt = 0;
14884
14885 masks = (char **) mymalloc (1 * sizeof (char *));
14886
14887 // mod
14888
14889 struct stat file_stat;
14890
14891 if (stat (mask, &file_stat) == -1)
14892 {
14893 maskcnt = 1;
14894
14895 masks[maskcnt - 1] = mystrdup (mask);
14896 }
14897 else
14898 {
14899 uint is_file = S_ISREG (file_stat.st_mode);
14900
14901 if (is_file == 1)
14902 {
14903 FILE *mask_fp;
14904
14905 if ((mask_fp = fopen (mask, "r")) == NULL)
14906 {
14907 log_error ("ERROR: %s: %s", mask, strerror (errno));
14908
14909 return (-1);
14910 }
14911
14912 char line_buf[BUFSIZ];
14913
14914 uint masks_avail = 1;
14915
14916 while (!feof (mask_fp))
14917 {
14918 memset (line_buf, 0, BUFSIZ);
14919
14920 int line_len = fgetl (mask_fp, line_buf);
14921
14922 if (line_len == 0) continue;
14923
14924 if (line_buf[0] == '#') continue;
14925
14926 if (masks_avail == maskcnt)
14927 {
14928 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14929
14930 masks_avail += INCR_MASKS;
14931 }
14932
14933 masks[maskcnt] = mystrdup (line_buf);
14934
14935 maskcnt++;
14936 }
14937
14938 fclose (mask_fp);
14939
14940 mask_from_file = 1;
14941 }
14942 else
14943 {
14944 maskcnt = 1;
14945
14946 masks[maskcnt - 1] = mystrdup (mask);
14947 }
14948 }
14949
14950 // base
14951
14952 int wls_left = myargc - (optind + 2);
14953
14954 for (int i = 0; i < wls_left; i++)
14955 {
14956 char *filename = myargv[optind + 1 + i];
14957
14958 struct stat file_stat;
14959
14960 if (stat (filename, &file_stat) == -1)
14961 {
14962 log_error ("ERROR: %s: %s", filename, strerror (errno));
14963
14964 return (-1);
14965 }
14966
14967 uint is_dir = S_ISDIR (file_stat.st_mode);
14968
14969 if (is_dir == 0)
14970 {
14971 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14972
14973 dictcnt++;
14974
14975 dictfiles[dictcnt - 1] = filename;
14976 }
14977 else
14978 {
14979 // do not allow --keyspace w/ a directory
14980
14981 if (keyspace == 1)
14982 {
14983 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14984
14985 return (-1);
14986 }
14987
14988 char **dictionary_files = NULL;
14989
14990 dictionary_files = scan_directory (filename);
14991
14992 if (dictionary_files != NULL)
14993 {
14994 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14995
14996 for (int d = 0; dictionary_files[d] != NULL; d++)
14997 {
14998 char *l1_filename = dictionary_files[d];
14999
15000 struct stat l1_stat;
15001
15002 if (stat (l1_filename, &l1_stat) == -1)
15003 {
15004 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15005
15006 return (-1);
15007 }
15008
15009 if (S_ISREG (l1_stat.st_mode))
15010 {
15011 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15012
15013 dictcnt++;
15014
15015 dictfiles[dictcnt - 1] = strdup (l1_filename);
15016 }
15017 }
15018 }
15019
15020 local_free (dictionary_files);
15021 }
15022 }
15023
15024 if (dictcnt < 1)
15025 {
15026 log_error ("ERROR: No usable dictionary file found.");
15027
15028 return (-1);
15029 }
15030
15031 if (increment)
15032 {
15033 maskcnt = 0;
15034
15035 uint mask_min = increment_min; // we can't reject smaller masks here
15036 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15037
15038 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15039 {
15040 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15041
15042 if (cur_mask == NULL) break;
15043
15044 masks[maskcnt] = cur_mask;
15045
15046 maskcnt++;
15047
15048 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15049 }
15050 }
15051 }
15052 else if (attack_mode == ATTACK_MODE_HYBRID2)
15053 {
15054 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15055
15056 // display
15057
15058 char *mask = myargv[optind + 1 + 0];
15059
15060 maskcnt = 0;
15061
15062 masks = (char **) mymalloc (1 * sizeof (char *));
15063
15064 // mod
15065
15066 struct stat file_stat;
15067
15068 if (stat (mask, &file_stat) == -1)
15069 {
15070 maskcnt = 1;
15071
15072 masks[maskcnt - 1] = mystrdup (mask);
15073 }
15074 else
15075 {
15076 uint is_file = S_ISREG (file_stat.st_mode);
15077
15078 if (is_file == 1)
15079 {
15080 FILE *mask_fp;
15081
15082 if ((mask_fp = fopen (mask, "r")) == NULL)
15083 {
15084 log_error ("ERROR: %s: %s", mask, strerror (errno));
15085
15086 return (-1);
15087 }
15088
15089 char line_buf[BUFSIZ];
15090
15091 uint masks_avail = 1;
15092
15093 while (!feof (mask_fp))
15094 {
15095 memset (line_buf, 0, BUFSIZ);
15096
15097 int line_len = fgetl (mask_fp, line_buf);
15098
15099 if (line_len == 0) continue;
15100
15101 if (line_buf[0] == '#') continue;
15102
15103 if (masks_avail == maskcnt)
15104 {
15105 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15106
15107 masks_avail += INCR_MASKS;
15108 }
15109
15110 masks[maskcnt] = mystrdup (line_buf);
15111
15112 maskcnt++;
15113 }
15114
15115 fclose (mask_fp);
15116
15117 mask_from_file = 1;
15118 }
15119 else
15120 {
15121 maskcnt = 1;
15122
15123 masks[maskcnt - 1] = mystrdup (mask);
15124 }
15125 }
15126
15127 // base
15128
15129 int wls_left = myargc - (optind + 2);
15130
15131 for (int i = 0; i < wls_left; i++)
15132 {
15133 char *filename = myargv[optind + 2 + i];
15134
15135 struct stat file_stat;
15136
15137 if (stat (filename, &file_stat) == -1)
15138 {
15139 log_error ("ERROR: %s: %s", filename, strerror (errno));
15140
15141 return (-1);
15142 }
15143
15144 uint is_dir = S_ISDIR (file_stat.st_mode);
15145
15146 if (is_dir == 0)
15147 {
15148 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15149
15150 dictcnt++;
15151
15152 dictfiles[dictcnt - 1] = filename;
15153 }
15154 else
15155 {
15156 // do not allow --keyspace w/ a directory
15157
15158 if (keyspace == 1)
15159 {
15160 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15161
15162 return (-1);
15163 }
15164
15165 char **dictionary_files = NULL;
15166
15167 dictionary_files = scan_directory (filename);
15168
15169 if (dictionary_files != NULL)
15170 {
15171 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15172
15173 for (int d = 0; dictionary_files[d] != NULL; d++)
15174 {
15175 char *l1_filename = dictionary_files[d];
15176
15177 struct stat l1_stat;
15178
15179 if (stat (l1_filename, &l1_stat) == -1)
15180 {
15181 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15182
15183 return (-1);
15184 }
15185
15186 if (S_ISREG (l1_stat.st_mode))
15187 {
15188 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15189
15190 dictcnt++;
15191
15192 dictfiles[dictcnt - 1] = strdup (l1_filename);
15193 }
15194 }
15195 }
15196
15197 local_free (dictionary_files);
15198 }
15199 }
15200
15201 if (dictcnt < 1)
15202 {
15203 log_error ("ERROR: No usable dictionary file found.");
15204
15205 return (-1);
15206 }
15207
15208 if (increment)
15209 {
15210 maskcnt = 0;
15211
15212 uint mask_min = increment_min; // we can't reject smaller masks here
15213 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15214
15215 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15216 {
15217 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15218
15219 if (cur_mask == NULL) break;
15220
15221 masks[maskcnt] = cur_mask;
15222
15223 maskcnt++;
15224
15225 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15226 }
15227 }
15228 }
15229
15230 data.pw_min = pw_min;
15231 data.pw_max = pw_max;
15232
15233 /**
15234 * weak hash check
15235 */
15236
15237 if (weak_hash_threshold >= salts_cnt)
15238 {
15239 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15240
15241 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15242 {
15243 weak_hash_check (&data.devices_param[0], salt_pos, kernel_loops);
15244 }
15245 }
15246
15247 // Display hack, guarantee that there is at least one \r before real start
15248
15249 if (data.quiet == 0) log_info_nn ("");
15250
15251 /**
15252 * status and monitor threads
15253 */
15254
15255 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15256
15257 hc_thread_t i_thread = 0;
15258
15259 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15260 {
15261 hc_thread_create (i_thread, thread_keypress, &benchmark);
15262 }
15263
15264 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15265
15266 uint ni_threads_cnt = 0;
15267
15268 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15269
15270 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15271
15272 ni_threads_cnt++;
15273
15274 /**
15275 * Outfile remove
15276 */
15277
15278 if (keyspace == 0)
15279 {
15280 if (outfile_check_timer != 0)
15281 {
15282 if (data.outfile_check_directory != NULL)
15283 {
15284 if ((hash_mode != 5200) &&
15285 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15286 (hash_mode != 9000))
15287 {
15288 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15289
15290 ni_threads_cnt++;
15291 }
15292 else
15293 {
15294 outfile_check_timer = 0;
15295 }
15296 }
15297 else
15298 {
15299 outfile_check_timer = 0;
15300 }
15301 }
15302 }
15303
15304 /**
15305 * Inform the user if we got some hashes remove because of the pot file remove feature
15306 */
15307
15308 if (data.quiet == 0)
15309 {
15310 if (potfile_remove_cracks > 0)
15311 {
15312 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15313 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15314 }
15315 }
15316
15317 data.outfile_check_timer = outfile_check_timer;
15318
15319 /**
15320 * main loop
15321 */
15322
15323 char **induction_dictionaries = NULL;
15324
15325 int induction_dictionaries_cnt = 0;
15326
15327 hcstat_table_t *root_table_buf = NULL;
15328 hcstat_table_t *markov_table_buf = NULL;
15329
15330 uint initial_restore_done = 0;
15331
15332 data.maskcnt = maskcnt;
15333
15334 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15335 {
15336 if (data.devices_status == STATUS_CRACKED) break;
15337
15338 data.devices_status = STATUS_INIT;
15339
15340 if (maskpos > rd->maskpos)
15341 {
15342 rd->dictpos = 0;
15343 }
15344
15345 rd->maskpos = maskpos;
15346 data.maskpos = maskpos;
15347
15348 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15349 {
15350 char *mask = masks[maskpos];
15351
15352 if (mask_from_file == 1)
15353 {
15354 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15355
15356 char *str_ptr;
15357 uint str_pos;
15358
15359 uint mask_offset = 0;
15360
15361 uint separator_cnt;
15362
15363 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15364 {
15365 str_ptr = strstr (mask + mask_offset, ",");
15366
15367 if (str_ptr == NULL) break;
15368
15369 str_pos = str_ptr - mask;
15370
15371 // escaped separator, i.e. "\,"
15372
15373 if (str_pos > 0)
15374 {
15375 if (mask[str_pos - 1] == '\\')
15376 {
15377 separator_cnt --;
15378
15379 mask_offset = str_pos + 1;
15380
15381 continue;
15382 }
15383 }
15384
15385 // reset the offset
15386
15387 mask_offset = 0;
15388
15389 mask[str_pos] = '\0';
15390
15391 switch (separator_cnt)
15392 {
15393 case 0:
15394 mp_reset_usr (mp_usr, 0);
15395
15396 custom_charset_1 = mask;
15397 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15398 break;
15399
15400 case 1:
15401 mp_reset_usr (mp_usr, 1);
15402
15403 custom_charset_2 = mask;
15404 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15405 break;
15406
15407 case 2:
15408 mp_reset_usr (mp_usr, 2);
15409
15410 custom_charset_3 = mask;
15411 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15412 break;
15413
15414 case 3:
15415 mp_reset_usr (mp_usr, 3);
15416
15417 custom_charset_4 = mask;
15418 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15419 break;
15420 }
15421
15422 mask = mask + str_pos + 1;
15423 }
15424 }
15425
15426 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15427 {
15428 if (maskpos > 0)
15429 {
15430 local_free (css_buf);
15431 local_free (data.root_css_buf);
15432 local_free (data.markov_css_buf);
15433
15434 local_free (masks[maskpos - 1]);
15435 }
15436
15437 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15438
15439 data.mask = mask;
15440 data.css_cnt = css_cnt;
15441 data.css_buf = css_buf;
15442
15443 uint uniq_tbls[SP_PW_MAX][CHARSIZ];
15444
15445 memset (uniq_tbls, 0, sizeof (uniq_tbls));
15446
15447 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15448
15449 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15450 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15451
15452 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15453
15454 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15455
15456 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15457 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15458
15459 data.root_css_buf = root_css_buf;
15460 data.markov_css_buf = markov_css_buf;
15461
15462 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15463
15464 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15465
15466 local_free (root_table_buf);
15467 local_free (markov_table_buf);
15468
15469 // args
15470
15471 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15472 {
15473 hc_device_param_t *device_param = &data.devices_param[device_id];
15474
15475 device_param->kernel_params_mp[0] = &device_param->d_combs;
15476 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15477 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15478
15479 device_param->kernel_params_mp_buf64[3] = 0;
15480 device_param->kernel_params_mp_buf32[4] = css_cnt;
15481 device_param->kernel_params_mp_buf32[5] = 0;
15482 device_param->kernel_params_mp_buf32[6] = 0;
15483 device_param->kernel_params_mp_buf32[7] = 0;
15484
15485 if (attack_mode == ATTACK_MODE_HYBRID1)
15486 {
15487 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15488 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15489 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15490 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15491 }
15492 else if (attack_mode == ATTACK_MODE_HYBRID2)
15493 {
15494 device_param->kernel_params_mp_buf32[5] = 0;
15495 device_param->kernel_params_mp_buf32[6] = 0;
15496 device_param->kernel_params_mp_buf32[7] = 0;
15497 }
15498
15499 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp[i]);
15500 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp[i]);
15501 for (uint i = 4; i < 8; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp[i]);
15502
15503 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);
15504 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);
15505 }
15506 }
15507 else if (attack_mode == ATTACK_MODE_BF)
15508 {
15509 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15510
15511 if (increment)
15512 {
15513 for (uint i = 0; i < dictcnt; i++)
15514 {
15515 local_free (dictfiles[i]);
15516 }
15517
15518 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15519 {
15520 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15521
15522 if (l1_filename == NULL) break;
15523
15524 dictcnt++;
15525
15526 dictfiles[dictcnt - 1] = l1_filename;
15527 }
15528 }
15529 else
15530 {
15531 dictcnt++;
15532
15533 dictfiles[dictcnt - 1] = mask;
15534 }
15535
15536 if (dictcnt == 0)
15537 {
15538 log_error ("ERROR: Mask is too small");
15539
15540 return (-1);
15541 }
15542 }
15543 }
15544
15545 free (induction_dictionaries);
15546
15547 // induction_dictionaries_cnt = 0; // implied
15548
15549 if (attack_mode != ATTACK_MODE_BF)
15550 {
15551 if (keyspace == 0)
15552 {
15553 induction_dictionaries = scan_directory (induction_directory);
15554
15555 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15556 }
15557 }
15558
15559 if (induction_dictionaries_cnt)
15560 {
15561 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15562 }
15563
15564 /**
15565 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15566 */
15567 if (keyspace == 1)
15568 {
15569 if ((maskcnt > 1) || (dictcnt > 1))
15570 {
15571 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15572
15573 return (-1);
15574 }
15575 }
15576
15577 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15578 {
15579 char *subid = logfile_generate_subid ();
15580
15581 data.subid = subid;
15582
15583 logfile_sub_msg ("START");
15584
15585 data.devices_status = STATUS_INIT;
15586
15587 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (uint64_t));
15588 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (uint64_t));
15589 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (uint64_t));
15590
15591 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15592
15593 data.cpt_pos = 0;
15594
15595 data.cpt_start = time (NULL);
15596
15597 data.cpt_total = 0;
15598
15599 if (data.restore == 0)
15600 {
15601 rd->words_cur = skip;
15602
15603 skip = 0;
15604
15605 data.skip = 0;
15606 }
15607
15608 data.ms_paused = 0;
15609
15610 data.words_cur = rd->words_cur;
15611
15612 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15613 {
15614 hc_device_param_t *device_param = &data.devices_param[device_id];
15615
15616 device_param->speed_pos = 0;
15617
15618 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (uint64_t));
15619 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15620 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15621
15622 device_param->kernel_power = device_param->kernel_power_user;
15623 device_param->kernel_blocks = device_param->kernel_blocks_user;
15624
15625 device_param->outerloop_pos = 0;
15626 device_param->outerloop_left = 0;
15627 device_param->innerloop_pos = 0;
15628 device_param->innerloop_left = 0;
15629
15630 // some more resets:
15631
15632 memset (device_param->pw_caches, 0, 64 * sizeof (pw_cache_t));
15633
15634 memset (device_param->pws_buf, 0, device_param->size_pws);
15635
15636 device_param->pw_cnt = 0;
15637 device_param->pws_cnt = 0;
15638
15639 device_param->words_off = 0;
15640 device_param->words_done = 0;
15641 }
15642
15643 data.kernel_blocks_div = 0;
15644
15645 // figure out some workload
15646
15647 if (attack_mode == ATTACK_MODE_STRAIGHT)
15648 {
15649 if (data.wordlist_mode == WL_MODE_FILE)
15650 {
15651 char *dictfile = NULL;
15652
15653 if (induction_dictionaries_cnt)
15654 {
15655 dictfile = induction_dictionaries[0];
15656 }
15657 else
15658 {
15659 dictfile = dictfiles[dictpos];
15660 }
15661
15662 data.dictfile = dictfile;
15663
15664 logfile_sub_string (dictfile);
15665
15666 for (uint i = 0; i < rp_files_cnt; i++)
15667 {
15668 logfile_sub_var_string ("rulefile", rp_files[i]);
15669 }
15670
15671 FILE *fd2 = fopen (dictfile, "rb");
15672
15673 if (fd2 == NULL)
15674 {
15675 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15676
15677 return (-1);
15678 }
15679
15680 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15681
15682 fclose (fd2);
15683
15684 if (data.words_cnt == 0)
15685 {
15686 if (data.devices_status == STATUS_CRACKED) break;
15687 if (data.devices_status == STATUS_ABORTED) break;
15688
15689 dictpos++;
15690
15691 continue;
15692 }
15693 }
15694 }
15695 else if (attack_mode == ATTACK_MODE_COMBI)
15696 {
15697 char *dictfile = data.dictfile;
15698 char *dictfile2 = data.dictfile2;
15699
15700 logfile_sub_string (dictfile);
15701 logfile_sub_string (dictfile2);
15702
15703 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
15704 {
15705 FILE *fd2 = fopen (dictfile, "rb");
15706
15707 if (fd2 == NULL)
15708 {
15709 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15710
15711 return (-1);
15712 }
15713
15714 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15715
15716 fclose (fd2);
15717 }
15718 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
15719 {
15720 FILE *fd2 = fopen (dictfile2, "rb");
15721
15722 if (fd2 == NULL)
15723 {
15724 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15725
15726 return (-1);
15727 }
15728
15729 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
15730
15731 fclose (fd2);
15732 }
15733
15734 if (data.words_cnt == 0)
15735 {
15736 if (data.devices_status == STATUS_CRACKED) break;
15737 if (data.devices_status == STATUS_ABORTED) break;
15738
15739 dictpos++;
15740
15741 continue;
15742 }
15743 }
15744 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15745 {
15746 char *dictfile = NULL;
15747
15748 if (induction_dictionaries_cnt)
15749 {
15750 dictfile = induction_dictionaries[0];
15751 }
15752 else
15753 {
15754 dictfile = dictfiles[dictpos];
15755 }
15756
15757 data.dictfile = dictfile;
15758
15759 char *mask = data.mask;
15760
15761 logfile_sub_string (dictfile);
15762 logfile_sub_string (mask);
15763
15764 FILE *fd2 = fopen (dictfile, "rb");
15765
15766 if (fd2 == NULL)
15767 {
15768 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15769
15770 return (-1);
15771 }
15772
15773 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15774
15775 fclose (fd2);
15776
15777 if (data.words_cnt == 0)
15778 {
15779 if (data.devices_status == STATUS_CRACKED) break;
15780 if (data.devices_status == STATUS_ABORTED) break;
15781
15782 dictpos++;
15783
15784 continue;
15785 }
15786 }
15787 else if (attack_mode == ATTACK_MODE_BF)
15788 {
15789 local_free (css_buf);
15790 local_free (data.root_css_buf);
15791 local_free (data.markov_css_buf);
15792
15793 char *mask = dictfiles[dictpos];
15794
15795 logfile_sub_string (mask);
15796
15797 // base
15798
15799 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15800
15801 if (opts_type & OPTS_TYPE_PT_UNICODE)
15802 {
15803 uint css_cnt_unicode = css_cnt * 2;
15804
15805 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
15806
15807 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
15808 {
15809 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
15810
15811 css_buf_unicode[j + 1].cs_buf[0] = 0;
15812 css_buf_unicode[j + 1].cs_len = 1;
15813 }
15814
15815 free (css_buf);
15816
15817 css_buf = css_buf_unicode;
15818 css_cnt = css_cnt_unicode;
15819 }
15820
15821 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
15822
15823 uint mask_min = pw_min;
15824 uint mask_max = pw_max;
15825
15826 if (opts_type & OPTS_TYPE_PT_UNICODE)
15827 {
15828 mask_min *= 2;
15829 mask_max *= 2;
15830 }
15831
15832 if ((css_cnt < mask_min) || (css_cnt > mask_max))
15833 {
15834 if (css_cnt < mask_min)
15835 {
15836 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
15837 }
15838
15839 if (css_cnt > mask_max)
15840 {
15841 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
15842 }
15843
15844 // skip to next mask
15845
15846 dictpos++;
15847
15848 rd->dictpos = dictpos;
15849
15850 logfile_sub_msg ("STOP");
15851
15852 continue;
15853 }
15854
15855 uint save_css_cnt = css_cnt;
15856
15857 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15858 {
15859 if (opti_type & OPTI_TYPE_APPENDED_SALT)
15860 {
15861 uint salt_len = (uint) data.salts_buf[0].salt_len;
15862 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
15863
15864 uint css_cnt_salt = css_cnt + salt_len;
15865
15866 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
15867
15868 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
15869
15870 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
15871 {
15872 css_buf_salt[j].cs_buf[0] = salt_buf[i];
15873 css_buf_salt[j].cs_len = 1;
15874 }
15875
15876 free (css_buf);
15877
15878 css_buf = css_buf_salt;
15879 css_cnt = css_cnt_salt;
15880 }
15881 }
15882
15883 data.mask = mask;
15884 data.css_cnt = css_cnt;
15885 data.css_buf = css_buf;
15886
15887 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
15888
15889 uint uniq_tbls[SP_PW_MAX][CHARSIZ];
15890
15891 memset (uniq_tbls, 0, sizeof (uniq_tbls));
15892
15893 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15894
15895 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15896 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15897
15898 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15899
15900 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15901
15902 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15903 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15904
15905 data.root_css_buf = root_css_buf;
15906 data.markov_css_buf = markov_css_buf;
15907
15908 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15909
15910 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15911
15912 local_free (root_table_buf);
15913 local_free (markov_table_buf);
15914
15915 // copy + args
15916
15917 uint css_cnt_l = css_cnt;
15918 uint css_cnt_r;
15919
15920 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15921 {
15922 if (save_css_cnt < 6)
15923 {
15924 css_cnt_r = 1;
15925 }
15926 else if (save_css_cnt == 6)
15927 {
15928 css_cnt_r = 2;
15929 }
15930 else
15931 {
15932 if (opts_type & OPTS_TYPE_PT_UNICODE)
15933 {
15934 if (save_css_cnt == 8 || save_css_cnt == 10)
15935 {
15936 css_cnt_r = 2;
15937 }
15938 else
15939 {
15940 css_cnt_r = 4;
15941 }
15942 }
15943 else
15944 {
15945 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
15946 {
15947 css_cnt_r = 3;
15948 }
15949 else
15950 {
15951 css_cnt_r = 4;
15952 }
15953 }
15954 }
15955 }
15956 else
15957 {
15958 css_cnt_r = 1;
15959
15960 /* unfinished code?
15961 int sum = css_buf[css_cnt_r - 1].cs_len;
15962
15963 for (uint i = 1; i < 4 && i < css_cnt; i++)
15964 {
15965 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
15966
15967 css_cnt_r++;
15968
15969 sum *= css_buf[css_cnt_r - 1].cs_len;
15970 }
15971 */
15972 }
15973
15974 css_cnt_l -= css_cnt_r;
15975
15976 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
15977
15978 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15979 {
15980 hc_device_param_t *device_param = &data.devices_param[device_id];
15981
15982 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
15983 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
15984 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
15985
15986 device_param->kernel_params_mp_l_buf64[3] = 0;
15987 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
15988 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
15989 device_param->kernel_params_mp_l_buf32[6] = 0;
15990 device_param->kernel_params_mp_l_buf32[7] = 0;
15991 device_param->kernel_params_mp_l_buf32[8] = 0;
15992
15993 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
15994 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
15995 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
15996 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
15997
15998 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
15999 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16000 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16001
16002 device_param->kernel_params_mp_r_buf64[3] = 0;
16003 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16004 device_param->kernel_params_mp_r_buf32[5] = 0;
16005 device_param->kernel_params_mp_r_buf32[6] = 0;
16006 device_param->kernel_params_mp_r_buf32[7] = 0;
16007
16008 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]);
16009 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]);
16010 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]);
16011
16012 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]);
16013 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]);
16014 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]);
16015
16016 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);
16017 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);
16018 }
16019 }
16020
16021 uint64_t words_base = data.words_cnt;
16022
16023 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16024 {
16025 if (data.kernel_rules_cnt)
16026 {
16027 words_base /= data.kernel_rules_cnt;
16028 }
16029 }
16030 else if (data.attack_kern == ATTACK_KERN_COMBI)
16031 {
16032 if (data.combs_cnt)
16033 {
16034 words_base /= data.combs_cnt;
16035 }
16036 }
16037 else if (data.attack_kern == ATTACK_KERN_BF)
16038 {
16039 if (data.bfs_cnt)
16040 {
16041 words_base /= data.bfs_cnt;
16042 }
16043 }
16044
16045 data.words_base = words_base;
16046
16047 if (keyspace == 1)
16048 {
16049 log_info ("%llu", (unsigned long long int) words_base);
16050
16051 return (0);
16052 }
16053
16054 if (data.words_cur > data.words_base)
16055 {
16056 log_error ("ERROR: restore value greater keyspace");
16057
16058 return (-1);
16059 }
16060
16061 if (data.words_cur)
16062 {
16063 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16064 {
16065 for (uint i = 0; i < data.salts_cnt; i++)
16066 {
16067 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16068 }
16069 }
16070 else if (data.attack_kern == ATTACK_KERN_COMBI)
16071 {
16072 for (uint i = 0; i < data.salts_cnt; i++)
16073 {
16074 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16075 }
16076 }
16077 else if (data.attack_kern == ATTACK_KERN_BF)
16078 {
16079 for (uint i = 0; i < data.salts_cnt; i++)
16080 {
16081 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16082 }
16083 }
16084 }
16085
16086 /*
16087 * Inform user about possible slow speeds
16088 */
16089
16090 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16091 {
16092 if (data.words_base < kernel_blocks_all)
16093 {
16094 if (quiet == 0)
16095 {
16096 log_info ("");
16097 log_info ("ATTENTION!");
16098 log_info (" The wordlist or mask you are using is too small.");
16099 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16100 log_info (" The cracking speed will drop.");
16101 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16102 log_info ("");
16103 }
16104 }
16105 }
16106
16107 /*
16108 * Update loopback file
16109 */
16110
16111 if (loopback == 1)
16112 {
16113 time_t now;
16114
16115 time (&now);
16116
16117 uint random_num = get_random_num (0, 9999);
16118
16119 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16120
16121 data.loopback_file = loopback_file;
16122 }
16123
16124 /*
16125 * Update dictionary statistic
16126 */
16127
16128 if (keyspace == 0)
16129 {
16130 dictstat_fp = fopen (dictstat, "wb");
16131
16132 if (dictstat_fp)
16133 {
16134 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16135
16136 fclose (dictstat_fp);
16137 }
16138 }
16139
16140 data.devices_status = STATUS_RUNNING;
16141
16142 if (initial_restore_done == 0)
16143 {
16144 if (data.restore_disable == 0) cycle_restore ();
16145
16146 initial_restore_done = 1;
16147 }
16148
16149 hc_timer_set (&data.timer_running);
16150
16151 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16152 {
16153 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16154 {
16155 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16156 if (quiet == 0) fflush (stdout);
16157 }
16158 }
16159 else if (wordlist_mode == WL_MODE_STDIN)
16160 {
16161 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16162 if (data.quiet == 0) log_info ("");
16163 }
16164
16165 time_t runtime_start;
16166
16167 time (&runtime_start);
16168
16169 data.runtime_start = runtime_start;
16170
16171 /**
16172 * create cracker threads
16173 */
16174
16175 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (devices_cnt, sizeof (hc_thread_t));
16176
16177 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16178 {
16179 hc_device_param_t *device_param = &devices_param[device_id];
16180
16181 device_param->device_id = device_id;
16182
16183 if (wordlist_mode == WL_MODE_STDIN)
16184 {
16185 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16186 }
16187 else
16188 {
16189 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16190 }
16191 }
16192
16193 // wait for crack threads to exit
16194
16195 hc_thread_wait (devices_cnt, c_threads);
16196
16197 local_free (c_threads);
16198
16199 data.restore = 0;
16200
16201 // finalize task
16202
16203 logfile_sub_var_uint ("status-after-work", data.devices_status);
16204
16205 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16206
16207 if (data.devices_status == STATUS_CRACKED) break;
16208 if (data.devices_status == STATUS_ABORTED) break;
16209
16210 if (data.devices_status == STATUS_BYPASS)
16211 {
16212 data.devices_status = STATUS_RUNNING;
16213 }
16214
16215 if (induction_dictionaries_cnt)
16216 {
16217 unlink (induction_dictionaries[0]);
16218 }
16219
16220 free (induction_dictionaries);
16221
16222 if (attack_mode != ATTACK_MODE_BF)
16223 {
16224 induction_dictionaries = scan_directory (induction_directory);
16225
16226 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16227 }
16228
16229 if (benchmark == 0)
16230 {
16231 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16232 {
16233 if (quiet == 0) clear_prompt ();
16234
16235 if (quiet == 0) log_info ("");
16236
16237 if (status == 1)
16238 {
16239 status_display ();
16240 }
16241 else
16242 {
16243 if (quiet == 0) status_display ();
16244 }
16245
16246 if (quiet == 0) log_info ("");
16247 }
16248 }
16249
16250 if (attack_mode == ATTACK_MODE_BF)
16251 {
16252 dictpos++;
16253
16254 rd->dictpos = dictpos;
16255 }
16256 else
16257 {
16258 if (induction_dictionaries_cnt)
16259 {
16260 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16261 }
16262 else
16263 {
16264 dictpos++;
16265
16266 rd->dictpos = dictpos;
16267 }
16268 }
16269
16270 time_t runtime_stop;
16271
16272 time (&runtime_stop);
16273
16274 data.runtime_stop = runtime_stop;
16275
16276 logfile_sub_uint (runtime_start);
16277 logfile_sub_uint (runtime_stop);
16278
16279 logfile_sub_msg ("STOP");
16280
16281 global_free (subid);
16282 }
16283
16284 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16285
16286 if (data.devices_status == STATUS_CRACKED) break;
16287 if (data.devices_status == STATUS_ABORTED) break;
16288 if (data.devices_status == STATUS_QUIT) break;
16289
16290 if (data.devices_status == STATUS_BYPASS)
16291 {
16292 data.devices_status = STATUS_RUNNING;
16293 }
16294 }
16295
16296 // 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
16297
16298 if (attack_mode == ATTACK_MODE_STRAIGHT)
16299 {
16300 if (data.wordlist_mode == WL_MODE_FILE)
16301 {
16302 if (data.dictfile == NULL)
16303 {
16304 if (dictfiles != NULL)
16305 {
16306 data.dictfile = dictfiles[0];
16307
16308 hc_timer_set (&data.timer_running);
16309 }
16310 }
16311 }
16312 }
16313 // NOTE: combi is okay because it is already set beforehand
16314 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16315 {
16316 if (data.dictfile == NULL)
16317 {
16318 if (dictfiles != NULL)
16319 {
16320 hc_timer_set (&data.timer_running);
16321
16322 data.dictfile = dictfiles[0];
16323 }
16324 }
16325 }
16326 else if (attack_mode == ATTACK_MODE_BF)
16327 {
16328 if (data.mask == NULL)
16329 {
16330 hc_timer_set (&data.timer_running);
16331
16332 data.mask = masks[0];
16333 }
16334 }
16335
16336 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16337 {
16338 data.devices_status = STATUS_EXHAUSTED;
16339 }
16340
16341 // if cracked / aborted remove last induction dictionary
16342
16343 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16344 {
16345 struct stat induct_stat;
16346
16347 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16348 {
16349 unlink (induction_dictionaries[file_pos]);
16350 }
16351 }
16352
16353 // wait for non-interactive threads
16354
16355 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16356 {
16357 hc_thread_wait (1, &ni_threads[thread_idx]);
16358 }
16359
16360 local_free (ni_threads);
16361
16362 // wait for interactive threads
16363
16364 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16365 {
16366 hc_thread_wait (1, &i_thread);
16367 }
16368
16369 // we dont need restore file anymore
16370 if (data.restore_disable == 0)
16371 {
16372 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16373 {
16374 unlink (eff_restore_file);
16375 unlink (new_restore_file);
16376 }
16377 else
16378 {
16379 cycle_restore ();
16380 }
16381 }
16382
16383 // finally save left hashes
16384
16385 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16386 {
16387 save_hash ();
16388 }
16389
16390 /**
16391 * Clean up
16392 */
16393
16394 if (benchmark == 1)
16395 {
16396 status_benchmark ();
16397
16398 log_info ("");
16399 }
16400 else
16401 {
16402 if (quiet == 0) clear_prompt ();
16403
16404 if (quiet == 0) log_info ("");
16405
16406 if (status == 1)
16407 {
16408 status_display ();
16409 }
16410 else
16411 {
16412 if (quiet == 0) status_display ();
16413 }
16414
16415 if (quiet == 0) log_info ("");
16416 }
16417
16418 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16419 {
16420 hc_device_param_t *device_param = &data.devices_param[device_id];
16421
16422 local_free (device_param->result);
16423
16424 local_free (device_param->pw_caches);
16425
16426 local_free (device_param->combs_buf);
16427
16428 local_free (device_param->hooks_buf);
16429
16430 local_free (device_param->device_name);
16431
16432 local_free (device_param->device_name_chksum);
16433
16434 local_free (device_param->device_version);
16435
16436 local_free (device_param->driver_version);
16437
16438 if (device_param->pws_buf) myfree (device_param->pws_buf);
16439 if (device_param->d_pws_buf) hc_clReleaseMemObject (device_param->d_pws_buf);
16440 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (device_param->d_pws_amp_buf);
16441 if (device_param->d_rules) hc_clReleaseMemObject (device_param->d_rules);
16442 if (device_param->d_rules_c) hc_clReleaseMemObject (device_param->d_rules_c);
16443 if (device_param->d_combs) hc_clReleaseMemObject (device_param->d_combs);
16444 if (device_param->d_combs_c) hc_clReleaseMemObject (device_param->d_combs_c);
16445 if (device_param->d_bfs) hc_clReleaseMemObject (device_param->d_bfs);
16446 if (device_param->d_bfs_c) hc_clReleaseMemObject (device_param->d_bfs_c);
16447 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (device_param->d_bitmap_s1_a);
16448 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (device_param->d_bitmap_s1_b);
16449 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (device_param->d_bitmap_s1_c);
16450 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (device_param->d_bitmap_s1_d);
16451 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (device_param->d_bitmap_s2_a);
16452 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (device_param->d_bitmap_s2_b);
16453 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (device_param->d_bitmap_s2_c);
16454 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (device_param->d_bitmap_s2_d);
16455 if (device_param->d_plain_bufs) hc_clReleaseMemObject (device_param->d_plain_bufs);
16456 if (device_param->d_digests_buf) hc_clReleaseMemObject (device_param->d_digests_buf);
16457 if (device_param->d_digests_shown) hc_clReleaseMemObject (device_param->d_digests_shown);
16458 if (device_param->d_salt_bufs) hc_clReleaseMemObject (device_param->d_salt_bufs);
16459 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (device_param->d_esalt_bufs);
16460 if (device_param->d_tmps) hc_clReleaseMemObject (device_param->d_tmps);
16461 if (device_param->d_hooks) hc_clReleaseMemObject (device_param->d_hooks);
16462 if (device_param->d_result) hc_clReleaseMemObject (device_param->d_result);
16463 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (device_param->d_scryptV_buf);
16464 if (device_param->d_root_css_buf) hc_clReleaseMemObject (device_param->d_root_css_buf);
16465 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (device_param->d_markov_css_buf);
16466 if (device_param->d_tm_c) hc_clReleaseMemObject (device_param->d_tm_c);
16467
16468 if (device_param->kernel1) hc_clReleaseKernel (device_param->kernel1);
16469 if (device_param->kernel12) hc_clReleaseKernel (device_param->kernel12);
16470 if (device_param->kernel2) hc_clReleaseKernel (device_param->kernel2);
16471 if (device_param->kernel23) hc_clReleaseKernel (device_param->kernel23);
16472 if (device_param->kernel3) hc_clReleaseKernel (device_param->kernel3);
16473 if (device_param->kernel_mp) hc_clReleaseKernel (device_param->kernel_mp);
16474 if (device_param->kernel_mp_l) hc_clReleaseKernel (device_param->kernel_mp_l);
16475 if (device_param->kernel_mp_r) hc_clReleaseKernel (device_param->kernel_mp_r);
16476 if (device_param->kernel_tb) hc_clReleaseKernel (device_param->kernel_tb);
16477 if (device_param->kernel_tm) hc_clReleaseKernel (device_param->kernel_tm);
16478 if (device_param->kernel_amp) hc_clReleaseKernel (device_param->kernel_amp);
16479 if (device_param->kernel_weak) hc_clReleaseKernel (device_param->kernel_weak);
16480
16481 if (device_param->program) hc_clReleaseProgram (device_param->program);
16482 if (device_param->program_mp) hc_clReleaseProgram (device_param->program_mp);
16483 if (device_param->program_amp) hc_clReleaseProgram (device_param->program_amp);
16484 if (device_param->program_weak) hc_clReleaseProgram (device_param->program_weak);
16485
16486 if (device_param->command_queue) hc_clReleaseCommandQueue (device_param->command_queue);
16487 if (device_param->context) hc_clReleaseContext (device_param->context);
16488 }
16489
16490 // reset default fan speed
16491
16492 if (gpu_temp_disable == 0)
16493 {
16494 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16495 {
16496 hc_thread_mutex_lock (mux_adl);
16497
16498 for (uint i = 0; i < data.devices_cnt; i++)
16499 {
16500 if (data.hm_device[i].fan_supported == 1)
16501 {
16502 int fanspeed = temp_retain_fanspeed_value[i];
16503
16504 if (fanspeed == -1) continue;
16505
16506 int rc = hm_set_fanspeed_with_device_id_amd (i, fanspeed);
16507
16508 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", i);
16509 }
16510 }
16511
16512 hc_thread_mutex_unlock (mux_adl);
16513 }
16514 }
16515
16516 // reset power tuning
16517
16518 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16519 {
16520 hc_thread_mutex_lock (mux_adl);
16521
16522 for (uint i = 0; i < data.devices_cnt; i++)
16523 {
16524 if (data.hm_device[i].od_version == 6)
16525 {
16526 // check powertune capabilities first, if not available then skip device
16527
16528 int powertune_supported = 0;
16529
16530 if ((hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll, data.hm_device[i].adapter_index.amd, &powertune_supported)) != ADL_OK)
16531 {
16532 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16533
16534 return (-1);
16535 }
16536
16537 if (powertune_supported != 0)
16538 {
16539 // powercontrol settings
16540
16541 if ((hc_ADL_Overdrive_PowerControl_Set (data.hm_dll, data.hm_device[i].adapter_index.amd, od_power_control_status[i])) != ADL_OK)
16542 {
16543 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16544
16545 return (-1);
16546 }
16547
16548 // clocks
16549
16550 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16551
16552 performance_state->iNumberOfPerformanceLevels = 2;
16553
16554 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[i].state.aLevels[0].iEngineClock;
16555 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[i].state.aLevels[1].iEngineClock;
16556 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[i].state.aLevels[0].iMemoryClock;
16557 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[i].state.aLevels[1].iMemoryClock;
16558
16559 if ((hc_ADL_Overdrive_State_Set (data.hm_dll, data.hm_device[i].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
16560 {
16561 log_info ("ERROR: Failed to restore ADL performance state");
16562
16563 return (-1);
16564 }
16565
16566 local_free (performance_state);
16567 }
16568 }
16569 }
16570
16571 hc_thread_mutex_unlock (mux_adl);
16572 }
16573
16574 if (gpu_temp_disable == 0)
16575 {
16576 if (vendor_id == VENDOR_ID_NV)
16577 {
16578 #ifdef LINUX
16579 hc_NVML_nvmlShutdown (data.hm_dll);
16580 #endif
16581
16582 #ifdef WIN
16583 NvAPI_Unload ();
16584 #endif
16585 }
16586
16587 if (vendor_id == VENDOR_ID_AMD)
16588 {
16589 hc_ADL_Main_Control_Destroy (data.hm_dll);
16590
16591 hm_close (data.hm_dll);
16592 }
16593
16594 #ifdef LINUX
16595 if (vendor_id == VENDOR_ID_NV)
16596 {
16597 hm_close (data.hm_dll);
16598 }
16599 #endif
16600 }
16601
16602 // free memory
16603
16604 local_free (masks);
16605
16606 local_free (dictstat_base);
16607
16608 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16609 {
16610 pot_t *pot_ptr = &pot[pot_pos];
16611
16612 hash_t *hash = &pot_ptr->hash;
16613
16614 local_free (hash->digest);
16615
16616 if (isSalted)
16617 {
16618 local_free (hash->salt);
16619 }
16620 }
16621
16622 local_free (pot);
16623
16624 local_free (all_kernel_rules_cnt);
16625 local_free (all_kernel_rules_buf);
16626
16627 local_free (wl_data->buf);
16628 local_free (wl_data);
16629
16630 local_free (bitmap_s1_a);
16631 local_free (bitmap_s1_b);
16632 local_free (bitmap_s1_c);
16633 local_free (bitmap_s1_d);
16634 local_free (bitmap_s2_a);
16635 local_free (bitmap_s2_b);
16636 local_free (bitmap_s2_c);
16637 local_free (bitmap_s2_d);
16638
16639 local_free (temp_retain_fanspeed_value);
16640 local_free (od_clock_mem_status);
16641 local_free (od_power_control_status);
16642
16643 global_free (devices_param);
16644
16645 global_free (kernel_rules_buf);
16646
16647 global_free (root_css_buf);
16648 global_free (markov_css_buf);
16649
16650 global_free (digests_buf);
16651 global_free (digests_shown);
16652 global_free (digests_shown_tmp);
16653
16654 global_free (salts_buf);
16655 global_free (salts_shown);
16656
16657 global_free (esalts_buf);
16658
16659 global_free (words_progress_done);
16660 global_free (words_progress_rejected);
16661 global_free (words_progress_restored);
16662
16663 if (pot_fp) fclose (pot_fp);
16664
16665 if (data.devices_status == STATUS_QUIT) break;
16666 }
16667
16668 // destroy others mutex
16669
16670 hc_thread_mutex_delete (mux_dispatcher);
16671 hc_thread_mutex_delete (mux_counter);
16672 hc_thread_mutex_delete (mux_display);
16673 hc_thread_mutex_delete (mux_adl);
16674
16675 // free memory
16676
16677 local_free (eff_restore_file);
16678 local_free (new_restore_file);
16679
16680 local_free (rd);
16681
16682 // loopback
16683
16684 local_free (loopback_file);
16685
16686 if (loopback == 1) unlink (loopback_file);
16687
16688 // induction directory
16689
16690 if (induction_dir == NULL)
16691 {
16692 if (attack_mode != ATTACK_MODE_BF)
16693 {
16694 if (rmdir (induction_directory) == -1)
16695 {
16696 if (errno == ENOENT)
16697 {
16698 // good, we can ignore
16699 }
16700 else if (errno == ENOTEMPTY)
16701 {
16702 // good, we can ignore
16703 }
16704 else
16705 {
16706 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
16707
16708 return (-1);
16709 }
16710 }
16711
16712 local_free (induction_directory);
16713 }
16714 }
16715
16716 // outfile-check directory
16717
16718 if (outfile_check_dir == NULL)
16719 {
16720 if (rmdir (outfile_check_directory) == -1)
16721 {
16722 if (errno == ENOENT)
16723 {
16724 // good, we can ignore
16725 }
16726 else if (errno == ENOTEMPTY)
16727 {
16728 // good, we can ignore
16729 }
16730 else
16731 {
16732 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
16733
16734 return (-1);
16735 }
16736 }
16737
16738 local_free (outfile_check_directory);
16739 }
16740
16741 time_t proc_stop;
16742
16743 time (&proc_stop);
16744
16745 logfile_top_uint (proc_start);
16746 logfile_top_uint (proc_stop);
16747
16748 logfile_top_msg ("STOP");
16749
16750 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
16751 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
16752
16753 if (data.devices_status == STATUS_ABORTED) return 2;
16754 if (data.devices_status == STATUS_QUIT) return 2;
16755 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
16756 if (data.devices_status == STATUS_EXHAUSTED) return 1;
16757 if (data.devices_status == STATUS_CRACKED) return 0;
16758
16759 return -1;
16760 }
Hashcat additions to support pwdhash