projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
cosmetic: replace tab by spaces
[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 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
389 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
390 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
391 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
392 " -n, --kernel-accel=NUM Workload tuning: 1, 8, 40, 80, 160",
393 " -u, --kernel-loops=NUM Workload fine-tuning: 8 - 1024",
394 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
395 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
396 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
397 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
398 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
399 "",
400 "* Distributed:",
401 "",
402 " -s, --skip=NUM Skip number of words",
403 " -l, --limit=NUM Limit number of words",
404 " --keyspace Show keyspace base:mod values and quit",
405 "",
406 "* Rules:",
407 "",
408 " -j, --rule-left=RULE Single rule applied to each word from left dict",
409 " -k, --rule-right=RULE Single rule applied to each word from right dict",
410 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
411 " -g, --generate-rules=NUM Generate NUM random rules",
412 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
413 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
414 " --generate-rules-seed=NUM Force RNG seed to NUM",
415 "",
416 "* Custom charsets:",
417 "",
418 " -1, --custom-charset1=CS User-defined charsets",
419 " -2, --custom-charset2=CS Example:",
420 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
421 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
422 "",
423 "* Increment:",
424 "",
425 " -i, --increment Enable increment mode",
426 " --increment-min=NUM Start incrementing at NUM",
427 " --increment-max=NUM Stop incrementing at NUM",
428 "",
429 "==========",
430 "References",
431 "==========",
432 "",
433 "* Workload Profile:",
434 "",
435 " 1 = Reduced performance profile (low latency desktop)",
436 " 2 = Default performance profile",
437 " 3 = Tuned performance profile (high latency desktop)",
438 "",
439 "* Benchmark Settings:",
440 "",
441 " 0 = Manual Tuning",
442 " 1 = Performance Tuning, default",
443 "",
444 "* OpenCL device-types:",
445 "",
446 " 1 = CPU devices",
447 " 2 = GPU devices",
448 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
449 "",
450 "* Outfile Formats:",
451 "",
452 " 1 = hash[:salt]",
453 " 2 = plain",
454 " 3 = hash[:salt]:plain",
455 " 4 = hex_plain",
456 " 5 = hash[:salt]:hex_plain",
457 " 6 = plain:hex_plain",
458 " 7 = hash[:salt]:plain:hex_plain",
459 " 8 = crackpos",
460 " 9 = hash[:salt]:crackpos",
461 " 10 = plain:crackpos",
462 " 11 = hash[:salt]:plain:crackpos",
463 " 12 = hex_plain:crackpos",
464 " 13 = hash[:salt]:hex_plain:crackpos",
465 " 14 = plain:hex_plain:crackpos",
466 " 15 = hash[:salt]:plain:hex_plain:crackpos",
467 "",
468 "* Debug mode output formats (for hybrid mode only, by using rules):",
469 "",
470 " 1 = save finding rule",
471 " 2 = save original word",
472 " 3 = save original word and finding rule",
473 " 4 = save original word, finding rule and modified plain",
474 "",
475 "* Built-in charsets:",
476 "",
477 " ?l = abcdefghijklmnopqrstuvwxyz",
478 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
479 " ?d = 0123456789",
480 " ?s = !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~",
481 " ?a = ?l?u?d?s",
482 " ?b = 0x00 - 0xff",
483 "",
484 "* Attack modes:",
485 "",
486 " 0 = Straight",
487 " 1 = Combination",
488 " 3 = Brute-force",
489 " 6 = Hybrid dict + mask",
490 " 7 = Hybrid mask + dict",
491 "",
492 "* Hash types:",
493 "",
494 "[[ Roll-your-own: Raw Hashes ]]",
495 "",
496 " 900 = MD4",
497 " 0 = MD5",
498 " 5100 = Half MD5",
499 " 100 = SHA1",
500 " 10800 = SHA-384",
501 " 1400 = SHA-256",
502 " 1700 = SHA-512",
503 " 5000 = SHA-3(Keccak)",
504 " 10100 = SipHash",
505 " 6000 = RipeMD160",
506 " 6100 = Whirlpool",
507 " 6900 = GOST R 34.11-94",
508 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
509 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
510 "",
511 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
512 "",
513 " 10 = md5($pass.$salt)",
514 " 20 = md5($salt.$pass)",
515 " 30 = md5(unicode($pass).$salt)",
516 " 40 = md5($salt.unicode($pass))",
517 " 3800 = md5($salt.$pass.$salt)",
518 " 3710 = md5($salt.md5($pass))",
519 " 2600 = md5(md5($pass)",
520 " 4300 = md5(strtoupper(md5($pass)))",
521 " 4400 = md5(sha1($pass))",
522 " 110 = sha1($pass.$salt)",
523 " 120 = sha1($salt.$pass)",
524 " 130 = sha1(unicode($pass).$salt)",
525 " 140 = sha1($salt.unicode($pass))",
526 " 4500 = sha1(sha1($pass)",
527 " 4700 = sha1(md5($pass))",
528 " 4900 = sha1($salt.$pass.$salt)",
529 " 1410 = sha256($pass.$salt)",
530 " 1420 = sha256($salt.$pass)",
531 " 1430 = sha256(unicode($pass).$salt)",
532 " 1440 = sha256($salt.unicode($pass))",
533 " 1710 = sha512($pass.$salt)",
534 " 1720 = sha512($salt.$pass)",
535 " 1730 = sha512(unicode($pass).$salt)",
536 " 1740 = sha512($salt.unicode($pass))",
537 "",
538 "[[ Roll-your-own: Authenticated Hashes ]]",
539 "",
540 " 50 = HMAC-MD5 (key = $pass)",
541 " 60 = HMAC-MD5 (key = $salt)",
542 " 150 = HMAC-SHA1 (key = $pass)",
543 " 160 = HMAC-SHA1 (key = $salt)",
544 " 1450 = HMAC-SHA256 (key = $pass)",
545 " 1460 = HMAC-SHA256 (key = $salt)",
546 " 1750 = HMAC-SHA512 (key = $pass)",
547 " 1760 = HMAC-SHA512 (key = $salt)",
548 "",
549 "[[ Generic KDF ]]",
550 "",
551 " 400 = phpass",
552 " 8900 = scrypt",
553 " 11900 = PBKDF2-HMAC-MD5",
554 " 12000 = PBKDF2-HMAC-SHA1",
555 " 10900 = PBKDF2-HMAC-SHA256",
556 " 12100 = PBKDF2-HMAC-SHA512",
557 "",
558 "[[ Network protocols, Challenge-Response ]]",
559 "",
560 " 23 = Skype",
561 " 2500 = WPA/WPA2",
562 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
563 " 5300 = IKE-PSK MD5",
564 " 5400 = IKE-PSK SHA1",
565 " 5500 = NetNTLMv1",
566 " 5500 = NetNTLMv1 + ESS",
567 " 5600 = NetNTLMv2",
568 " 7300 = IPMI2 RAKP HMAC-SHA1",
569 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
570 " 8300 = DNSSEC (NSEC3)",
571 " 10200 = Cram MD5",
572 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
573 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
574 " 11400 = SIP digest authentication (MD5)",
575 "",
576 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
577 "",
578 " 121 = SMF (Simple Machines Forum)",
579 " 400 = phpBB3",
580 " 2611 = vBulletin < v3.8.5",
581 " 2711 = vBulletin > v3.8.5",
582 " 2811 = MyBB",
583 " 2811 = IPB (Invison Power Board)",
584 " 8400 = WBB3 (Woltlab Burning Board)",
585 " 11 = Joomla < 2.5.18",
586 " 400 = Joomla > 2.5.18",
587 " 400 = Wordpress",
588 " 2612 = PHPS",
589 " 7900 = Drupal7",
590 " 21 = osCommerce",
591 " 21 = xt:Commerce",
592 " 11000 = PrestaShop",
593 " 124 = Django (SHA-1)",
594 " 10000 = Django (PBKDF2-SHA256)",
595 " 3711 = Mediawiki B type",
596 " 7600 = Redmine",
597 "",
598 "[[ Database Server ]]",
599 "",
600 " 12 = PostgreSQL",
601 " 131 = MSSQL(2000)",
602 " 132 = MSSQL(2005)",
603 " 1731 = MSSQL(2012)",
604 " 1731 = MSSQL(2014)",
605 " 200 = MySQL323",
606 " 300 = MySQL4.1/MySQL5",
607 " 3100 = Oracle H: Type (Oracle 7+)",
608 " 112 = Oracle S: Type (Oracle 11+)",
609 " 12300 = Oracle T: Type (Oracle 12+)",
610 " 8000 = Sybase ASE",
611 "",
612 "[[ HTTP, SMTP, LDAP Server ]]",
613 "",
614 " 141 = EPiServer 6.x < v4",
615 " 1441 = EPiServer 6.x > v4",
616 " 1600 = Apache $apr1$",
617 " 12600 = ColdFusion 10+",
618 " 1421 = hMailServer",
619 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
620 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
621 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
622 "",
623 "[[ Checksums ]]",
624 "",
625 " 11500 = CRC32",
626 "",
627 "[[ Operating-Systems ]]",
628 "",
629 " 3000 = LM",
630 " 1000 = NTLM",
631 " 1100 = Domain Cached Credentials (DCC), MS Cache",
632 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
633 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
634 " 1500 = descrypt, DES(Unix), Traditional DES",
635 " 12400 = BSDiCrypt, Extended DES",
636 " 500 = md5crypt $1$, MD5(Unix)",
637 " 3200 = bcrypt $2*$, Blowfish(Unix)",
638 " 7400 = sha256crypt $5$, SHA256(Unix)",
639 " 1800 = sha512crypt $6$, SHA512(Unix)",
640 " 122 = OSX v10.4",
641 " 122 = OSX v10.5",
642 " 122 = OSX v10.6",
643 " 1722 = OSX v10.7",
644 " 7100 = OSX v10.8",
645 " 7100 = OSX v10.9",
646 " 7100 = OSX v10.10",
647 " 6300 = AIX {smd5}",
648 " 6700 = AIX {ssha1}",
649 " 6400 = AIX {ssha256}",
650 " 6500 = AIX {ssha512}",
651 " 2400 = Cisco-PIX",
652 " 2410 = Cisco-ASA",
653 " 500 = Cisco-IOS $1$",
654 " 5700 = Cisco-IOS $4$",
655 " 9200 = Cisco-IOS $8$",
656 " 9300 = Cisco-IOS $9$",
657 " 22 = Juniper Netscreen/SSG (ScreenOS)",
658 " 501 = Juniper IVE",
659 " 5800 = Android PIN",
660 " 8100 = Citrix Netscaler",
661 " 8500 = RACF",
662 " 7200 = GRUB 2",
663 " 9900 = Radmin2",
664 "",
665 "[[ Enterprise Application Software (EAS) ]]",
666 "",
667 " 7700 = SAP CODVN B (BCODE)",
668 " 7800 = SAP CODVN F/G (PASSCODE)",
669 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
670 " 8600 = Lotus Notes/Domino 5",
671 " 8700 = Lotus Notes/Domino 6",
672 " 9100 = Lotus Notes/Domino 8",
673 " 133 = PeopleSoft",
674 "",
675 "[[ Archives ]]",
676 "",
677 " 11600 = 7-Zip",
678 " 12500 = RAR3-hp",
679 " 13000 = RAR5",
680 "",
681 "[[ Full-Disk encryptions (FDE) ]]",
682 "",
683 " 62XY = TrueCrypt 5.0+",
684 " X = 1 = PBKDF2-HMAC-RipeMD160",
685 " X = 2 = PBKDF2-HMAC-SHA512",
686 " X = 3 = PBKDF2-HMAC-Whirlpool",
687 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
688 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
689 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
690 " Y = 3 = XTS 1536 bit (Ciphers: All)",
691 " 8800 = Android FDE < v4.3",
692 " 12900 = Android FDE (Samsung DEK)",
693 " 12200 = eCryptfs",
694 "",
695 "[[ Documents ]]",
696 "",
697 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
698 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
699 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
700 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
701 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
702 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
703 " 9400 = MS Office 2007",
704 " 9500 = MS Office 2010",
705 " 9600 = MS Office 2013",
706 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
707 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
708 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
709 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
710 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
711 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
712 "",
713 "[[ Password Managers ]]",
714 "",
715 " 9000 = Password Safe v2",
716 " 5200 = Password Safe v3",
717 " 6800 = Lastpass",
718 " 6600 = 1Password, agilekeychain",
719 " 8200 = 1Password, cloudkeychain",
720 " 11300 = Bitcoin/Litecoin wallet.dat",
721 " 12700 = Blockchain, My Wallet",
722 "",
723 NULL
724 };
725
726 /**
727 * oclHashcat specific functions
728 */
729
730 void status_display_automat ()
731 {
732 FILE *out = stdout;
733
734 fprintf (out, "STATUS\t%u\t", data.devices_status);
735
736 /**
737 * speed new
738 */
739
740 fprintf (out, "SPEED\t");
741
742 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
743 {
744 hc_device_param_t *device_param = &data.devices_param[device_id];
745
746 uint64_t speed_cnt = 0;
747 float speed_ms = 0;
748
749 for (int i = 0; i < SPEED_CACHE; i++)
750 {
751 float rec_ms;
752
753 hc_timer_get (device_param->speed_rec[i], rec_ms);
754
755 if (rec_ms > SPEED_MAXAGE) continue;
756
757 speed_cnt += device_param->speed_cnt[i];
758 speed_ms += device_param->speed_ms[i];
759 }
760
761 speed_cnt /= SPEED_CACHE;
762 speed_ms /= SPEED_CACHE;
763
764 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
765 }
766
767 /**
768 * words_cur
769 */
770
771 uint64_t words_cur = get_lowest_words_done ();
772
773 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
774
775 /**
776 * counter
777 */
778
779 uint salts_left = data.salts_cnt - data.salts_done;
780
781 if (salts_left == 0) salts_left = 1;
782
783 uint64_t progress_total = data.words_cnt * salts_left;
784
785 uint64_t all_done = 0;
786 uint64_t all_rejected = 0;
787 uint64_t all_restored = 0;
788
789 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
790 {
791 if (salts_left > 1)
792 {
793 // otherwise the final cracked status shows 0/XXX progress
794
795 if (data.salts_shown[salt_pos] == 1) continue;
796 }
797
798 all_done += data.words_progress_done[salt_pos];
799 all_rejected += data.words_progress_rejected[salt_pos];
800 all_restored += data.words_progress_restored[salt_pos];
801 }
802
803 uint64_t progress_cur = all_restored + all_done + all_rejected;
804 uint64_t progress_end = progress_total;
805
806 uint64_t progress_skip = 0;
807
808 if (data.skip)
809 {
810 progress_skip = MIN (data.skip, data.words_base) * salts_left;
811
812 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
813 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
814 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
815 }
816
817 if (data.limit)
818 {
819 progress_end = MIN (data.limit, data.words_base) * salts_left;
820
821 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
822 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
823 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
824 }
825
826 uint64_t progress_cur_relative_skip = progress_cur - progress_skip;
827 uint64_t progress_end_relative_skip = progress_end - progress_skip;
828
829 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
830
831 /**
832 * cracks
833 */
834
835 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
836 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
837
838 /**
839 * temperature
840 */
841
842 if (data.gpu_temp_disable == 0)
843 {
844 fprintf (out, "TEMP\t");
845
846 hc_thread_mutex_lock (mux_adl);
847
848 for (uint i = 0; i < data.devices_cnt; i++)
849 {
850 int temp = hm_get_temperature_with_device_id (i);
851
852 fprintf (out, "%d\t", temp);
853 }
854
855 hc_thread_mutex_unlock (mux_adl);
856 }
857
858 #ifdef _WIN
859 fputc ('\r', out);
860 fputc ('\n', out);
861 #endif
862
863 #ifdef _POSIX
864 fputc ('\n', out);
865 #endif
866
867 fflush (out);
868 }
869
870 void status_display ()
871 {
872 if (data.devices_status == STATUS_INIT) return;
873 if (data.devices_status == STATUS_STARTING) return;
874 if (data.devices_status == STATUS_BYPASS) return;
875
876 if (data.status_automat == 1)
877 {
878 status_display_automat ();
879
880 return;
881 }
882
883 char tmp_buf[1000];
884
885 uint tmp_len = 0;
886
887 log_info ("Session.Name...: %s", data.session);
888
889 char *status_type = strstatus (data.devices_status);
890
891 uint hash_mode = data.hash_mode;
892
893 char *hash_type = strhashtype (hash_mode); // not a bug
894
895 log_info ("Status.........: %s", status_type);
896
897 /**
898 * show rules
899 */
900
901 if (data.rp_files_cnt)
902 {
903 uint i;
904
905 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
906 {
907 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
908 }
909
910 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
911
912 log_info ("Rules.Type.....: %s", tmp_buf);
913
914 tmp_len = 0;
915 }
916
917 if (data.rp_gen)
918 {
919 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
920
921 if (data.rp_gen_seed)
922 {
923 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
924 }
925 }
926
927 /**
928 * show input
929 */
930
931 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
932 {
933 if (data.wordlist_mode == WL_MODE_FILE)
934 {
935 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
936 }
937 else if (data.wordlist_mode == WL_MODE_STDIN)
938 {
939 log_info ("Input.Mode.....: Pipe");
940 }
941 }
942 else if (data.attack_mode == ATTACK_MODE_COMBI)
943 {
944 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
945 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
946 }
947 else if (data.attack_mode == ATTACK_MODE_BF)
948 {
949 char *mask = data.mask;
950
951 if (mask != NULL)
952 {
953 uint mask_len = data.css_cnt;
954
955 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
956
957 if (mask_len > 0)
958 {
959 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
960 {
961 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
962 {
963 mask_len -= data.salts_buf[0].salt_len;
964 }
965 }
966
967 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
968
969 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
970 }
971
972 if (data.maskcnt > 1)
973 {
974 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
975
976 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
977 }
978
979 log_info ("Input.Mode.....: %s", tmp_buf);
980 }
981
982 tmp_len = 0;
983 }
984 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
985 {
986 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
987 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
988 }
989 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
990 {
991 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
992 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
993 }
994
995 if (data.digests_cnt == 1)
996 {
997 if (data.hash_mode == 2500)
998 {
999 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1000
1001 uint pke[25];
1002
1003 char *pke_ptr = (char *) pke;
1004
1005 for (uint i = 0; i < 25; i++)
1006 {
1007 pke[i] = byte_swap_32 (wpa->pke[i]);
1008 }
1009
1010 char mac1[6];
1011 char mac2[6];
1012
1013 memcpy (mac1, pke_ptr + 23, 6);
1014 memcpy (mac2, pke_ptr + 29, 6);
1015
1016 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1017 (char *) data.salts_buf[0].salt_buf,
1018 mac1[0] & 0xff,
1019 mac1[1] & 0xff,
1020 mac1[2] & 0xff,
1021 mac1[3] & 0xff,
1022 mac1[4] & 0xff,
1023 mac1[5] & 0xff,
1024 mac2[0] & 0xff,
1025 mac2[1] & 0xff,
1026 mac2[2] & 0xff,
1027 mac2[3] & 0xff,
1028 mac2[4] & 0xff,
1029 mac2[5] & 0xff);
1030 }
1031 else if (data.hash_mode == 5200)
1032 {
1033 log_info ("Hash.Target....: File (%s)", data.hashfile);
1034 }
1035 else if (data.hash_mode == 9000)
1036 {
1037 log_info ("Hash.Target....: File (%s)", data.hashfile);
1038 }
1039 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1040 {
1041 log_info ("Hash.Target....: File (%s)", data.hashfile);
1042 }
1043 else
1044 {
1045 char out_buf[4096];
1046
1047 ascii_digest (out_buf, 0, 0);
1048
1049 // limit length
1050 if (strlen (out_buf) > 40)
1051 {
1052 out_buf[41] = '.';
1053 out_buf[42] = '.';
1054 out_buf[43] = '.';
1055 out_buf[44] = 0;
1056 }
1057
1058 log_info ("Hash.Target....: %s", out_buf);
1059 }
1060 }
1061 else
1062 {
1063 if (data.hash_mode == 3000)
1064 {
1065 char out_buf1[4096];
1066 char out_buf2[4096];
1067
1068 ascii_digest (out_buf1, 0, 0);
1069 ascii_digest (out_buf2, 0, 1);
1070
1071 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1072 }
1073 else
1074 {
1075 log_info ("Hash.Target....: File (%s)", data.hashfile);
1076 }
1077 }
1078
1079 log_info ("Hash.Type......: %s", hash_type);
1080
1081 /**
1082 * speed new
1083 */
1084
1085 uint64_t speed_cnt[DEVICES_MAX];
1086 float speed_ms[DEVICES_MAX];
1087
1088 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1089 {
1090 hc_device_param_t *device_param = &data.devices_param[device_id];
1091
1092 // we need to clear values (set to 0) because in case the device does
1093 // not get new candidates it idles around but speed display would
1094 // show it as working.
1095 // if we instantly set it to 0 after reading it happens that the
1096 // speed can be shown as zero if the users refreshs to fast.
1097 // therefore, we add a timestamp when a stat was recorded and if its
1098 // to old we will not use it
1099
1100 speed_cnt[device_id] = 0;
1101 speed_ms[device_id] = 0;
1102
1103 for (int i = 0; i < SPEED_CACHE; i++)
1104 {
1105 float rec_ms;
1106
1107 hc_timer_get (device_param->speed_rec[i], rec_ms);
1108
1109 if (rec_ms > SPEED_MAXAGE) continue;
1110
1111 speed_cnt[device_id] += device_param->speed_cnt[i];
1112 speed_ms[device_id] += device_param->speed_ms[i];
1113 }
1114
1115 speed_cnt[device_id] /= SPEED_CACHE;
1116 speed_ms[device_id] /= SPEED_CACHE;
1117 }
1118
1119 float hashes_all_ms = 0;
1120
1121 float hashes_dev_ms[DEVICES_MAX];
1122
1123 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1124 {
1125 hashes_dev_ms[device_id] = 0;
1126
1127 if (speed_ms[device_id])
1128 {
1129 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1130
1131 hashes_all_ms += hashes_dev_ms[device_id];
1132 }
1133 }
1134
1135 /**
1136 * timers
1137 */
1138
1139 float ms_running = 0;
1140
1141 hc_timer_get (data.timer_running, ms_running);
1142
1143 float ms_paused = data.ms_paused;
1144
1145 if (data.devices_status == STATUS_PAUSED)
1146 {
1147 float ms_paused_tmp = 0;
1148
1149 hc_timer_get (data.timer_paused, ms_paused_tmp);
1150
1151 ms_paused += ms_paused_tmp;
1152 }
1153
1154 #ifdef WIN
1155
1156 __time64_t sec_run = ms_running / 1000;
1157
1158 #else
1159
1160 time_t sec_run = ms_running / 1000;
1161
1162 #endif
1163
1164 if (sec_run)
1165 {
1166 char display_run[32];
1167
1168 struct tm tm_run;
1169
1170 struct tm *tmp;
1171
1172 #ifdef WIN
1173
1174 tmp = _gmtime64 (&sec_run);
1175
1176 #else
1177
1178 tmp = gmtime (&sec_run);
1179
1180 #endif
1181
1182 if (tmp != NULL)
1183 {
1184 memcpy (&tm_run, tmp, sizeof (struct tm));
1185
1186 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1187
1188 char *start = ctime (&data.proc_start);
1189
1190 size_t start_len = strlen (start);
1191
1192 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1193 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1194
1195 log_info ("Time.Started...: %s (%s)", start, display_run);
1196 }
1197 }
1198 else
1199 {
1200 log_info ("Time.Started...: 0 secs");
1201 }
1202
1203 /**
1204 * counters
1205 */
1206
1207 uint salts_left = data.salts_cnt - data.salts_done;
1208
1209 if (salts_left == 0) salts_left = 1;
1210
1211 uint64_t progress_total = data.words_cnt * salts_left;
1212
1213 uint64_t all_done = 0;
1214 uint64_t all_rejected = 0;
1215 uint64_t all_restored = 0;
1216
1217 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1218 {
1219 if (salts_left > 1)
1220 {
1221 // otherwise the final cracked status shows 0/XXX progress
1222
1223 if (data.salts_shown[salt_pos] == 1) continue;
1224 }
1225
1226 all_done += data.words_progress_done[salt_pos];
1227 all_rejected += data.words_progress_rejected[salt_pos];
1228 all_restored += data.words_progress_restored[salt_pos];
1229 }
1230
1231 uint64_t progress_cur = all_restored + all_done + all_rejected;
1232 uint64_t progress_end = progress_total;
1233
1234 uint64_t progress_skip = 0;
1235
1236 if (data.skip)
1237 {
1238 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1239
1240 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1241 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1242 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1243 }
1244
1245 if (data.limit)
1246 {
1247 progress_end = MIN (data.limit, data.words_base) * salts_left;
1248
1249 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1250 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1251 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1252 }
1253
1254 uint64_t progress_cur_relative_skip = progress_cur - progress_skip;
1255 uint64_t progress_end_relative_skip = progress_end - progress_skip;
1256
1257 float speed_ms_real = ms_running - ms_paused;
1258 uint64_t speed_plains_real = all_done;
1259
1260 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1261 {
1262 if (data.devices_status != STATUS_CRACKED)
1263 {
1264 uint64_t words_per_ms = 0;
1265
1266 if (speed_plains_real && speed_ms_real)
1267 {
1268 words_per_ms = speed_plains_real / speed_ms_real;
1269 }
1270
1271 #ifdef WIN
1272 __time64_t sec_etc = 0;
1273 #else
1274 time_t sec_etc = 0;
1275 #endif
1276
1277 if (words_per_ms)
1278 {
1279 uint64_t progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1280
1281 uint64_t ms_left = progress_left_relative_skip / words_per_ms;
1282
1283 sec_etc = ms_left / 1000;
1284 }
1285
1286 if (sec_etc == 0)
1287 {
1288 log_info ("Time.Estimated.: 0 secs");
1289 }
1290 else if ((uint64_t) sec_etc > ETC_MAX)
1291 {
1292 log_info ("Time.Estimated.: > 10 Years");
1293 }
1294 else
1295 {
1296 char display_etc[32];
1297
1298 struct tm tm_etc;
1299
1300 struct tm *tmp;
1301
1302 #ifdef WIN
1303
1304 tmp = _gmtime64 (&sec_etc);
1305
1306 #else
1307
1308 tmp = gmtime (&sec_etc);
1309
1310 #endif
1311
1312 if (tmp != NULL)
1313 {
1314 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1315
1316 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1317
1318 time_t now;
1319
1320 time (&now);
1321
1322 now += sec_etc;
1323
1324 char *etc = ctime (&now);
1325
1326 size_t etc_len = strlen (etc);
1327
1328 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1329 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1330
1331 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1332 }
1333 }
1334 }
1335 }
1336
1337 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1338 {
1339 char display_dev_cur[16];
1340
1341 memset (display_dev_cur, 0, sizeof (display_dev_cur));
1342
1343 strncpy (display_dev_cur, "0.00", 4);
1344
1345 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1346
1347 log_info ("Speed.Dev.#%d...: %9sH/s", device_id + 1, display_dev_cur);
1348 }
1349
1350 char display_all_cur[16];
1351
1352 memset (display_all_cur, 0, sizeof (display_all_cur));
1353
1354 strncpy (display_all_cur, "0.00", 4);
1355
1356 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1357
1358 if (data.devices_cnt > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1359
1360 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1361 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1362
1363 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);
1364
1365 // crack-per-time
1366
1367 if (data.digests_cnt > 100)
1368 {
1369 time_t now = time (NULL);
1370
1371 int cpt_cur_min = 0;
1372 int cpt_cur_hour = 0;
1373 int cpt_cur_day = 0;
1374
1375 for (int i = 0; i < CPT_BUF; i++)
1376 {
1377 const uint cracked = data.cpt_buf[i].cracked;
1378 const time_t timestamp = data.cpt_buf[i].timestamp;
1379
1380 if ((timestamp + 60) > now)
1381 {
1382 cpt_cur_min += cracked;
1383 }
1384
1385 if ((timestamp + 3600) > now)
1386 {
1387 cpt_cur_hour += cracked;
1388 }
1389
1390 if ((timestamp + 86400) > now)
1391 {
1392 cpt_cur_day += cracked;
1393 }
1394 }
1395
1396 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1397 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1398 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1399
1400 if ((data.cpt_start + 86400) < now)
1401 {
1402 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1403 cpt_cur_min,
1404 cpt_cur_hour,
1405 cpt_cur_day,
1406 cpt_avg_min,
1407 cpt_avg_hour,
1408 cpt_avg_day);
1409 }
1410 else if ((data.cpt_start + 3600) < now)
1411 {
1412 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1413 cpt_cur_min,
1414 cpt_cur_hour,
1415 cpt_avg_min,
1416 cpt_avg_hour,
1417 cpt_avg_day);
1418 }
1419 else if ((data.cpt_start + 60) < now)
1420 {
1421 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1422 cpt_cur_min,
1423 cpt_avg_min,
1424 cpt_avg_hour,
1425 cpt_avg_day);
1426 }
1427 else
1428 {
1429 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1430 cpt_avg_min,
1431 cpt_avg_hour,
1432 cpt_avg_day);
1433 }
1434 }
1435
1436 // Restore point
1437
1438 uint64_t restore_point = get_lowest_words_done ();
1439
1440 uint64_t restore_total = data.words_base;
1441
1442 float percent_restore = 0;
1443
1444 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1445
1446 if (progress_end_relative_skip)
1447 {
1448 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1449 {
1450 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1451 float percent_rejected = 0.0;
1452
1453 if (progress_cur)
1454 {
1455 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1456 }
1457
1458 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);
1459 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1460
1461 if (data.restore_disable == 0)
1462 {
1463 if (percent_finished != 1)
1464 {
1465 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1466 }
1467 }
1468 }
1469 }
1470 else
1471 {
1472 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1473 {
1474 log_info ("Progress.......: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1475 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1476
1477 if (data.restore_disable == 0)
1478 {
1479 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1480 }
1481 }
1482 else
1483 {
1484 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1485 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1486
1487 // --restore not allowed if stdin is used -- really? why?
1488
1489 //if (data.restore_disable == 0)
1490 //{
1491 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1492 //}
1493 }
1494 }
1495
1496 if (data.gpu_temp_disable == 0)
1497 {
1498 hc_thread_mutex_lock (mux_adl);
1499
1500 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1501 {
1502 hc_device_param_t *device_param = &data.devices_param[device_id];
1503
1504 #define HM_STR_BUF_SIZE 255
1505
1506 if (data.hm_device[device_id].fan_supported == 1)
1507 {
1508 char utilization[HM_STR_BUF_SIZE];
1509 char temperature[HM_STR_BUF_SIZE];
1510 char fanspeed[HM_STR_BUF_SIZE];
1511
1512 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1513 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1514
1515 if (device_param->vendor_id == VENDOR_ID_AMD)
1516 {
1517 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1518 }
1519 else if (device_param->vendor_id == VENDOR_ID_NV)
1520 {
1521 #ifdef LINUX
1522 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1523 #else
1524 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "rpm", hm_get_fanspeed_with_device_id (device_id));
1525 #endif
1526 }
1527
1528 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1529 }
1530 else
1531 {
1532 char utilization[HM_STR_BUF_SIZE];
1533 char temperature[HM_STR_BUF_SIZE];
1534
1535 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1536 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1537
1538 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1539 }
1540 }
1541
1542 hc_thread_mutex_unlock (mux_adl);
1543 }
1544 }
1545
1546 static void status_benchmark ()
1547 {
1548 if (data.devices_status == STATUS_INIT) return;
1549 if (data.devices_status == STATUS_STARTING) return;
1550
1551 if (data.words_cnt == 0) return;
1552
1553 uint64_t speed_cnt[DEVICES_MAX];
1554 float speed_ms[DEVICES_MAX];
1555
1556 uint device_id;
1557
1558 for (device_id = 0; device_id < data.devices_cnt; device_id++)
1559 {
1560 hc_device_param_t *device_param = &data.devices_param[device_id];
1561
1562 speed_cnt[device_id] = 0;
1563 speed_ms[device_id] = 0;
1564
1565 for (int i = 0; i < SPEED_CACHE; i++)
1566 {
1567 speed_cnt[device_id] += device_param->speed_cnt[i];
1568 speed_ms[device_id] += device_param->speed_ms[i];
1569 }
1570
1571 speed_cnt[device_id] /= SPEED_CACHE;
1572 speed_ms[device_id] /= SPEED_CACHE;
1573 }
1574
1575 float hashes_all_ms = 0;
1576
1577 float hashes_dev_ms[DEVICES_MAX];
1578
1579 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1580 {
1581 hashes_dev_ms[device_id] = 0;
1582
1583 if (speed_ms[device_id])
1584 {
1585 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1586
1587 hashes_all_ms += hashes_dev_ms[device_id];
1588 }
1589 }
1590
1591 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1592 {
1593 char display_dev_cur[16];
1594
1595 memset (display_dev_cur, 0, sizeof (display_dev_cur));
1596
1597 strncpy (display_dev_cur, "0.00", 4);
1598
1599 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1600
1601 log_info ("Speed.Dev.#%d.: %9sH/s", device_id + 1, display_dev_cur);
1602 }
1603
1604 char display_all_cur[16];
1605
1606 memset (display_all_cur, 0, sizeof (display_all_cur));
1607
1608 strncpy (display_all_cur, "0.00", 4);
1609
1610 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1611
1612 if (data.devices_cnt > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1613 }
1614
1615 /**
1616 * oclHashcat -only- functions
1617 */
1618
1619 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1620 {
1621 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1622 {
1623 if (attack_kern == ATTACK_KERN_STRAIGHT)
1624 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1625 else if (attack_kern == ATTACK_KERN_COMBI)
1626 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1627 else if (attack_kern == ATTACK_KERN_BF)
1628 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1629 }
1630 else
1631 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1632 }
1633
1634 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, char *cached_file)
1635 {
1636 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1637 {
1638 if (attack_kern == ATTACK_KERN_STRAIGHT)
1639 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1640 else if (attack_kern == ATTACK_KERN_COMBI)
1641 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1642 else if (attack_kern == ATTACK_KERN_BF)
1643 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1644 }
1645 else
1646 {
1647 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1648 }
1649 }
1650
1651 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1652 {
1653 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1654 {
1655 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1656 }
1657 else
1658 {
1659 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1660 }
1661 }
1662
1663 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, char *device_name_chksum, char *cached_file)
1664 {
1665 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1666 {
1667 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1668 }
1669 else
1670 {
1671 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1672 }
1673 }
1674
1675 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1676 {
1677 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1678 }
1679
1680 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, char *device_name_chksum, char *cached_file)
1681 {
1682 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1683 }
1684
1685 static uint convert_from_hex (char *line_buf, const uint line_len)
1686 {
1687 if (line_len & 1) return (line_len); // not in hex
1688
1689 if (data.hex_wordlist == 1)
1690 {
1691 uint i;
1692 uint j;
1693
1694 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1695 {
1696 line_buf[i] = hex_to_char (&line_buf[j]);
1697 }
1698
1699 memset (line_buf + i, 0, line_len - i);
1700
1701 return (i);
1702 }
1703 else if (line_len >= 6) // $HEX[] = 6
1704 {
1705 if (line_buf[0] != '$') return (line_len);
1706 if (line_buf[1] != 'H') return (line_len);
1707 if (line_buf[2] != 'E') return (line_len);
1708 if (line_buf[3] != 'X') return (line_len);
1709 if (line_buf[4] != '[') return (line_len);
1710 if (line_buf[line_len - 1] != ']') return (line_len);
1711
1712 uint i;
1713 uint j;
1714
1715 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1716 {
1717 line_buf[i] = hex_to_char (&line_buf[j]);
1718 }
1719
1720 memset (line_buf + i, 0, line_len - i);
1721
1722 return (i);
1723 }
1724
1725 return (line_len);
1726 }
1727
1728 static uint count_lines (FILE *fd)
1729 {
1730 uint cnt = 0;
1731
1732 char *buf = (char *) mymalloc (BUFSIZ);
1733
1734 size_t nread_tmp = 0;
1735
1736 char *ptr = buf;
1737
1738 while (!feof (fd))
1739 {
1740 size_t nread = fread (buf, sizeof (char), BUFSIZ, fd);
1741 nread_tmp = nread;
1742
1743 if (nread < 1) continue;
1744
1745 ptr = buf;
1746
1747 do
1748 {
1749 if (*ptr++ == '\n') cnt++;
1750
1751 } while (nread--);
1752 }
1753
1754 // special case (if last line did not contain a newline char ... at the very end of the file)
1755
1756 if (nread_tmp > 3)
1757 {
1758 ptr -= 2;
1759
1760 if (*ptr != '\n')
1761 {
1762 ptr--;
1763
1764 if (*ptr != '\n') // needed ? different on windows systems?
1765 {
1766 cnt++;
1767 }
1768 }
1769 }
1770
1771 myfree (buf);
1772
1773 return cnt;
1774 }
1775
1776 static void clear_prompt ()
1777 {
1778 fputc ('\r', stdout);
1779
1780 for (size_t i = 0; i < strlen (PROMPT); i++)
1781 {
1782 fputc (' ', stdout);
1783 }
1784
1785 fputc ('\r', stdout);
1786
1787 fflush (stdout);
1788 }
1789
1790 static void gidd_to_pw_t (hc_device_param_t *device_param, const uint64_t gidd, pw_t *pw)
1791 {
1792 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1793 }
1794
1795 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1796 {
1797 char *outfile = data.outfile;
1798 uint quiet = data.quiet;
1799 FILE *pot_fp = data.pot_fp;
1800 uint loopback = data.loopback;
1801 uint debug_mode = data.debug_mode;
1802 char *debug_file = data.debug_file;
1803
1804 char debug_rule_buf[BLOCK_SIZE];
1805 int debug_rule_len = 0; // -1 error
1806 uint debug_plain_len = 0;
1807
1808 unsigned char debug_plain_ptr[BLOCK_SIZE];
1809
1810 // hash
1811
1812 char out_buf[4096]; memset (out_buf, 0, sizeof (out_buf));
1813
1814 ascii_digest (out_buf, salt_pos, digest_pos);
1815
1816 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1817
1818 // plain
1819
1820 plain_t plain;
1821
1822 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, idx * sizeof (plain_t), sizeof (plain_t), &plain, 0, NULL, NULL);
1823
1824 uint gidvid = plain.gidvid;
1825 uint il_pos = plain.il_pos;
1826
1827 uint64_t crackpos = device_param->words_off;
1828
1829 uint plain_buf[16];
1830
1831 unsigned char *plain_ptr = (unsigned char *) plain_buf;
1832 unsigned int plain_len = 0;
1833
1834 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1835 {
1836 uint64_t gidd = gidvid;
1837 uint64_t gidm = 0;
1838
1839 pw_t pw;
1840
1841 gidd_to_pw_t (device_param, gidd, &pw);
1842
1843 for (int i = 0, j = gidm; i < 16; i++, j++)
1844 {
1845 plain_buf[i] = pw.hi1[0][j];
1846 }
1847
1848 plain_len = pw.pw_len;
1849
1850 const uint off = device_param->innerloop_pos + il_pos;
1851
1852 if (debug_mode > 0)
1853 {
1854 debug_rule_len = 0;
1855
1856 // save rule
1857 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1858 {
1859 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1860
1861 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1862 }
1863
1864 // save plain
1865 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1866 {
1867 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1868
1869 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1870
1871 debug_plain_len = plain_len;
1872 }
1873 }
1874
1875 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1876
1877 crackpos += gidvid;
1878 crackpos *= data.kernel_rules_cnt;
1879 crackpos += device_param->innerloop_pos + il_pos;
1880
1881 if (plain_len > data.pw_max) plain_len = data.pw_max;
1882 }
1883 else if (data.attack_mode == ATTACK_MODE_COMBI)
1884 {
1885 uint64_t gidd = gidvid;
1886 uint64_t gidm = 0;
1887
1888 pw_t pw;
1889
1890 gidd_to_pw_t (device_param, gidd, &pw);
1891
1892 for (int i = 0, j = gidm; i < 16; i++, j++)
1893 {
1894 plain_buf[i] = pw.hi1[0][j];
1895 }
1896
1897 plain_len = pw.pw_len;
1898
1899 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1900 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1901
1902 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1903 {
1904 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1905 }
1906 else
1907 {
1908 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1909
1910 memcpy (plain_ptr, comb_buf, comb_len);
1911 }
1912
1913 plain_len += comb_len;
1914
1915 crackpos += gidvid;
1916 crackpos *= data.combs_cnt;
1917 crackpos += device_param->innerloop_pos + il_pos;
1918
1919 if (data.pw_max != PW_DICTMAX1)
1920 {
1921 if (plain_len > data.pw_max) plain_len = data.pw_max;
1922 }
1923 }
1924 else if (data.attack_mode == ATTACK_MODE_BF)
1925 {
1926 uint64_t l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1927 uint64_t r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1928
1929 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1930 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1931
1932 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1933 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1934
1935 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1936 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1937
1938 plain_len = data.css_cnt;
1939
1940 crackpos += gidvid;
1941 crackpos *= data.bfs_cnt;
1942 crackpos += device_param->innerloop_pos + il_pos;
1943 }
1944 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1945 {
1946 uint64_t gidd = gidvid;
1947 uint64_t gidm = 0;
1948
1949 pw_t pw;
1950
1951 gidd_to_pw_t (device_param, gidd, &pw);
1952
1953 for (int i = 0, j = gidm; i < 16; i++, j++)
1954 {
1955 plain_buf[i] = pw.hi1[0][j];
1956 }
1957
1958 plain_len = pw.pw_len;
1959
1960 uint64_t off = device_param->kernel_params_mp_buf64[3] + il_pos;
1961
1962 uint start = 0;
1963 uint stop = device_param->kernel_params_mp_buf32[4];
1964
1965 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
1966
1967 plain_len += start + stop;
1968
1969 crackpos += gidvid;
1970 crackpos *= data.combs_cnt;
1971 crackpos += device_param->innerloop_pos + il_pos;
1972
1973 if (data.pw_max != PW_DICTMAX1)
1974 {
1975 if (plain_len > data.pw_max) plain_len = data.pw_max;
1976 }
1977 }
1978 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1979 {
1980 uint64_t gidd = gidvid;
1981 uint64_t gidm = 0;
1982
1983 pw_t pw;
1984
1985 gidd_to_pw_t (device_param, gidd, &pw);
1986
1987 for (int i = 0, j = gidm; i < 16; i++, j++)
1988 {
1989 plain_buf[i] = pw.hi1[0][j];
1990 }
1991
1992 plain_len = pw.pw_len;
1993
1994 uint64_t off = device_param->kernel_params_mp_buf64[3] + il_pos;
1995
1996 uint start = 0;
1997 uint stop = device_param->kernel_params_mp_buf32[4];
1998
1999 memmove (plain_ptr + stop, plain_ptr, plain_len);
2000
2001 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2002
2003 plain_len += start + stop;
2004
2005 crackpos += gidvid;
2006 crackpos *= data.combs_cnt;
2007 crackpos += device_param->innerloop_pos + il_pos;
2008
2009 if (data.pw_max != PW_DICTMAX1)
2010 {
2011 if (plain_len > data.pw_max) plain_len = data.pw_max;
2012 }
2013 }
2014
2015 if (data.attack_mode == ATTACK_MODE_BF)
2016 {
2017 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2018 {
2019 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2020 {
2021 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2022 {
2023 plain_len = plain_len - data.salts_buf[0].salt_len;
2024 }
2025 }
2026
2027 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2028 {
2029 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2030 {
2031 plain_ptr[j] = plain_ptr[i];
2032 }
2033
2034 plain_len = plain_len / 2;
2035 }
2036 }
2037 }
2038
2039 // if enabled, update also the potfile
2040
2041 if (pot_fp)
2042 {
2043 fprintf (pot_fp, "%s:", out_buf);
2044
2045 format_plain (pot_fp, plain_ptr, plain_len, 1);
2046
2047 fputc ('\n', pot_fp);
2048
2049 fflush (pot_fp);
2050 }
2051
2052 // outfile
2053
2054 FILE *out_fp = NULL;
2055
2056 if (outfile != NULL)
2057 {
2058 if ((out_fp = fopen (outfile, "ab")) == NULL)
2059 {
2060 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2061
2062 out_fp = stdout;
2063 }
2064 }
2065 else
2066 {
2067 out_fp = stdout;
2068
2069 if (quiet == 0) clear_prompt ();
2070 }
2071
2072 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2073
2074 if (outfile != NULL)
2075 {
2076 if (out_fp != stdout)
2077 {
2078 fclose (out_fp);
2079 }
2080 }
2081 else
2082 {
2083 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2084 {
2085 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2086 {
2087 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2088 if (quiet == 0) fflush (stdout);
2089 }
2090 }
2091 }
2092
2093 // loopback
2094
2095 if (loopback)
2096 {
2097 char *loopback_file = data.loopback_file;
2098
2099 FILE *fb_fp = NULL;
2100
2101 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2102 {
2103 format_plain (fb_fp, plain_ptr, plain_len, 1);
2104
2105 fputc ('\n', fb_fp);
2106
2107 fclose (fb_fp);
2108 }
2109 }
2110
2111 // (rule) debug mode
2112
2113 // the next check implies that:
2114 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2115 // - debug_mode > 0
2116
2117 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2118 {
2119 if (debug_rule_len < 0) debug_rule_len = 0;
2120
2121 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2122
2123 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2124
2125 if ((quiet == 0) && (debug_file == NULL))
2126 {
2127 fprintf (stdout, "%s", PROMPT);
2128 fflush (stdout);
2129 }
2130 }
2131 }
2132
2133 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2134 {
2135 salt_t *salt_buf = &data.salts_buf[salt_pos];
2136
2137 int found = 0;
2138
2139 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2140
2141 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2142
2143 if (found == 1)
2144 {
2145 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2146
2147 log_info_nn ("");
2148
2149 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);
2150
2151 uint cpt_cracked = 0;
2152
2153 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2154 {
2155 uint idx = salt_buf->digests_offset + digest_pos;
2156
2157 if (data.digests_shown_tmp[idx] == 0) continue;
2158
2159 if (data.digests_shown[idx] == 1) continue;
2160
2161 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2162 {
2163 data.digests_shown[idx] = 1;
2164
2165 data.digests_done++;
2166
2167 cpt_cracked++;
2168
2169 salt_buf->digests_done++;
2170
2171 if (salt_buf->digests_done == salt_buf->digests_cnt)
2172 {
2173 data.salts_shown[salt_pos] = 1;
2174
2175 data.salts_done++;
2176 }
2177 }
2178
2179 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2180
2181 check_hash (device_param, salt_pos, digest_pos);
2182 }
2183
2184 if (cpt_cracked > 0)
2185 {
2186 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2187 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2188
2189 data.cpt_pos++;
2190
2191 data.cpt_total += cpt_cracked;
2192
2193 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2194 }
2195
2196 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2197 {
2198 // we need to reset cracked state on the device
2199 // otherwise host thinks again and again the hash was cracked
2200 // and returns invalid password each time
2201
2202 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2203
2204 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);
2205 }
2206
2207 memset (device_param->result, 0, device_param->size_results);
2208
2209 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2210 }
2211 }
2212
2213 static void save_hash ()
2214 {
2215 char *hashfile = data.hashfile;
2216
2217 char new_hashfile[256];
2218 char old_hashfile[256];
2219
2220 memset (new_hashfile, 0, sizeof (new_hashfile));
2221 memset (old_hashfile, 0, sizeof (old_hashfile));
2222
2223 snprintf (new_hashfile, 255, "%s.new", hashfile);
2224 snprintf (old_hashfile, 255, "%s.old", hashfile);
2225
2226 unlink (new_hashfile);
2227
2228 char separator = data.separator;
2229
2230 FILE *fp = fopen (new_hashfile, "wb");
2231
2232 if (fp == NULL)
2233 {
2234 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2235
2236 exit (-1);
2237 }
2238
2239 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2240 {
2241 if (data.salts_shown[salt_pos] == 1) continue;
2242
2243 salt_t *salt_buf = &data.salts_buf[salt_pos];
2244
2245 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2246 {
2247 uint idx = salt_buf->digests_offset + digest_pos;
2248
2249 if (data.digests_shown[idx] == 1) continue;
2250
2251 if (data.hash_mode != 2500)
2252 {
2253 char out_buf[4096];
2254
2255 memset (out_buf, 0, sizeof (out_buf));
2256
2257 if (data.username == 1)
2258 {
2259 user_t *user = data.hash_info[idx]->user;
2260
2261 uint i;
2262
2263 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2264
2265 fputc (separator, fp);
2266 }
2267
2268 ascii_digest (out_buf, salt_pos, digest_pos);
2269
2270 fputs (out_buf, fp);
2271
2272 log_out (fp, "");
2273 }
2274 else
2275 {
2276 hccap_t hccap;
2277
2278 to_hccap_t (&hccap, salt_pos, digest_pos);
2279
2280 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2281 }
2282 }
2283 }
2284
2285 fflush (fp);
2286
2287 fclose (fp);
2288
2289 unlink (old_hashfile);
2290
2291 if (rename (hashfile, old_hashfile) != 0)
2292 {
2293 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2294
2295 exit (-1);
2296 }
2297
2298 unlink (hashfile);
2299
2300 if (rename (new_hashfile, hashfile) != 0)
2301 {
2302 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2303
2304 exit (-1);
2305 }
2306
2307 unlink (old_hashfile);
2308 }
2309
2310 static float find_kernel_blocks_div (const uint64_t total_left, const uint kernel_blocks_all)
2311 {
2312 // function called only in case kernel_blocks_all > words_left)
2313
2314 float kernel_blocks_div = (float) (total_left) / kernel_blocks_all;
2315
2316 kernel_blocks_div += kernel_blocks_div / 100;
2317
2318 uint32_t kernel_blocks_new = (uint32_t) (kernel_blocks_all * kernel_blocks_div);
2319
2320 while (kernel_blocks_new < total_left)
2321 {
2322 kernel_blocks_div += kernel_blocks_div / 100;
2323
2324 kernel_blocks_new = (uint32_t) (kernel_blocks_all * kernel_blocks_div);
2325 }
2326
2327 if (data.quiet == 0)
2328 {
2329 clear_prompt ();
2330
2331 log_info ("");
2332
2333 log_info ("INFO: approaching final keyspace, workload adjusted");
2334
2335 log_info ("");
2336
2337 fprintf (stdout, "%s", PROMPT);
2338
2339 fflush (stdout);
2340 }
2341
2342 if ((kernel_blocks_all * kernel_blocks_div) < 8) return 1;
2343
2344 return kernel_blocks_div;
2345 }
2346
2347 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num)
2348 {
2349 uint num_elements = num;
2350
2351 device_param->kernel_params_buf32[30] = data.combs_mode;
2352 device_param->kernel_params_buf32[31] = num;
2353
2354 uint kernel_threads = device_param->kernel_threads;
2355
2356 while (num_elements % kernel_threads) num_elements++;
2357
2358 cl_kernel kernel = NULL;
2359
2360 switch (kern_run)
2361 {
2362 case KERN_RUN_1: kernel = device_param->kernel1; break;
2363 case KERN_RUN_12: kernel = device_param->kernel12; break;
2364 case KERN_RUN_2: kernel = device_param->kernel2; break;
2365 case KERN_RUN_23: kernel = device_param->kernel23; break;
2366 case KERN_RUN_3: kernel = device_param->kernel3; break;
2367 case KERN_RUN_WEAK: kernel = device_param->kernel_weak; break;
2368 }
2369
2370 hc_clSetKernelArg (kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2371 hc_clSetKernelArg (kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2372 hc_clSetKernelArg (kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2373 hc_clSetKernelArg (kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2374 hc_clSetKernelArg (kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2375 hc_clSetKernelArg (kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2376 hc_clSetKernelArg (kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2377 hc_clSetKernelArg (kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2378 hc_clSetKernelArg (kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2379 hc_clSetKernelArg (kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2380 hc_clSetKernelArg (kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2381
2382 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2383 {
2384 const size_t global_work_size[3] = { num_elements, 32, 1 };
2385 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2386
2387 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2388 }
2389 else
2390 {
2391 const size_t global_work_size[3] = { num_elements, 1, 1 };
2392 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2393
2394 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2395 }
2396
2397 hc_clFlush (device_param->command_queue);
2398
2399 hc_clFinish (device_param->command_queue);
2400 }
2401
2402 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2403 {
2404 uint num_elements = num;
2405
2406 switch (kern_run)
2407 {
2408 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2409 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2410 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2411 }
2412
2413 // causes problems with special threads like in bcrypt
2414 // const uint kernel_threads = device_param->kernel_threads;
2415
2416 const uint kernel_threads = KERNEL_THREADS;
2417
2418 while (num_elements % kernel_threads) num_elements++;
2419
2420 cl_kernel kernel = NULL;
2421
2422 switch (kern_run)
2423 {
2424 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2425 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2426 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2427 }
2428
2429 switch (kern_run)
2430 {
2431 case KERN_RUN_MP: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2432 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2433 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2434 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2435 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2436 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2437 break;
2438 case KERN_RUN_MP_R: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2439 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2440 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2441 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2442 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2443 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2444 break;
2445 case KERN_RUN_MP_L: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2446 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2447 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2448 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2449 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2450 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2451 hc_clSetKernelArg (kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2452 break;
2453 }
2454
2455 const size_t global_work_size[3] = { num_elements, 1, 1 };
2456 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2457
2458 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2459
2460 hc_clFlush (device_param->command_queue);
2461
2462 hc_clFinish (device_param->command_queue);
2463 }
2464
2465 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2466 {
2467 uint num_elements = num;
2468
2469 uint kernel_threads = device_param->kernel_threads;
2470
2471 while (num_elements % kernel_threads) num_elements++;
2472
2473 cl_kernel kernel = device_param->kernel_tb;
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_tm (hc_device_param_t *device_param)
2486 {
2487 const uint num_elements = 1024; // fixed
2488
2489 const uint kernel_threads = 32;
2490
2491 cl_kernel kernel = device_param->kernel_tm;
2492
2493 const size_t global_work_size[3] = { num_elements, 1, 1 };
2494 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2495
2496 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2497
2498 hc_clFlush (device_param->command_queue);
2499
2500 hc_clFinish (device_param->command_queue);
2501 }
2502
2503 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2504 {
2505 uint num_elements = num;
2506
2507 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2508 device_param->kernel_params_amp_buf32[6] = num_elements;
2509
2510 // causes problems with special threads like in bcrypt
2511 // const uint kernel_threads = device_param->kernel_threads;
2512
2513 const uint kernel_threads = KERNEL_THREADS;
2514
2515 while (num_elements % kernel_threads) num_elements++;
2516
2517 cl_kernel kernel = device_param->kernel_amp;
2518
2519 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2520 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2521
2522 const size_t global_work_size[3] = { num_elements, 1, 1 };
2523 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2524
2525 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2526
2527 hc_clFlush (device_param->command_queue);
2528
2529 hc_clFinish (device_param->command_queue);
2530 }
2531
2532 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2533 {
2534 if (device_param->vendor_id == VENDOR_ID_AMD)
2535 {
2536 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2537
2538 const cl_uchar zero = 0;
2539
2540 hc_clEnqueueFillBuffer (device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2541 }
2542 else
2543 {
2544 // NOTE: clEnqueueFillBuffer () always fails with -59
2545 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults
2546 // How's that possible, OpenCL 1.2 support is advertised??
2547 // We need to workaround...
2548
2549 #define FILLSZ 0x100000
2550
2551 char *tmp = (char *) mymalloc (FILLSZ);
2552
2553 memset (tmp, 0, FILLSZ);
2554
2555 for (uint i = 0; i < size; i += FILLSZ)
2556 {
2557 const int left = size - i;
2558
2559 const int fillsz = MIN (FILLSZ, left);
2560
2561 hc_clEnqueueWriteBuffer (device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2562 }
2563
2564 myfree (tmp);
2565 }
2566 }
2567
2568 static int run_rule_engine (const int rule_len, const char *rule_buf)
2569 {
2570 if (rule_len == 0)
2571 {
2572 return 0;
2573 }
2574 else if (rule_len == 1)
2575 {
2576 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2577 }
2578
2579 return 1;
2580 }
2581
2582 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2583 {
2584 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2585 {
2586 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);
2587 }
2588 else if (data.attack_kern == ATTACK_KERN_COMBI)
2589 {
2590 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);
2591 }
2592 else if (data.attack_kern == ATTACK_KERN_BF)
2593 {
2594 const uint64_t off = device_param->words_off;
2595
2596 device_param->kernel_params_mp_l_buf64[3] = off;
2597
2598 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2599 }
2600 }
2601
2602 static void run_cracker (hc_device_param_t *device_param, const uint pw_cnt, const uint pws_cnt)
2603 {
2604 const uint kernel_loops = data.kernel_loops;
2605
2606 // init speed timer
2607
2608 uint speed_pos = device_param->speed_pos;
2609
2610 #ifdef _POSIX
2611 if (device_param->timer_speed.tv_sec == 0)
2612 {
2613 hc_timer_set (&device_param->timer_speed);
2614 }
2615 #endif
2616
2617 #ifdef _WIN
2618 if (device_param->timer_speed.QuadPart == 0)
2619 {
2620 hc_timer_set (&device_param->timer_speed);
2621 }
2622 #endif
2623
2624 // find higest password length, this is for optimization stuff
2625
2626 uint highest_pw_len = 0;
2627
2628 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2629 {
2630 }
2631 else if (data.attack_kern == ATTACK_KERN_COMBI)
2632 {
2633 }
2634 else if (data.attack_kern == ATTACK_KERN_BF)
2635 {
2636 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
2637 + device_param->kernel_params_mp_l_buf32[5];
2638 }
2639
2640 // bitslice optimization stuff
2641
2642 if (data.attack_mode == ATTACK_MODE_BF)
2643 {
2644 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2645 {
2646 run_kernel_tb (device_param, pws_cnt);
2647 }
2648 }
2649
2650 // iteration type
2651
2652 uint innerloop_step = 0;
2653 uint innerloop_cnt = 0;
2654
2655 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = kernel_loops;
2656 else innerloop_step = 1;
2657
2658 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
2659 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
2660 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
2661
2662 // loop start: most outer loop = salt iteration, then innerloops (if multi)
2663
2664 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2665 {
2666 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2667
2668 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2669
2670 if (data.devices_status == STATUS_CRACKED) break;
2671 if (data.devices_status == STATUS_ABORTED) break;
2672 if (data.devices_status == STATUS_QUIT) break;
2673 if (data.devices_status == STATUS_BYPASS) break;
2674
2675 if (data.salts_shown[salt_pos] == 1) continue;
2676
2677 salt_t *salt_buf = &data.salts_buf[salt_pos];
2678
2679 device_param->kernel_params_buf32[24] = salt_pos;
2680 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
2681 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
2682
2683 FILE *combs_fp = device_param->combs_fp;
2684
2685 if (data.attack_mode == ATTACK_MODE_COMBI)
2686 {
2687 rewind (combs_fp);
2688 }
2689
2690 // innerloops
2691
2692 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
2693 {
2694 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2695
2696 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2697
2698 if (data.devices_status == STATUS_CRACKED) break;
2699 if (data.devices_status == STATUS_ABORTED) break;
2700 if (data.devices_status == STATUS_QUIT) break;
2701 if (data.devices_status == STATUS_BYPASS) break;
2702
2703 uint innerloop_left = innerloop_cnt - innerloop_pos;
2704
2705 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
2706
2707 device_param->innerloop_pos = innerloop_pos;
2708 device_param->innerloop_left = innerloop_left;
2709
2710 device_param->kernel_params_buf32[27] = innerloop_left;
2711
2712 if (innerloop_left == 0) continue;
2713
2714 // initialize amplifiers
2715
2716 if (data.attack_mode == ATTACK_MODE_COMBI)
2717 {
2718 char line_buf[BUFSIZ];
2719
2720 uint i = 0;
2721
2722 while (i < innerloop_left)
2723 {
2724 if (feof (combs_fp)) break;
2725
2726 int line_len = fgetl (combs_fp, line_buf);
2727
2728 if (line_len >= PW_MAX1) continue;
2729
2730 line_len = convert_from_hex (line_buf, line_len);
2731
2732 char *line_buf_new = line_buf;
2733
2734 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
2735 {
2736 char rule_buf_out[BLOCK_SIZE];
2737
2738 memset (rule_buf_out, 0, sizeof (rule_buf_out));
2739
2740 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
2741
2742 if (rule_len_out < 0)
2743 {
2744 data.words_progress_rejected[salt_pos] += pw_cnt;
2745
2746 continue;
2747 }
2748
2749 line_len = rule_len_out;
2750
2751 line_buf_new = rule_buf_out;
2752 }
2753
2754 line_len = MIN (line_len, PW_DICTMAX);
2755
2756 char *ptr = (char *) device_param->combs_buf[i].i;
2757
2758 memcpy (ptr, line_buf_new, line_len);
2759
2760 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
2761
2762 if (data.opts_type & OPTS_TYPE_PT_UPPER)
2763 {
2764 uppercase (ptr, line_len);
2765 }
2766
2767 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2768 {
2769 if (data.opts_type & OPTS_TYPE_PT_ADD80)
2770 {
2771 ptr[line_len] = 0x80;
2772 }
2773
2774 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2775 {
2776 ptr[line_len] = 0x01;
2777 }
2778 }
2779
2780 device_param->combs_buf[i].pw_len = line_len;
2781
2782 i++;
2783 }
2784
2785 for (uint j = i; j < innerloop_left; j++)
2786 {
2787 device_param->combs_buf[j].i[0] = 0;
2788 device_param->combs_buf[j].i[1] = 0;
2789 device_param->combs_buf[j].i[2] = 0;
2790 device_param->combs_buf[j].i[3] = 0;
2791 device_param->combs_buf[j].i[4] = 0;
2792 device_param->combs_buf[j].i[5] = 0;
2793 device_param->combs_buf[j].i[6] = 0;
2794 device_param->combs_buf[j].i[7] = 0;
2795
2796 device_param->combs_buf[j].pw_len = 0;
2797 }
2798
2799 innerloop_left = i;
2800 }
2801 else if (data.attack_mode == ATTACK_MODE_BF)
2802 {
2803 uint64_t off = innerloop_pos;
2804
2805 device_param->kernel_params_mp_r_buf64[3] = off;
2806
2807 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
2808 }
2809 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2810 {
2811 uint64_t off = innerloop_pos;
2812
2813 device_param->kernel_params_mp_buf64[3] = off;
2814
2815 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2816 }
2817 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2818 {
2819 uint64_t off = innerloop_pos;
2820
2821 device_param->kernel_params_mp_buf64[3] = off;
2822
2823 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2824 }
2825
2826 // copy amplifiers
2827
2828 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2829 {
2830 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);
2831 }
2832 else if (data.attack_mode == ATTACK_MODE_COMBI)
2833 {
2834 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);
2835 }
2836 else if (data.attack_mode == ATTACK_MODE_BF)
2837 {
2838 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);
2839 }
2840 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2841 {
2842 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);
2843 }
2844 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2845 {
2846 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);
2847 }
2848
2849 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2850 {
2851 if (data.attack_mode == ATTACK_MODE_BF)
2852 {
2853 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2854 {
2855 const uint size_tm = 32 * sizeof (bs_word_t);
2856
2857 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2858
2859 run_kernel_tm (device_param);
2860
2861 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2862 }
2863 }
2864
2865 if (highest_pw_len < 16)
2866 {
2867 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2868 }
2869 else if (highest_pw_len < 32)
2870 {
2871 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2872 }
2873 else
2874 {
2875 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2876 }
2877 }
2878 else
2879 {
2880 run_kernel_amp (device_param, pws_cnt);
2881
2882 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2883
2884 if (data.opts_type & OPTS_TYPE_HOOK12)
2885 {
2886 run_kernel (KERN_RUN_12, device_param, pws_cnt);
2887 }
2888
2889 uint iter = salt_buf->salt_iter;
2890
2891 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
2892 {
2893 uint loop_left = iter - loop_pos;
2894
2895 loop_left = MIN (loop_left, kernel_loops);
2896
2897 device_param->kernel_params_buf32[25] = loop_pos;
2898 device_param->kernel_params_buf32[26] = loop_left;
2899
2900 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2901
2902 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2903
2904 if (data.devices_status == STATUS_CRACKED) break;
2905 if (data.devices_status == STATUS_ABORTED) break;
2906 if (data.devices_status == STATUS_QUIT) break;
2907 }
2908
2909 if (data.opts_type & OPTS_TYPE_HOOK23)
2910 {
2911 run_kernel (KERN_RUN_23, device_param, pws_cnt);
2912
2913 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2914
2915 // do something with data
2916
2917 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2918 }
2919
2920 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2921 }
2922
2923 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2924
2925 if (data.devices_status == STATUS_CRACKED) break;
2926 if (data.devices_status == STATUS_ABORTED) break;
2927 if (data.devices_status == STATUS_QUIT) break;
2928
2929 /**
2930 * result
2931 */
2932
2933 hc_thread_mutex_lock (mux_display);
2934
2935 check_cracked (device_param, salt_pos);
2936
2937 hc_thread_mutex_unlock (mux_display);
2938
2939 /**
2940 * progress
2941 */
2942
2943 uint64_t perf_sum_all = (uint64_t) pw_cnt * (uint64_t) innerloop_left;
2944
2945 hc_thread_mutex_lock (mux_counter);
2946
2947 data.words_progress_done[salt_pos] += perf_sum_all;
2948
2949 hc_thread_mutex_unlock (mux_counter);
2950
2951 /**
2952 * speed
2953 */
2954
2955 float speed_ms;
2956
2957 hc_timer_get (device_param->timer_speed, speed_ms);
2958
2959 hc_timer_set (&device_param->timer_speed);
2960
2961 hc_thread_mutex_lock (mux_display);
2962
2963 device_param->speed_cnt[speed_pos] = perf_sum_all;
2964
2965 device_param->speed_ms[speed_pos] = speed_ms;
2966
2967 device_param->speed_rec[speed_pos] = device_param->timer_speed;
2968
2969 hc_thread_mutex_unlock (mux_display);
2970
2971 speed_pos++;
2972
2973 if (speed_pos == SPEED_CACHE)
2974 {
2975 speed_pos = 0;
2976 }
2977 }
2978 }
2979
2980 device_param->speed_pos = speed_pos;
2981 }
2982
2983 static void load_segment (wl_data_t *wl_data, FILE *fd)
2984 {
2985 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
2986
2987 wl_data->pos = 0;
2988
2989 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
2990
2991 wl_data->buf[wl_data->cnt] = 0;
2992
2993 if (wl_data->cnt == 0) return;
2994
2995 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
2996
2997 while (!feof (fd))
2998 {
2999 if (wl_data->cnt == wl_data->avail)
3000 {
3001 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3002
3003 wl_data->avail += wl_data->incr;
3004 }
3005
3006 const int c = fgetc (fd);
3007
3008 if (c == EOF) break;
3009
3010 wl_data->buf[wl_data->cnt] = (char) c;
3011
3012 wl_data->cnt++;
3013
3014 if (c == '\n') break;
3015 }
3016
3017 // ensure stream ends with a newline
3018
3019 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3020 {
3021 wl_data->cnt++;
3022
3023 wl_data->buf[wl_data->cnt - 1] = '\n';
3024 }
3025
3026 return;
3027 }
3028
3029 static void get_next_word_lm (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
3030 {
3031 char *ptr = buf;
3032
3033 for (uint32_t i = 0; i < sz; i++, ptr++)
3034 {
3035 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3036
3037 if (i == 7)
3038 {
3039 *off = i;
3040 *len = i;
3041
3042 return;
3043 }
3044
3045 if (*ptr != '\n') continue;
3046
3047 *off = i + 1;
3048
3049 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3050
3051 *len = i;
3052
3053 return;
3054 }
3055
3056 *off = sz;
3057 *len = sz;
3058 }
3059
3060 static void get_next_word_uc (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
3061 {
3062 char *ptr = buf;
3063
3064 for (uint32_t i = 0; i < sz; i++, ptr++)
3065 {
3066 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3067
3068 if (*ptr != '\n') continue;
3069
3070 *off = i + 1;
3071
3072 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3073
3074 *len = i;
3075
3076 return;
3077 }
3078
3079 *off = sz;
3080 *len = sz;
3081 }
3082
3083 static void get_next_word_std (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
3084 {
3085 char *ptr = buf;
3086
3087 for (uint32_t i = 0; i < sz; i++, ptr++)
3088 {
3089 if (*ptr != '\n') continue;
3090
3091 *off = i + 1;
3092
3093 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3094
3095 *len = i;
3096
3097 return;
3098 }
3099
3100 *off = sz;
3101 *len = sz;
3102 }
3103
3104 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3105 {
3106 while (wl_data->pos < wl_data->cnt)
3107 {
3108 uint off;
3109 uint len;
3110
3111 char *ptr = wl_data->buf + wl_data->pos;
3112
3113 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3114
3115 wl_data->pos += off;
3116
3117 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3118 {
3119 char rule_buf_out[BLOCK_SIZE];
3120
3121 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3122
3123 int rule_len_out = -1;
3124
3125 if (len < BLOCK_SIZE)
3126 {
3127 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3128 }
3129
3130 if (rule_len_out < 0)
3131 {
3132 continue;
3133 }
3134
3135 if (rule_len_out > PW_MAX)
3136 {
3137 continue;
3138 }
3139 }
3140 else
3141 {
3142 if (len > PW_MAX)
3143 {
3144 continue;
3145 }
3146 }
3147
3148 *out_buf = ptr;
3149 *out_len = len;
3150
3151 return;
3152 }
3153
3154 if (feof (fd))
3155 {
3156 fprintf (stderr, "bug!!\n");
3157
3158 return;
3159 }
3160
3161 load_segment (wl_data, fd);
3162
3163 get_next_word (wl_data, fd, out_buf, out_len);
3164 }
3165
3166 #ifdef _POSIX
3167 static uint64_t count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3168 #endif
3169
3170 #ifdef _WIN
3171 static uint64_t count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3172 #endif
3173 {
3174 hc_signal (NULL);
3175
3176 dictstat_t d;
3177
3178 d.cnt = 0;
3179
3180 #ifdef _POSIX
3181 fstat (fileno (fd), &d.stat);
3182 #endif
3183
3184 #ifdef _WIN
3185 _fstat64 (fileno (fd), &d.stat);
3186 #endif
3187
3188 d.stat.st_mode = 0;
3189 d.stat.st_nlink = 0;
3190 d.stat.st_uid = 0;
3191 d.stat.st_gid = 0;
3192 d.stat.st_rdev = 0;
3193 d.stat.st_atime = 0;
3194
3195 #ifdef _POSIX
3196 d.stat.st_blksize = 0;
3197 d.stat.st_blocks = 0;
3198 #endif
3199
3200 if (d.stat.st_size == 0) return 0;
3201
3202 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3203
3204 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3205 {
3206 if (d_cache)
3207 {
3208 uint64_t cnt = d_cache->cnt;
3209
3210 uint64_t keyspace = cnt;
3211
3212 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3213 {
3214 keyspace *= data.kernel_rules_cnt;
3215 }
3216 else if (data.attack_kern == ATTACK_KERN_COMBI)
3217 {
3218 keyspace *= data.combs_cnt;
3219 }
3220
3221 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);
3222 if (data.quiet == 0) log_info ("");
3223
3224 hc_signal (sigHandler_default);
3225
3226 return (keyspace);
3227 }
3228 }
3229
3230 time_t now = 0;
3231 time_t prev = 0;
3232
3233 uint64_t comp = 0;
3234 uint64_t cnt = 0;
3235 uint64_t cnt2 = 0;
3236
3237 while (!feof (fd))
3238 {
3239 load_segment (wl_data, fd);
3240
3241 comp += wl_data->cnt;
3242
3243 uint32_t i = 0;
3244
3245 while (i < wl_data->cnt)
3246 {
3247 uint32_t len;
3248 uint32_t off;
3249
3250 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3251
3252 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3253 {
3254 char rule_buf_out[BLOCK_SIZE];
3255
3256 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3257
3258 int rule_len_out = -1;
3259
3260 if (len < BLOCK_SIZE)
3261 {
3262 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3263 }
3264
3265 if (rule_len_out < 0)
3266 {
3267 len = PW_MAX1;
3268 }
3269 else
3270 {
3271 len = rule_len_out;
3272 }
3273 }
3274
3275 if (len < PW_MAX1)
3276 {
3277 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3278 {
3279 cnt += data.kernel_rules_cnt;
3280 }
3281 else if (data.attack_kern == ATTACK_KERN_COMBI)
3282 {
3283 cnt += data.combs_cnt;
3284 }
3285
3286 d.cnt++;
3287 }
3288
3289 i += off;
3290
3291 cnt2++;
3292 }
3293
3294 time (&now);
3295
3296 if ((now - prev) == 0) continue;
3297
3298 float percent = (float) comp / (float) d.stat.st_size;
3299
3300 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);
3301
3302 time (&prev);
3303 }
3304
3305 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);
3306 if (data.quiet == 0) log_info ("");
3307
3308 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3309
3310 hc_signal (sigHandler_default);
3311
3312 return (cnt);
3313 }
3314
3315 static void pw_transpose_to_hi1 (const pw_t *p1, pw_t *p2)
3316 {
3317 memcpy (p2->hi1, p1->hi1, 64 * sizeof (uint));
3318 }
3319
3320 static uint pw_add_to_hc1 (hc_device_param_t *device_param, const uint8_t *pw_buf, const uint pw_len)
3321 {
3322 if (data.devices_status == STATUS_BYPASS) return 0;
3323
3324 pw_cache_t *pw_cache = device_param->pw_caches + pw_len;
3325
3326 uint cache_cnt = pw_cache->cnt;
3327
3328 uint8_t *pw_hc1 = pw_cache->pw_buf.hc1[cache_cnt];
3329
3330 memcpy (pw_hc1, pw_buf, pw_len);
3331
3332 memset (pw_hc1 + pw_len, 0, 256 - pw_len);
3333
3334 uint pws_cnt = device_param->pws_cnt;
3335
3336 cache_cnt++;
3337
3338 pw_t *pw = device_param->pws_buf + pws_cnt;
3339
3340 device_param->pw_transpose (&pw_cache->pw_buf, pw);
3341
3342 pw->pw_len = pw_len;
3343
3344 pws_cnt++;
3345
3346 device_param->pws_cnt = pws_cnt;
3347 device_param->pw_cnt = pws_cnt * 1;
3348
3349 cache_cnt = 0;
3350
3351 pw_cache->cnt = cache_cnt;
3352
3353 return pws_cnt;
3354 }
3355
3356 static void *thread_monitor (void *p)
3357 {
3358 uint runtime_check = 0;
3359 uint remove_check = 0;
3360 uint status_check = 0;
3361 uint hwmon_check = 0;
3362 uint restore_check = 0;
3363
3364 uint restore_left = data.restore_timer;
3365 uint remove_left = data.remove_timer;
3366 uint status_left = data.status_timer;
3367
3368 // these variables are mainly used for fan control (AMD only)
3369
3370 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3371
3372 // temperature controller "loopback" values
3373
3374 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3375 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3376
3377 int temp_threshold = 1; // degrees celcius
3378
3379 int fan_speed_min = 15; // in percentage
3380 int fan_speed_max = 100;
3381
3382 time_t last_temp_check_time;
3383
3384 uint sleep_time = 1;
3385
3386 if (data.runtime)
3387 {
3388 runtime_check = 1;
3389 }
3390
3391 if (data.restore_timer)
3392 {
3393 restore_check = 1;
3394 }
3395
3396 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3397 {
3398 remove_check = 1;
3399 }
3400
3401 if (data.status == 1)
3402 {
3403 status_check = 1;
3404 }
3405
3406 if (data.gpu_temp_disable == 0)
3407 {
3408 time (&last_temp_check_time);
3409
3410 hwmon_check = 1;
3411 }
3412
3413 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (hwmon_check == 0) && (restore_check == 0))
3414 {
3415 return (p);
3416 }
3417
3418 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3419 {
3420 hc_sleep (sleep_time);
3421
3422 if (data.devices_status != STATUS_RUNNING) continue;
3423
3424 if (hwmon_check == 1)
3425 {
3426 hc_thread_mutex_lock (mux_adl);
3427
3428 time_t temp_check_time;
3429
3430 time (&temp_check_time);
3431
3432 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3433
3434 if (Ta == 0) Ta = 1;
3435
3436 for (uint i = 0; i < data.devices_cnt; i++)
3437 {
3438 if ((data.devices_param[i].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3439
3440 const int temperature = hm_get_temperature_with_device_id (i);
3441
3442 if (temperature > (int) data.gpu_temp_abort)
3443 {
3444 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", i + 1);
3445
3446 if (data.devices_status != STATUS_QUIT) myabort ();
3447
3448 break;
3449 }
3450
3451 const int gpu_temp_retain = data.gpu_temp_retain;
3452
3453 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3454 {
3455 if (data.hm_device[i].fan_supported == 1)
3456 {
3457 int temp_cur = temperature;
3458
3459 int temp_diff_new = gpu_temp_retain - temp_cur;
3460
3461 temp_diff_sum[i] = temp_diff_sum[i] + temp_diff_new;
3462
3463 // calculate Ta value (time difference in seconds between the last check and this check)
3464
3465 last_temp_check_time = temp_check_time;
3466
3467 float Kp = 1.8;
3468 float Ki = 0.005;
3469 float Kd = 6;
3470
3471 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3472
3473 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);
3474
3475 if (abs (fan_diff_required) >= temp_threshold)
3476 {
3477 const int fan_speed_cur = hm_get_fanspeed_with_device_id (i);
3478
3479 int fan_speed_level = fan_speed_cur;
3480
3481 if (fan_speed_chgd[i] == 0) fan_speed_level = temp_cur;
3482
3483 int fan_speed_new = fan_speed_level - fan_diff_required;
3484
3485 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3486 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3487
3488 if (fan_speed_new != fan_speed_cur)
3489 {
3490 int freely_change_fan_speed = (fan_speed_chgd[i] == 1);
3491 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3492
3493 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3494 {
3495 hm_set_fanspeed_with_device_id_amd (i, fan_speed_new);
3496
3497 fan_speed_chgd[i] = 1;
3498 }
3499
3500 temp_diff_old[i] = temp_diff_new;
3501 }
3502 }
3503 }
3504 }
3505 }
3506
3507 hc_thread_mutex_unlock (mux_adl);
3508 }
3509
3510 if (restore_check == 1)
3511 {
3512 restore_left--;
3513
3514 if (restore_left == 0)
3515 {
3516 if (data.restore_disable == 0) cycle_restore ();
3517
3518 restore_left = data.restore_timer;
3519 }
3520 }
3521
3522 if ((runtime_check == 1) && (data.runtime_start > 0))
3523 {
3524 time_t runtime_cur;
3525
3526 time (&runtime_cur);
3527
3528 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3529
3530 if (runtime_left <= 0)
3531 {
3532 if (data.benchmark == 0)
3533 {
3534 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3535 }
3536
3537 if (data.devices_status != STATUS_QUIT) myabort ();
3538 }
3539 }
3540
3541 if (remove_check == 1)
3542 {
3543 remove_left--;
3544
3545 if (remove_left == 0)
3546 {
3547 if (data.digests_saved != data.digests_done)
3548 {
3549 data.digests_saved = data.digests_done;
3550
3551 save_hash ();
3552 }
3553
3554 remove_left = data.remove_timer;
3555 }
3556 }
3557
3558 if (status_check == 1)
3559 {
3560 status_left--;
3561
3562 if (status_left == 0)
3563 {
3564 hc_thread_mutex_lock (mux_display);
3565
3566 if (data.quiet == 0) clear_prompt ();
3567
3568 if (data.quiet == 0) log_info ("");
3569
3570 status_display ();
3571
3572 if (data.quiet == 0) log_info ("");
3573
3574 hc_thread_mutex_unlock (mux_display);
3575
3576 status_left = data.status_timer;
3577 }
3578 }
3579 }
3580
3581 myfree (fan_speed_chgd);
3582
3583 myfree (temp_diff_old);
3584 myfree (temp_diff_sum);
3585
3586 p = NULL;
3587
3588 return (p);
3589 }
3590
3591 static void *thread_outfile_remove (void *p)
3592 {
3593 // some hash-dependent constants
3594 char *outfile_dir = data.outfile_check_directory;
3595 uint dgst_size = data.dgst_size;
3596 uint isSalted = data.isSalted;
3597 uint esalt_size = data.esalt_size;
3598 uint hash_mode = data.hash_mode;
3599
3600 uint outfile_check_timer = data.outfile_check_timer;
3601
3602 char separator = data.separator;
3603
3604 // some hash-dependent functions
3605 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3606 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3607
3608 // buffers
3609 hash_t hash_buf;
3610
3611 memset (&hash_buf, 0, sizeof (hash_buf));
3612
3613 hash_buf.digest = mymalloc (dgst_size);
3614
3615 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3616
3617 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3618
3619 uint digest_buf[64];
3620
3621 outfile_data_t *out_info = NULL;
3622
3623 char **out_files = NULL;
3624
3625 time_t folder_mtime = 0;
3626
3627 int out_cnt = 0;
3628
3629 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3630
3631 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3632 {
3633 hc_sleep (1);
3634
3635 if (data.devices_status != STATUS_RUNNING) continue;
3636
3637 check_left--;
3638
3639 if (check_left == 0)
3640 {
3641 struct stat outfile_check_stat;
3642
3643 if (stat (outfile_dir, &outfile_check_stat) == 0)
3644 {
3645 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3646
3647 if (is_dir == 1)
3648 {
3649 if (outfile_check_stat.st_mtime > folder_mtime)
3650 {
3651 char **out_files_new = scan_directory (outfile_dir);
3652
3653 int out_cnt_new = count_dictionaries (out_files_new);
3654
3655 outfile_data_t *out_info_new = NULL;
3656
3657 if (out_cnt_new > 0)
3658 {
3659 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3660
3661 for (int i = 0; i < out_cnt_new; i++)
3662 {
3663 out_info_new[i].file_name = out_files_new[i];
3664
3665 // check if there are files that we have seen/checked before (and not changed)
3666
3667 for (int j = 0; j < out_cnt; j++)
3668 {
3669 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
3670 {
3671 struct stat outfile_stat;
3672
3673 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
3674 {
3675 if (outfile_stat.st_ctime == out_info[j].ctime)
3676 {
3677 out_info_new[i].ctime = out_info[j].ctime;
3678 out_info_new[i].seek = out_info[j].seek;
3679 }
3680 }
3681 }
3682 }
3683 }
3684 }
3685
3686 local_free (out_info);
3687 local_free (out_files);
3688
3689 out_files = out_files_new;
3690 out_cnt = out_cnt_new;
3691 out_info = out_info_new;
3692
3693 folder_mtime = outfile_check_stat.st_mtime;
3694 }
3695
3696 for (int j = 0; j < out_cnt; j++)
3697 {
3698 FILE *fp = fopen (out_info[j].file_name, "rb");
3699
3700 if (fp != NULL)
3701 {
3702 //hc_thread_mutex_lock (mux_display);
3703
3704 #ifdef _POSIX
3705 struct stat outfile_stat;
3706
3707 fstat (fileno (fp), &outfile_stat);
3708 #endif
3709
3710 #ifdef _WIN
3711 struct stat64 outfile_stat;
3712
3713 _fstat64 (fileno (fp), &outfile_stat);
3714 #endif
3715
3716 if (outfile_stat.st_ctime > out_info[j].ctime)
3717 {
3718 out_info[j].ctime = outfile_stat.st_ctime;
3719 out_info[j].seek = 0;
3720 }
3721
3722 fseek (fp, out_info[j].seek, SEEK_SET);
3723
3724 while (!feof (fp))
3725 {
3726 char line_buf[BUFSIZ];
3727
3728 memset (line_buf, 0, BUFSIZ);
3729
3730 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
3731
3732 if (ptr == NULL) break;
3733
3734 int line_len = strlen (line_buf);
3735
3736 if (line_len <= 0) continue;
3737
3738 int iter = MAX_CUT_TRIES;
3739
3740 for (uint i = line_len - 1; i && iter; i--, line_len--)
3741 {
3742 if (line_buf[i] != separator) continue;
3743
3744 int parser_status = PARSER_OK;
3745
3746 if ((hash_mode != 2500) && (hash_mode != 6800))
3747 {
3748 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
3749 }
3750
3751 uint found = 0;
3752
3753 if (parser_status == PARSER_OK)
3754 {
3755 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
3756 {
3757 if (data.salts_shown[salt_pos] == 1) continue;
3758
3759 salt_t *salt_buf = &data.salts_buf[salt_pos];
3760
3761 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
3762 {
3763 uint idx = salt_buf->digests_offset + digest_pos;
3764
3765 if (data.digests_shown[idx] == 1) continue;
3766
3767 uint cracked = 0;
3768
3769 if (hash_mode == 6800)
3770 {
3771 if (i == salt_buf->salt_len)
3772 {
3773 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3774 }
3775 }
3776 else if (hash_mode == 2500)
3777 {
3778 // BSSID : MAC1 : MAC2 (:plain)
3779 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
3780 {
3781 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3782
3783 if (!cracked) continue;
3784
3785 // now compare MAC1 and MAC2 too, since we have this additional info
3786 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
3787 char *mac2_pos = mac1_pos + 12 + 1;
3788
3789 wpa_t *wpas = (wpa_t *) data.esalts_buf;
3790 wpa_t *wpa = &wpas[salt_pos];
3791
3792 uint pke[25];
3793
3794 char *pke_ptr = (char *) pke;
3795
3796 for (uint i = 0; i < 25; i++)
3797 {
3798 pke[i] = byte_swap_32 (wpa->pke[i]);
3799 }
3800
3801 unsigned char mac1[6];
3802 unsigned char mac2[6];
3803
3804 memcpy (mac1, pke_ptr + 23, 6);
3805 memcpy (mac2, pke_ptr + 29, 6);
3806
3807 // compare hex string(s) vs binary MAC address(es)
3808
3809 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3810 {
3811 if (mac1[i] != (unsigned char) hex_to_char (&mac1_pos[j]))
3812 {
3813 cracked = 0;
3814 break;
3815 }
3816 }
3817
3818 // early skip ;)
3819 if (!cracked) continue;
3820
3821 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3822 {
3823 if (mac2[i] != (unsigned char) hex_to_char (&mac2_pos[j]))
3824 {
3825 cracked = 0;
3826 break;
3827 }
3828 }
3829 }
3830 }
3831 else
3832 {
3833 char *digests_buf_ptr = (char *) data.digests_buf;
3834
3835 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
3836
3837 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
3838 }
3839
3840 if (cracked == 1)
3841 {
3842 found = 1;
3843
3844 data.digests_shown[idx] = 1;
3845
3846 data.digests_done++;
3847
3848 salt_buf->digests_done++;
3849
3850 if (salt_buf->digests_done == salt_buf->digests_cnt)
3851 {
3852 data.salts_shown[salt_pos] = 1;
3853
3854 data.salts_done++;
3855
3856 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
3857 }
3858 }
3859 }
3860
3861 if (data.devices_status == STATUS_CRACKED) break;
3862 }
3863 }
3864
3865 if (found) break;
3866
3867 if (data.devices_status == STATUS_CRACKED) break;
3868
3869 iter--;
3870 }
3871
3872 if (data.devices_status == STATUS_CRACKED) break;
3873 }
3874
3875 out_info[j].seek = ftell (fp);
3876
3877 //hc_thread_mutex_unlock (mux_display);
3878
3879 fclose (fp);
3880 }
3881 }
3882 }
3883 }
3884
3885 check_left = outfile_check_timer;
3886 }
3887 }
3888
3889 if (esalt_size) local_free (hash_buf.esalt);
3890
3891 if (isSalted) local_free (hash_buf.salt);
3892
3893 local_free (hash_buf.digest);
3894
3895 local_free (out_info);
3896
3897 local_free (out_files);
3898
3899 p = NULL;
3900
3901 return (p);
3902 }
3903
3904 static uint get_work (hc_device_param_t *device_param, const uint64_t max)
3905 {
3906 hc_thread_mutex_lock (mux_dispatcher);
3907
3908 const uint64_t words_cur = data.words_cur;
3909 const uint64_t words_base = (data.limit == 0) ? data.words_base : data.limit;
3910
3911 device_param->words_off = words_cur;
3912
3913 const uint64_t words_left = words_base - words_cur;
3914
3915 if (data.kernel_blocks_all > words_left)
3916 {
3917 if (data.kernel_blocks_div == 0)
3918 {
3919 data.kernel_blocks_div = find_kernel_blocks_div (words_left, data.kernel_blocks_all);
3920 }
3921 }
3922
3923 if (data.kernel_blocks_div)
3924 {
3925 if (device_param->kernel_blocks == device_param->kernel_blocks_user)
3926 {
3927 const uint32_t kernel_blocks_new = (float) device_param->kernel_blocks * data.kernel_blocks_div;
3928 const uint32_t kernel_power_new = kernel_blocks_new;
3929
3930 if (kernel_blocks_new < device_param->kernel_blocks)
3931 {
3932 device_param->kernel_blocks = kernel_blocks_new;
3933 device_param->kernel_power = kernel_power_new;
3934 }
3935 }
3936 }
3937
3938 const uint kernel_blocks = device_param->kernel_blocks;
3939
3940 uint work = MIN (words_left, kernel_blocks);
3941
3942 work = MIN (work, max);
3943
3944 data.words_cur += work;
3945
3946 hc_thread_mutex_unlock (mux_dispatcher);
3947
3948 return work;
3949 }
3950
3951 static void *thread_calc_stdin (void *p)
3952 {
3953 hc_device_param_t *device_param = (hc_device_param_t *) p;
3954
3955 const uint attack_kern = data.attack_kern;
3956
3957 const uint kernel_blocks = device_param->kernel_blocks;
3958
3959 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3960 {
3961 hc_thread_mutex_lock (mux_dispatcher);
3962
3963 if (feof (stdin) != 0)
3964 {
3965 hc_thread_mutex_unlock (mux_dispatcher);
3966
3967 break;
3968 }
3969
3970 uint words_cur = 0;
3971
3972 while (words_cur < kernel_blocks)
3973 {
3974 char buf[BUFSIZ];
3975
3976 char *line_buf = fgets (buf, sizeof (buf), stdin);
3977
3978 if (line_buf == NULL) break;
3979
3980 uint line_len = in_superchop (line_buf);
3981
3982 line_len = convert_from_hex (line_buf, line_len);
3983
3984 // post-process rule engine
3985
3986 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3987 {
3988 char rule_buf_out[BLOCK_SIZE];
3989
3990 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3991
3992 int rule_len_out = -1;
3993
3994 if (line_len < BLOCK_SIZE)
3995 {
3996 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
3997 }
3998
3999 if (rule_len_out < 0) continue;
4000
4001 line_buf = rule_buf_out;
4002 line_len = rule_len_out;
4003 }
4004
4005 if (line_len > PW_MAX)
4006 {
4007 continue;
4008 }
4009
4010 if (attack_kern == ATTACK_KERN_STRAIGHT)
4011 {
4012 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4013 {
4014 hc_thread_mutex_lock (mux_counter);
4015
4016 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4017 {
4018 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4019 }
4020
4021 hc_thread_mutex_unlock (mux_counter);
4022
4023 continue;
4024 }
4025 }
4026 else if (attack_kern == ATTACK_KERN_COMBI)
4027 {
4028 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4029 // since we still need to combine the plains
4030
4031 if (line_len > data.pw_max)
4032 {
4033 hc_thread_mutex_lock (mux_counter);
4034
4035 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4036 {
4037 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4038 }
4039
4040 hc_thread_mutex_unlock (mux_counter);
4041
4042 continue;
4043 }
4044 }
4045
4046 device_param->pw_add (device_param, (uint8_t *) line_buf, line_len);
4047
4048 words_cur++;
4049
4050 if (data.devices_status == STATUS_CRACKED) break;
4051 if (data.devices_status == STATUS_ABORTED) break;
4052 if (data.devices_status == STATUS_QUIT) break;
4053 if (data.devices_status == STATUS_BYPASS) break;
4054 }
4055
4056 hc_thread_mutex_unlock (mux_dispatcher);
4057
4058 if (data.devices_status == STATUS_CRACKED) break;
4059 if (data.devices_status == STATUS_ABORTED) break;
4060 if (data.devices_status == STATUS_QUIT) break;
4061 if (data.devices_status == STATUS_BYPASS) break;
4062
4063 // we need 2 flushing because we have two independant caches and it can occur
4064 // that one buffer is already at threshold plus for that length also exists
4065 // more data in the 2nd buffer so it would overflow
4066
4067 // flush session 1
4068
4069 {
4070 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4071 {
4072 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4073
4074 const uint pw_cache_cnt = pw_cache->cnt;
4075
4076 if (pw_cache_cnt == 0) continue;
4077
4078 pw_cache->cnt = 0;
4079
4080 uint pws_cnt = device_param->pws_cnt;
4081
4082 pw_t *pw = device_param->pws_buf + pws_cnt;
4083
4084 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4085
4086 pw->pw_len = pw_len;
4087
4088 uint pw_cnt = device_param->pw_cnt;
4089
4090 pw_cnt += pw_cache_cnt;
4091
4092 device_param->pw_cnt = pw_cnt;
4093
4094 pws_cnt++;
4095
4096 device_param->pws_cnt = pws_cnt;
4097
4098 if (pws_cnt == device_param->kernel_power_user) break;
4099 }
4100
4101 const uint pw_cnt = device_param->pw_cnt;
4102 const uint pws_cnt = device_param->pws_cnt;
4103
4104 if (pws_cnt)
4105 {
4106 run_copy (device_param, pws_cnt);
4107
4108 run_cracker (device_param, pw_cnt, pws_cnt);
4109
4110 device_param->pw_cnt = 0;
4111 device_param->pws_cnt = 0;
4112 }
4113 }
4114
4115 // flush session 2
4116
4117 {
4118 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4119 {
4120 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4121
4122 const uint pw_cache_cnt = pw_cache->cnt;
4123
4124 if (pw_cache_cnt == 0) continue;
4125
4126 pw_cache->cnt = 0;
4127
4128 uint pws_cnt = device_param->pws_cnt;
4129
4130 pw_t *pw = device_param->pws_buf + pws_cnt;
4131
4132 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4133
4134 pw->pw_len = pw_len;
4135
4136 uint pw_cnt = device_param->pw_cnt;
4137
4138 pw_cnt += pw_cache_cnt;
4139
4140 device_param->pw_cnt = pw_cnt;
4141
4142 pws_cnt++;
4143
4144 device_param->pws_cnt = pws_cnt;
4145 }
4146
4147 const uint pw_cnt = device_param->pw_cnt;
4148 const uint pws_cnt = device_param->pws_cnt;
4149
4150 if (pws_cnt)
4151 {
4152 run_copy (device_param, pws_cnt);
4153
4154 run_cracker (device_param, pw_cnt, pws_cnt);
4155
4156 device_param->pw_cnt = 0;
4157 device_param->pws_cnt = 0;
4158 }
4159 }
4160 }
4161
4162 return NULL;
4163 }
4164
4165 static void *thread_calc (void *p)
4166 {
4167 hc_device_param_t *device_param = (hc_device_param_t *) p;
4168
4169 const uint attack_mode = data.attack_mode;
4170 const uint attack_kern = data.attack_kern;
4171
4172 if (attack_mode == ATTACK_MODE_BF)
4173 {
4174 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4175 {
4176 const uint work = get_work (device_param, -1);
4177
4178 if (work == 0) break;
4179
4180 const uint64_t words_off = device_param->words_off;
4181 const uint64_t words_fin = words_off + work;
4182
4183 const uint pw_cnt = work;
4184 const uint pws_cnt = work;
4185
4186 device_param->pw_cnt = pw_cnt;
4187 device_param->pws_cnt = pws_cnt;
4188
4189 if (pws_cnt)
4190 {
4191 run_copy (device_param, pws_cnt);
4192
4193 run_cracker (device_param, pw_cnt, pws_cnt);
4194
4195 device_param->pw_cnt = 0;
4196 device_param->pws_cnt = 0;
4197 }
4198
4199 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4200
4201 if (data.devices_status == STATUS_CRACKED) break;
4202 if (data.devices_status == STATUS_ABORTED) break;
4203 if (data.devices_status == STATUS_QUIT) break;
4204 if (data.devices_status == STATUS_BYPASS) break;
4205
4206 device_param->words_done = words_fin;
4207 }
4208 }
4209 else
4210 {
4211 const uint segment_size = data.segment_size;
4212
4213 char *dictfile = data.dictfile;
4214
4215 if (attack_mode == ATTACK_MODE_COMBI)
4216 {
4217 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4218 {
4219 dictfile = data.dictfile2;
4220 }
4221 }
4222
4223 FILE *fd = fopen (dictfile, "rb");
4224
4225 if (fd == NULL)
4226 {
4227 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4228
4229 return NULL;
4230 }
4231
4232 if (attack_mode == ATTACK_MODE_COMBI)
4233 {
4234 const uint combs_mode = data.combs_mode;
4235
4236 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4237 {
4238 const char *dictfilec = data.dictfile2;
4239
4240 FILE *combs_fp = fopen (dictfilec, "rb");
4241
4242 if (combs_fp == NULL)
4243 {
4244 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4245
4246 fclose (fd);
4247
4248 return NULL;
4249 }
4250
4251 device_param->combs_fp = combs_fp;
4252 }
4253 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4254 {
4255 const char *dictfilec = data.dictfile;
4256
4257 FILE *combs_fp = fopen (dictfilec, "rb");
4258
4259 if (combs_fp == NULL)
4260 {
4261 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4262
4263 fclose (fd);
4264
4265 return NULL;
4266 }
4267
4268 device_param->combs_fp = combs_fp;
4269 }
4270 }
4271
4272 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4273
4274 wl_data->buf = (char *) mymalloc (segment_size);
4275 wl_data->avail = segment_size;
4276 wl_data->incr = segment_size;
4277 wl_data->cnt = 0;
4278 wl_data->pos = 0;
4279
4280 uint64_t words_cur = 0;
4281
4282 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4283 {
4284 uint64_t words_off = 0;
4285 uint64_t words_fin = 0;
4286
4287 uint64_t max = -1;
4288
4289 while (max)
4290 {
4291 const uint work = get_work (device_param, max);
4292
4293 if (work == 0) break;
4294
4295 words_off = device_param->words_off;
4296 words_fin = words_off + work;
4297
4298 char *line_buf;
4299 uint line_len;
4300
4301 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4302
4303 max = 0;
4304
4305 for ( ; words_cur < words_fin; words_cur++)
4306 {
4307 get_next_word (wl_data, fd, &line_buf, &line_len);
4308
4309 line_len = convert_from_hex (line_buf, line_len);
4310
4311 // post-process rule engine
4312
4313 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4314 {
4315 char rule_buf_out[BLOCK_SIZE];
4316
4317 memset (rule_buf_out, 0, sizeof (rule_buf_out));
4318
4319 int rule_len_out = -1;
4320
4321 if (line_len < BLOCK_SIZE)
4322 {
4323 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4324 }
4325
4326 if (rule_len_out < 0) continue;
4327
4328 line_buf = rule_buf_out;
4329 line_len = rule_len_out;
4330 }
4331
4332 if (attack_kern == ATTACK_KERN_STRAIGHT)
4333 {
4334 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4335 {
4336 max++;
4337
4338 hc_thread_mutex_lock (mux_counter);
4339
4340 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4341 {
4342 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4343 }
4344
4345 hc_thread_mutex_unlock (mux_counter);
4346
4347 continue;
4348 }
4349 }
4350 else if (attack_kern == ATTACK_KERN_COMBI)
4351 {
4352 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4353 // since we still need to combine the plains
4354
4355 if (line_len > data.pw_max)
4356 {
4357 max++;
4358
4359 hc_thread_mutex_lock (mux_counter);
4360
4361 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4362 {
4363 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4364 }
4365
4366 hc_thread_mutex_unlock (mux_counter);
4367
4368 continue;
4369 }
4370 }
4371
4372 device_param->pw_add (device_param, (uint8_t *) line_buf, line_len);
4373
4374 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4375
4376 if (data.devices_status == STATUS_CRACKED) break;
4377 if (data.devices_status == STATUS_ABORTED) break;
4378 if (data.devices_status == STATUS_QUIT) break;
4379 if (data.devices_status == STATUS_BYPASS) break;
4380 }
4381
4382 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4383
4384 if (data.devices_status == STATUS_CRACKED) break;
4385 if (data.devices_status == STATUS_ABORTED) break;
4386 if (data.devices_status == STATUS_QUIT) break;
4387 if (data.devices_status == STATUS_BYPASS) break;
4388 }
4389
4390 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4391
4392 if (data.devices_status == STATUS_CRACKED) break;
4393 if (data.devices_status == STATUS_ABORTED) break;
4394 if (data.devices_status == STATUS_QUIT) break;
4395 if (data.devices_status == STATUS_BYPASS) break;
4396
4397 // we need 2 flushing because we have two independant caches and it can occur
4398 // that one buffer is already at threshold plus for that length also exists
4399 // more data in the 2nd buffer so it would overflow
4400
4401 //
4402 // flush session 1
4403 //
4404
4405 {
4406 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4407 {
4408 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4409
4410 const uint pw_cache_cnt = pw_cache->cnt;
4411
4412 if (pw_cache_cnt == 0) continue;
4413
4414 pw_cache->cnt = 0;
4415
4416 uint pws_cnt = device_param->pws_cnt;
4417
4418 pw_t *pw = device_param->pws_buf + pws_cnt;
4419
4420 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4421
4422 pw->pw_len = pw_len;
4423
4424 uint pw_cnt = device_param->pw_cnt;
4425
4426 pw_cnt += pw_cache_cnt;
4427
4428 device_param->pw_cnt = pw_cnt;
4429
4430 pws_cnt++;
4431
4432 device_param->pws_cnt = pws_cnt;
4433
4434 if (pws_cnt == device_param->kernel_power_user) break;
4435 }
4436
4437 const uint pw_cnt = device_param->pw_cnt;
4438 const uint pws_cnt = device_param->pws_cnt;
4439
4440 if (pws_cnt)
4441 {
4442 run_copy (device_param, pws_cnt);
4443
4444 run_cracker (device_param, pw_cnt, pws_cnt);
4445
4446 device_param->pw_cnt = 0;
4447 device_param->pws_cnt = 0;
4448 }
4449
4450 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4451
4452 if (data.devices_status == STATUS_CRACKED) break;
4453 if (data.devices_status == STATUS_ABORTED) break;
4454 if (data.devices_status == STATUS_QUIT) break;
4455 if (data.devices_status == STATUS_BYPASS) break;
4456 }
4457
4458 //
4459 // flush session 2
4460 //
4461
4462 {
4463 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4464 {
4465 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4466
4467 const uint pw_cache_cnt = pw_cache->cnt;
4468
4469 if (pw_cache_cnt == 0) continue;
4470
4471 pw_cache->cnt = 0;
4472
4473 uint pws_cnt = device_param->pws_cnt;
4474
4475 pw_t *pw = device_param->pws_buf + pws_cnt;
4476
4477 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4478
4479 pw->pw_len = pw_len;
4480
4481 uint pw_cnt = device_param->pw_cnt;
4482
4483 pw_cnt += pw_cache_cnt;
4484
4485 device_param->pw_cnt = pw_cnt;
4486
4487 pws_cnt++;
4488
4489 device_param->pws_cnt = pws_cnt;
4490 }
4491
4492 const uint pw_cnt = device_param->pw_cnt;
4493 const uint pws_cnt = device_param->pws_cnt;
4494
4495 if (pws_cnt)
4496 {
4497 run_copy (device_param, pws_cnt);
4498
4499 run_cracker (device_param, pw_cnt, pws_cnt);
4500
4501 device_param->pw_cnt = 0;
4502 device_param->pws_cnt = 0;
4503 }
4504
4505 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4506
4507 if (data.devices_status == STATUS_CRACKED) break;
4508 if (data.devices_status == STATUS_ABORTED) break;
4509 if (data.devices_status == STATUS_QUIT) break;
4510 if (data.devices_status == STATUS_BYPASS) break;
4511 }
4512
4513 if (words_fin == 0) break;
4514
4515 device_param->words_done = words_fin;
4516 }
4517
4518 if (attack_mode == ATTACK_MODE_COMBI)
4519 {
4520 fclose (device_param->combs_fp);
4521 }
4522
4523 free (wl_data->buf);
4524 free (wl_data);
4525
4526 fclose (fd);
4527 }
4528
4529 return NULL;
4530 }
4531
4532 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos, const uint kernel_loops)
4533 {
4534 salt_t *salt_buf = &data.salts_buf[salt_pos];
4535
4536 device_param->kernel_params_buf32[24] = salt_pos;
4537 device_param->kernel_params_buf32[27] = 1;
4538 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4539 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4540 device_param->kernel_params_buf32[30] = 0;
4541 device_param->kernel_params_buf32[31] = 1;
4542
4543 char *dictfile_old = data.dictfile;
4544 char *dictfile2_old = data.dictfile2;
4545 char *mask_old = data.mask;
4546 int attack_mode_old = data.attack_mode;
4547
4548 const char *weak_hash_check = "weak-hash-check";
4549
4550 data.dictfile = (char *) weak_hash_check;
4551 data.dictfile2 = (char *) weak_hash_check;
4552 data.mask = (char *) weak_hash_check;
4553 data.attack_mode = ATTACK_MODE_STRAIGHT;
4554
4555 /**
4556 * run the kernel
4557 */
4558
4559 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4560 {
4561 run_kernel (KERN_RUN_WEAK, device_param, 1);
4562 }
4563 else
4564 {
4565 run_kernel (KERN_RUN_1, device_param, 1);
4566
4567 const uint iter = salt_buf->salt_iter;
4568
4569 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
4570 {
4571 uint loop_left = iter - loop_pos;
4572
4573 loop_left = MIN (loop_left, kernel_loops);
4574
4575 device_param->kernel_params_buf32[25] = loop_pos;
4576 device_param->kernel_params_buf32[26] = loop_left;
4577
4578 run_kernel (KERN_RUN_2, device_param, 1);
4579 }
4580
4581 run_kernel (KERN_RUN_3, device_param, 1);
4582 }
4583
4584 /**
4585 * result
4586 */
4587
4588 check_cracked (device_param, salt_pos);
4589
4590 /**
4591 * cleanup
4592 */
4593
4594 device_param->kernel_params_buf32[24] = 0;
4595 device_param->kernel_params_buf32[25] = 0;
4596 device_param->kernel_params_buf32[26] = 0;
4597 device_param->kernel_params_buf32[27] = 0;
4598 device_param->kernel_params_buf32[28] = 0;
4599 device_param->kernel_params_buf32[29] = 0;
4600 device_param->kernel_params_buf32[30] = 0;
4601 device_param->kernel_params_buf32[31] = 0;
4602
4603 data.dictfile = dictfile_old;
4604 data.dictfile2 = dictfile2_old;
4605 data.mask = mask_old;
4606 data.attack_mode = attack_mode_old;
4607 }
4608
4609 // hlfmt hashcat
4610
4611 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4612 {
4613 if (data.username == 0)
4614 {
4615 *hashbuf_pos = line_buf;
4616 *hashbuf_len = line_len;
4617 }
4618 else
4619 {
4620 char *pos = line_buf;
4621 int len = line_len;
4622
4623 for (int i = 0; i < line_len; i++, pos++, len--)
4624 {
4625 if (line_buf[i] == data.separator)
4626 {
4627 pos++;
4628
4629 len--;
4630
4631 break;
4632 }
4633 }
4634
4635 *hashbuf_pos = pos;
4636 *hashbuf_len = len;
4637 }
4638 }
4639
4640 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4641 {
4642 char *pos = NULL;
4643 int len = 0;
4644
4645 int sep_cnt = 0;
4646
4647 for (int i = 0; i < line_len; i++)
4648 {
4649 if (line_buf[i] == data.separator)
4650 {
4651 sep_cnt++;
4652
4653 continue;
4654 }
4655
4656 if (sep_cnt == 0)
4657 {
4658 if (pos == NULL) pos = line_buf + i;
4659
4660 len++;
4661 }
4662 }
4663
4664 *userbuf_pos = pos;
4665 *userbuf_len = len;
4666 }
4667
4668 // hlfmt pwdump
4669
4670 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
4671 {
4672 int sep_cnt = 0;
4673
4674 int sep2_len = 0;
4675 int sep3_len = 0;
4676
4677 for (int i = 0; i < line_len; i++)
4678 {
4679 if (line_buf[i] == ':')
4680 {
4681 sep_cnt++;
4682
4683 continue;
4684 }
4685
4686 if (sep_cnt == 2) sep2_len++;
4687 if (sep_cnt == 3) sep3_len++;
4688 }
4689
4690 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4691
4692 return 0;
4693 }
4694
4695 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4696 {
4697 char *pos = NULL;
4698 int len = 0;
4699
4700 int sep_cnt = 0;
4701
4702 for (int i = 0; i < line_len; i++)
4703 {
4704 if (line_buf[i] == ':')
4705 {
4706 sep_cnt++;
4707
4708 continue;
4709 }
4710
4711 if (data.hash_mode == 1000)
4712 {
4713 if (sep_cnt == 3)
4714 {
4715 if (pos == NULL) pos = line_buf + i;
4716
4717 len++;
4718 }
4719 }
4720 else if (data.hash_mode == 3000)
4721 {
4722 if (sep_cnt == 2)
4723 {
4724 if (pos == NULL) pos = line_buf + i;
4725
4726 len++;
4727 }
4728 }
4729 }
4730
4731 *hashbuf_pos = pos;
4732 *hashbuf_len = len;
4733 }
4734
4735 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4736 {
4737 char *pos = NULL;
4738 int len = 0;
4739
4740 int sep_cnt = 0;
4741
4742 for (int i = 0; i < line_len; i++)
4743 {
4744 if (line_buf[i] == ':')
4745 {
4746 sep_cnt++;
4747
4748 continue;
4749 }
4750
4751 if (sep_cnt == 0)
4752 {
4753 if (pos == NULL) pos = line_buf + i;
4754
4755 len++;
4756 }
4757 }
4758
4759 *userbuf_pos = pos;
4760 *userbuf_len = len;
4761 }
4762
4763 // hlfmt passwd
4764
4765 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
4766 {
4767 int sep_cnt = 0;
4768
4769 char sep5_first = 0;
4770 char sep6_first = 0;
4771
4772 for (int i = 0; i < line_len; i++)
4773 {
4774 if (line_buf[i] == ':')
4775 {
4776 sep_cnt++;
4777
4778 continue;
4779 }
4780
4781 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
4782 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
4783 }
4784
4785 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
4786
4787 return 0;
4788 }
4789
4790 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4791 {
4792 char *pos = NULL;
4793 int len = 0;
4794
4795 int sep_cnt = 0;
4796
4797 for (int i = 0; i < line_len; i++)
4798 {
4799 if (line_buf[i] == ':')
4800 {
4801 sep_cnt++;
4802
4803 continue;
4804 }
4805
4806 if (sep_cnt == 1)
4807 {
4808 if (pos == NULL) pos = line_buf + i;
4809
4810 len++;
4811 }
4812 }
4813
4814 *hashbuf_pos = pos;
4815 *hashbuf_len = len;
4816 }
4817
4818 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4819 {
4820 char *pos = NULL;
4821 int len = 0;
4822
4823 int sep_cnt = 0;
4824
4825 for (int i = 0; i < line_len; i++)
4826 {
4827 if (line_buf[i] == ':')
4828 {
4829 sep_cnt++;
4830
4831 continue;
4832 }
4833
4834 if (sep_cnt == 0)
4835 {
4836 if (pos == NULL) pos = line_buf + i;
4837
4838 len++;
4839 }
4840 }
4841
4842 *userbuf_pos = pos;
4843 *userbuf_len = len;
4844 }
4845
4846 // hlfmt shadow
4847
4848 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
4849 {
4850 int sep_cnt = 0;
4851
4852 for (int i = 0; i < line_len; i++)
4853 {
4854 if (line_buf[i] == ':') sep_cnt++;
4855 }
4856
4857 if (sep_cnt == 8) return 1;
4858
4859 return 0;
4860 }
4861
4862 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4863 {
4864 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
4865 }
4866
4867 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4868 {
4869 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
4870 }
4871
4872 // hlfmt main
4873
4874 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4875 {
4876 switch (hashfile_format)
4877 {
4878 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4879 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4880 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4881 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4882 }
4883 }
4884
4885 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4886 {
4887 switch (hashfile_format)
4888 {
4889 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
4890 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
4891 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
4892 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
4893 }
4894 }
4895
4896 static uint hlfmt_detect (FILE *fp, uint max_check)
4897 {
4898 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
4899
4900 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
4901 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
4902
4903 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
4904
4905 uint num_check = 0;
4906
4907 while (!feof (fp))
4908 {
4909 char line_buf[BUFSIZ];
4910
4911 int line_len = fgetl (fp, line_buf);
4912
4913 if (line_len == 0) continue;
4914
4915 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
4916 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
4917 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
4918
4919 if (num_check == max_check) break;
4920
4921 num_check++;
4922 }
4923
4924 uint hashlist_format = HLFMT_HASHCAT;
4925
4926 for (int i = 1; i < HLFMTS_CNT; i++)
4927 {
4928 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
4929
4930 hashlist_format = i;
4931 }
4932
4933 free (formats_cnt);
4934
4935 return hashlist_format;
4936 }
4937
4938 /**
4939 * some further helper function
4940 */
4941
4942 // wrapper around mymalloc for ADL
4943
4944 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
4945 {
4946 return mymalloc (iSize);
4947 }
4948
4949 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)
4950 {
4951 uint64_t collisions = 0;
4952
4953 const uint dgst_pos0 = data.dgst_pos0;
4954 const uint dgst_pos1 = data.dgst_pos1;
4955 const uint dgst_pos2 = data.dgst_pos2;
4956 const uint dgst_pos3 = data.dgst_pos3;
4957
4958 memset (bitmap_a, 0, bitmap_size);
4959 memset (bitmap_b, 0, bitmap_size);
4960 memset (bitmap_c, 0, bitmap_size);
4961 memset (bitmap_d, 0, bitmap_size);
4962
4963 for (uint i = 0; i < digests_cnt; i++)
4964 {
4965 uint *digest_ptr = (uint *) digests_buf_ptr;
4966
4967 digests_buf_ptr += dgst_size;
4968
4969 const uint val0 = 1 << (digest_ptr[dgst_pos0] & 0x1f);
4970 const uint val1 = 1 << (digest_ptr[dgst_pos1] & 0x1f);
4971 const uint val2 = 1 << (digest_ptr[dgst_pos2] & 0x1f);
4972 const uint val3 = 1 << (digest_ptr[dgst_pos3] & 0x1f);
4973
4974 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
4975 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
4976 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
4977 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
4978
4979 if (bitmap_a[idx0] & val0) collisions++;
4980 if (bitmap_b[idx1] & val1) collisions++;
4981 if (bitmap_c[idx2] & val2) collisions++;
4982 if (bitmap_d[idx3] & val3) collisions++;
4983
4984 bitmap_a[idx0] |= val0;
4985 bitmap_b[idx1] |= val1;
4986 bitmap_c[idx2] |= val2;
4987 bitmap_d[idx3] |= val3;
4988
4989 if (collisions >= collisions_max) return 0x7fffffff;
4990 }
4991
4992 return collisions;
4993 }
4994
4995 /**
4996 * main
4997 */
4998
4999 int main (int argc, char **argv)
5000 {
5001 /**
5002 * To help users a bit
5003 */
5004
5005 char *compute = getenv ("COMPUTE");
5006
5007 if (compute)
5008 {
5009 char display[100];
5010
5011 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5012
5013 putenv (display);
5014 }
5015 else
5016 {
5017 if (getenv ("DISPLAY") == NULL)
5018 putenv ((char *) "DISPLAY=:0");
5019 }
5020
5021 /*
5022 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5023 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5024
5025 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5026 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5027 */
5028
5029 /**
5030 * Real init
5031 */
5032
5033 memset (&data, 0, sizeof (hc_global_data_t));
5034
5035 time_t proc_start;
5036
5037 time (&proc_start);
5038
5039 data.proc_start = proc_start;
5040
5041 int myargc = argc;
5042 char **myargv = argv;
5043
5044 hc_thread_mutex_init (mux_dispatcher);
5045 hc_thread_mutex_init (mux_counter);
5046 hc_thread_mutex_init (mux_display);
5047 hc_thread_mutex_init (mux_adl);
5048
5049 /**
5050 * commandline parameters
5051 */
5052
5053 uint usage = USAGE;
5054 uint version = VERSION;
5055 uint quiet = QUIET;
5056 uint benchmark = BENCHMARK;
5057 uint benchmark_mode = BENCHMARK_MODE;
5058 uint show = SHOW;
5059 uint left = LEFT;
5060 uint username = USERNAME;
5061 uint remove = REMOVE;
5062 uint remove_timer = REMOVE_TIMER;
5063 uint64_t skip = SKIP;
5064 uint64_t limit = LIMIT;
5065 uint keyspace = KEYSPACE;
5066 uint potfile_disable = POTFILE_DISABLE;
5067 uint debug_mode = DEBUG_MODE;
5068 char *debug_file = NULL;
5069 char *induction_dir = NULL;
5070 char *outfile_check_dir = NULL;
5071 uint force = FORCE;
5072 uint runtime = RUNTIME;
5073 uint hash_mode = HASH_MODE;
5074 uint attack_mode = ATTACK_MODE;
5075 uint markov_disable = MARKOV_DISABLE;
5076 uint markov_classic = MARKOV_CLASSIC;
5077 uint markov_threshold = MARKOV_THRESHOLD;
5078 char *markov_hcstat = NULL;
5079 char *outfile = NULL;
5080 uint outfile_format = OUTFILE_FORMAT;
5081 uint outfile_autohex = OUTFILE_AUTOHEX;
5082 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5083 uint restore = RESTORE;
5084 uint restore_timer = RESTORE_TIMER;
5085 uint restore_disable = RESTORE_DISABLE;
5086 uint status = STATUS;
5087 uint status_timer = STATUS_TIMER;
5088 uint status_automat = STATUS_AUTOMAT;
5089 uint loopback = LOOPBACK;
5090 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5091 char *session = NULL;
5092 uint hex_charset = HEX_CHARSET;
5093 uint hex_salt = HEX_SALT;
5094 uint hex_wordlist = HEX_WORDLIST;
5095 uint rp_gen = RP_GEN;
5096 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5097 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5098 uint rp_gen_seed = RP_GEN_SEED;
5099 char *rule_buf_l = (char *) RULE_BUF_L;
5100 char *rule_buf_r = (char *) RULE_BUF_R;
5101 uint increment = INCREMENT;
5102 uint increment_min = INCREMENT_MIN;
5103 uint increment_max = INCREMENT_MAX;
5104 char *cpu_affinity = NULL;
5105 char *opencl_devices = NULL;
5106 char *opencl_platforms = NULL;
5107 char *opencl_device_types = NULL;
5108 char *truecrypt_keyfiles = NULL;
5109 uint workload_profile = WORKLOAD_PROFILE;
5110 uint kernel_accel = KERNEL_ACCEL;
5111 uint kernel_loops = KERNEL_LOOPS;
5112 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5113 uint gpu_temp_abort = GPU_TEMP_ABORT;
5114 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5115 uint powertune_enable = POWERTUNE_ENABLE;
5116 uint logfile_disable = LOGFILE_DISABLE;
5117 uint segment_size = SEGMENT_SIZE;
5118 uint scrypt_tmto = SCRYPT_TMTO;
5119 char separator = SEPARATOR;
5120 uint bitmap_min = BITMAP_MIN;
5121 uint bitmap_max = BITMAP_MAX;
5122 char *custom_charset_1 = NULL;
5123 char *custom_charset_2 = NULL;
5124 char *custom_charset_3 = NULL;
5125 char *custom_charset_4 = NULL;
5126
5127 #define IDX_HELP 'h'
5128 #define IDX_VERSION 'V'
5129 #define IDX_VERSION_LOWER 'v'
5130 #define IDX_QUIET 0xff02
5131 #define IDX_SHOW 0xff03
5132 #define IDX_LEFT 0xff04
5133 #define IDX_REMOVE 0xff05
5134 #define IDX_REMOVE_TIMER 0xff37
5135 #define IDX_SKIP 's'
5136 #define IDX_LIMIT 'l'
5137 #define IDX_KEYSPACE 0xff35
5138 #define IDX_POTFILE_DISABLE 0xff06
5139 #define IDX_DEBUG_MODE 0xff43
5140 #define IDX_DEBUG_FILE 0xff44
5141 #define IDX_INDUCTION_DIR 0xff46
5142 #define IDX_OUTFILE_CHECK_DIR 0xff47
5143 #define IDX_USERNAME 0xff07
5144 #define IDX_FORCE 0xff08
5145 #define IDX_RUNTIME 0xff09
5146 #define IDX_BENCHMARK 'b'
5147 #define IDX_BENCHMARK_MODE 0xff32
5148 #define IDX_HASH_MODE 'm'
5149 #define IDX_ATTACK_MODE 'a'
5150 #define IDX_RP_FILE 'r'
5151 #define IDX_RP_GEN 'g'
5152 #define IDX_RP_GEN_FUNC_MIN 0xff10
5153 #define IDX_RP_GEN_FUNC_MAX 0xff11
5154 #define IDX_RP_GEN_SEED 0xff34
5155 #define IDX_RULE_BUF_L 'j'
5156 #define IDX_RULE_BUF_R 'k'
5157 #define IDX_INCREMENT 'i'
5158 #define IDX_INCREMENT_MIN 0xff12
5159 #define IDX_INCREMENT_MAX 0xff13
5160 #define IDX_OUTFILE 'o'
5161 #define IDX_OUTFILE_FORMAT 0xff14
5162 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5163 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5164 #define IDX_RESTORE 0xff15
5165 #define IDX_RESTORE_DISABLE 0xff27
5166 #define IDX_STATUS 0xff17
5167 #define IDX_STATUS_TIMER 0xff18
5168 #define IDX_STATUS_AUTOMAT 0xff50
5169 #define IDX_LOOPBACK 0xff38
5170 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5171 #define IDX_SESSION 0xff19
5172 #define IDX_HEX_CHARSET 0xff20
5173 #define IDX_HEX_SALT 0xff21
5174 #define IDX_HEX_WORDLIST 0xff40
5175 #define IDX_MARKOV_DISABLE 0xff22
5176 #define IDX_MARKOV_CLASSIC 0xff23
5177 #define IDX_MARKOV_THRESHOLD 't'
5178 #define IDX_MARKOV_HCSTAT 0xff24
5179 #define IDX_CPU_AFFINITY 0xff25
5180 #define IDX_OPENCL_DEVICES 'd'
5181 #define IDX_OPENCL_PLATFORMS 0xff72
5182 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5183 #define IDX_WORKLOAD_PROFILE 'w'
5184 #define IDX_KERNEL_ACCEL 'n'
5185 #define IDX_KERNEL_LOOPS 'u'
5186 #define IDX_GPU_TEMP_DISABLE 0xff29
5187 #define IDX_GPU_TEMP_ABORT 0xff30
5188 #define IDX_GPU_TEMP_RETAIN 0xff31
5189 #define IDX_POWERTUNE_ENABLE 0xff41
5190 #define IDX_LOGFILE_DISABLE 0xff51
5191 #define IDX_TRUECRYPT_KEYFILES 0xff52
5192 #define IDX_SCRYPT_TMTO 0xff61
5193 #define IDX_SEGMENT_SIZE 'c'
5194 #define IDX_SEPARATOR 'p'
5195 #define IDX_BITMAP_MIN 0xff70
5196 #define IDX_BITMAP_MAX 0xff71
5197 #define IDX_CUSTOM_CHARSET_1 '1'
5198 #define IDX_CUSTOM_CHARSET_2 '2'
5199 #define IDX_CUSTOM_CHARSET_3 '3'
5200 #define IDX_CUSTOM_CHARSET_4 '4'
5201
5202 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5203
5204 struct option long_options[] =
5205 {
5206 {"help", no_argument, 0, IDX_HELP},
5207 {"version", no_argument, 0, IDX_VERSION},
5208 {"quiet", no_argument, 0, IDX_QUIET},
5209 {"show", no_argument, 0, IDX_SHOW},
5210 {"left", no_argument, 0, IDX_LEFT},
5211 {"username", no_argument, 0, IDX_USERNAME},
5212 {"remove", no_argument, 0, IDX_REMOVE},
5213 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5214 {"skip", required_argument, 0, IDX_SKIP},
5215 {"limit", required_argument, 0, IDX_LIMIT},
5216 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5217 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5218 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5219 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5220 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5221 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5222 {"force", no_argument, 0, IDX_FORCE},
5223 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5224 {"benchmark-mode", required_argument, 0, IDX_BENCHMARK_MODE},
5225 {"restore", no_argument, 0, IDX_RESTORE},
5226 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5227 {"status", no_argument, 0, IDX_STATUS},
5228 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5229 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5230 {"loopback", no_argument, 0, IDX_LOOPBACK},
5231 {"weak-hash-threshold",
5232 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5233 {"session", required_argument, 0, IDX_SESSION},
5234 {"runtime", required_argument, 0, IDX_RUNTIME},
5235 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5236 {"generate-rules-func-min",
5237 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5238 {"generate-rules-func-max",
5239 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5240 {"generate-rules-seed",
5241 required_argument, 0, IDX_RP_GEN_SEED},
5242 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5243 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5244 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5245 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5246 {"rules-file", required_argument, 0, IDX_RP_FILE},
5247 {"outfile", required_argument, 0, IDX_OUTFILE},
5248 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5249 {"outfile-autohex-disable",
5250 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5251 {"outfile-check-timer",
5252 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5253 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5254 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5255 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5256 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5257 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5258 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5259 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5260 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5261 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5262 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5263 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5264 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5265 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5266 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5267 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5268 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5269 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5270 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5271 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5272 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5273 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5274 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5275 // deprecated
5276 {"seperator", required_argument, 0, IDX_SEPARATOR},
5277 {"separator", required_argument, 0, IDX_SEPARATOR},
5278 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5279 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5280 {"increment", no_argument, 0, IDX_INCREMENT},
5281 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5282 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5283 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5284 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5285 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5286 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5287
5288 {0, 0, 0, 0}
5289 };
5290
5291 uint rp_files_cnt = 0;
5292
5293 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5294
5295 int option_index;
5296 int c;
5297
5298 optind = 1;
5299 optopt = 0;
5300 option_index = 0;
5301
5302 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5303 {
5304 switch (c)
5305 {
5306 case IDX_HELP: usage = 1; break;
5307 case IDX_VERSION:
5308 case IDX_VERSION_LOWER: version = 1; break;
5309 case IDX_RESTORE: restore = 1; break;
5310 case IDX_SESSION: session = optarg; break;
5311 case IDX_SHOW: show = 1; break;
5312 case IDX_LEFT: left = 1; break;
5313 case '?': return (-1);
5314 }
5315 }
5316
5317 if (optopt != 0)
5318 {
5319 log_error ("ERROR: Invalid argument specified");
5320
5321 return (-1);
5322 }
5323
5324 /**
5325 * exit functions
5326 */
5327
5328 if (version)
5329 {
5330 log_info (VERSION_TXT);
5331
5332 return (0);
5333 }
5334
5335 if (usage)
5336 {
5337 usage_big_print (PROGNAME);
5338
5339 return (0);
5340 }
5341
5342 /**
5343 * session needs to be set, always!
5344 */
5345
5346 if (session == NULL) session = (char *) PROGNAME;
5347
5348 /**
5349 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5350 */
5351
5352 char *exec_path = get_exec_path ();
5353
5354 #ifdef LINUX
5355
5356 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5357 char *resolved_exec_path = realpath (exec_path, NULL);
5358
5359 char *install_dir = get_install_dir (resolved_exec_path);
5360 char *profile_dir = NULL;
5361 char *session_dir = NULL;
5362 char *shared_dir = NULL;
5363
5364 if (strcmp (install_dir, resolved_install_folder) == 0)
5365 {
5366 struct passwd *pw = getpwuid (getuid ());
5367
5368 const char *homedir = pw->pw_dir;
5369
5370 profile_dir = get_profile_dir (homedir);
5371 session_dir = get_session_dir (profile_dir);
5372 shared_dir = strdup (SHARED_FOLDER);
5373
5374 mkdir (profile_dir, 0700);
5375 mkdir (session_dir, 0700);
5376 }
5377 else
5378 {
5379 profile_dir = install_dir;
5380 session_dir = install_dir;
5381 shared_dir = install_dir;
5382 }
5383
5384 myfree (resolved_install_folder);
5385 myfree (resolved_exec_path);
5386
5387 #else
5388
5389 char *install_dir = get_install_dir (exec_path);
5390 char *profile_dir = install_dir;
5391 char *session_dir = install_dir;
5392 char *shared_dir = install_dir;
5393
5394 #endif
5395
5396 data.install_dir = install_dir;
5397 data.profile_dir = profile_dir;
5398 data.session_dir = session_dir;
5399 data.shared_dir = shared_dir;
5400
5401 myfree (exec_path);
5402
5403 /**
5404 * kernel cache, we need to make sure folder exist
5405 */
5406
5407 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5408
5409 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5410
5411 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5412
5413 mkdir (kernels_folder, 0700);
5414
5415 myfree (kernels_folder);
5416
5417 /**
5418 * session
5419 */
5420
5421 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5422
5423 data.session = session;
5424
5425 char *eff_restore_file = (char *) mymalloc (session_size);
5426 char *new_restore_file = (char *) mymalloc (session_size);
5427
5428 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5429 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5430
5431 data.eff_restore_file = eff_restore_file;
5432 data.new_restore_file = new_restore_file;
5433
5434 if (((show == 1) || (left == 1)) && (restore == 1))
5435 {
5436 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5437 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5438
5439 return (-1);
5440 }
5441
5442 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5443 if ((show == 1) || (left == 1))
5444 {
5445 restore_disable = 1;
5446
5447 restore = 0;
5448 }
5449
5450 data.restore_disable = restore_disable;
5451
5452 restore_data_t *rd = init_restore (argc, argv);
5453
5454 data.rd = rd;
5455
5456 /**
5457 * restore file
5458 */
5459
5460 if (restore == 1)
5461 {
5462 read_restore (eff_restore_file, rd);
5463
5464 if (rd->version_bin < RESTORE_MIN)
5465 {
5466 log_error ("ERROR: Incompatible restore-file version");
5467
5468 return (-1);
5469 }
5470
5471 myargc = rd->argc;
5472 myargv = rd->argv;
5473
5474 #ifdef _POSIX
5475 rd->pid = getpid ();
5476 #elif _WIN
5477 rd->pid = GetCurrentProcessId ();
5478 #endif
5479 }
5480
5481 uint hash_mode_chgd = 0;
5482 uint runtime_chgd = 0;
5483 uint kernel_loops_chgd = 0;
5484 uint kernel_accel_chgd = 0;
5485 uint attack_mode_chgd = 0;
5486 uint outfile_format_chgd = 0;
5487 uint rp_gen_seed_chgd = 0;
5488 uint remove_timer_chgd = 0;
5489 uint increment_min_chgd = 0;
5490 uint increment_max_chgd = 0;
5491 uint gpu_temp_abort_chgd = 0;
5492 uint gpu_temp_retain_chgd = 0;
5493
5494 optind = 1;
5495 optopt = 0;
5496 option_index = 0;
5497
5498 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5499 {
5500 switch (c)
5501 {
5502 //case IDX_HELP: usage = 1; break;
5503 //case IDX_VERSION: version = 1; break;
5504 //case IDX_RESTORE: restore = 1; break;
5505 case IDX_QUIET: quiet = 1; break;
5506 //case IDX_SHOW: show = 1; break;
5507 case IDX_SHOW: break;
5508 //case IDX_LEFT: left = 1; break;
5509 case IDX_LEFT: break;
5510 case IDX_USERNAME: username = 1; break;
5511 case IDX_REMOVE: remove = 1; break;
5512 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5513 remove_timer_chgd = 1; break;
5514 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5515 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5516 case IDX_DEBUG_FILE: debug_file = optarg; break;
5517 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5518 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5519 case IDX_FORCE: force = 1; break;
5520 case IDX_SKIP: skip = atoll (optarg); break;
5521 case IDX_LIMIT: limit = atoll (optarg); break;
5522 case IDX_KEYSPACE: keyspace = 1; break;
5523 case IDX_BENCHMARK: benchmark = 1; break;
5524 case IDX_BENCHMARK_MODE: benchmark_mode = atoi (optarg); break;
5525 case IDX_RESTORE: break;
5526 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5527 case IDX_STATUS: status = 1; break;
5528 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5529 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5530 case IDX_LOOPBACK: loopback = 1; break;
5531 case IDX_WEAK_HASH_THRESHOLD:
5532 weak_hash_threshold = atoi (optarg); break;
5533 //case IDX_SESSION: session = optarg; break;
5534 case IDX_SESSION: break;
5535 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5536 hash_mode_chgd = 1; break;
5537 case IDX_RUNTIME: runtime = atoi (optarg);
5538 runtime_chgd = 1; break;
5539 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5540 attack_mode_chgd = 1; break;
5541 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5542 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5543 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5544 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5545 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5546 rp_gen_seed_chgd = 1; break;
5547 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5548 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5549 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5550 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5551 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5552 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5553 case IDX_OUTFILE: outfile = optarg; break;
5554 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5555 outfile_format_chgd = 1; break;
5556 case IDX_OUTFILE_AUTOHEX_DISABLE:
5557 outfile_autohex = 0; break;
5558 case IDX_OUTFILE_CHECK_TIMER:
5559 outfile_check_timer = atoi (optarg); break;
5560 case IDX_HEX_CHARSET: hex_charset = 1; break;
5561 case IDX_HEX_SALT: hex_salt = 1; break;
5562 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5563 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5564 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5565 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5566 case IDX_OPENCL_DEVICE_TYPES:
5567 opencl_device_types = optarg; break;
5568 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg); break;
5569 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5570 kernel_accel_chgd = 1; break;
5571 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5572 kernel_loops_chgd = 1; break;
5573 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5574 case IDX_GPU_TEMP_ABORT: gpu_temp_abort_chgd = 1;
5575 gpu_temp_abort = atoi (optarg); break;
5576 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain_chgd = 1;
5577 gpu_temp_retain = atoi (optarg); break;
5578 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5579 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5580 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5581 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5582 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5583 case IDX_SEPARATOR: separator = optarg[0]; break;
5584 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5585 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5586 case IDX_INCREMENT: increment = 1; break;
5587 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5588 increment_min_chgd = 1; break;
5589 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5590 increment_max_chgd = 1; break;
5591 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5592 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5593 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5594 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5595
5596 default:
5597 log_error ("ERROR: Invalid argument specified");
5598 return (-1);
5599 }
5600 }
5601
5602 if (optopt != 0)
5603 {
5604 log_error ("ERROR: Invalid argument specified");
5605
5606 return (-1);
5607 }
5608
5609 /**
5610 * Inform user things getting started,
5611 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5612 * - we do not need to check algorithm_pos
5613 */
5614
5615 if (quiet == 0)
5616 {
5617 if (benchmark == 1)
5618 {
5619 log_info ("%s v%.2f starting in benchmark-mode...", PROGNAME, (float) VERSION_BIN / 100);
5620
5621 log_info ("");
5622 }
5623 else if (restore == 1)
5624 {
5625 log_info ("%s v%.2f starting in restore-mode...", PROGNAME, (float) VERSION_BIN / 100);
5626
5627 log_info ("");
5628 }
5629 else
5630 {
5631 log_info ("%s v%.2f starting...", PROGNAME, (float) VERSION_BIN / 100);
5632
5633 log_info ("");
5634 }
5635 }
5636
5637 /**
5638 * sanity check
5639 */
5640
5641 if (attack_mode > 7)
5642 {
5643 log_error ("ERROR: Invalid attack-mode specified");
5644
5645 return (-1);
5646 }
5647
5648 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5649 {
5650 log_error ("ERROR: Invalid runtime specified");
5651
5652 return (-1);
5653 }
5654
5655 if (hash_mode_chgd && hash_mode > 13000) // just added to remove compiler warnings for hash_mode_chgd
5656 {
5657 log_error ("ERROR: Invalid hash-type specified");
5658
5659 return (-1);
5660 }
5661
5662 // renamed hash modes
5663
5664 if (hash_mode_chgd)
5665 {
5666 int n = -1;
5667
5668 switch (hash_mode)
5669 {
5670 case 123: n = 124;
5671 break;
5672 }
5673
5674 if (n >= 0)
5675 {
5676 log_error ("Old -m specified, use -m %d instead", n);
5677
5678 return (-1);
5679 }
5680 }
5681
5682 if (username == 1)
5683 {
5684 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5685 {
5686 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5687
5688 return (-1);
5689 }
5690 }
5691
5692 if (outfile_format > 16)
5693 {
5694 log_error ("ERROR: Invalid outfile-format specified");
5695
5696 return (-1);
5697 }
5698
5699 if (left == 1)
5700 {
5701 if (outfile_format_chgd == 1)
5702 {
5703 if (outfile_format > 1)
5704 {
5705 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5706
5707 return (-1);
5708 }
5709 }
5710 else
5711 {
5712 outfile_format = OUTFILE_FMT_HASH;
5713 }
5714 }
5715
5716 if (show == 1)
5717 {
5718 if (outfile_format_chgd == 1)
5719 {
5720 if ((outfile_format > 7) && (outfile_format < 16))
5721 {
5722 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
5723
5724 return (-1);
5725 }
5726 }
5727 }
5728
5729 if (increment_min < INCREMENT_MIN)
5730 {
5731 log_error ("ERROR: Invalid increment-min specified");
5732
5733 return (-1);
5734 }
5735
5736 if (increment_max > INCREMENT_MAX)
5737 {
5738 log_error ("ERROR: Invalid increment-max specified");
5739
5740 return (-1);
5741 }
5742
5743 if (increment_min > increment_max)
5744 {
5745 log_error ("ERROR: Invalid increment-min specified");
5746
5747 return (-1);
5748 }
5749
5750 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
5751 {
5752 log_error ("ERROR: increment is not allowed in attack-mode 0");
5753
5754 return (-1);
5755 }
5756
5757 if ((increment == 0) && (increment_min_chgd == 1))
5758 {
5759 log_error ("ERROR: increment-min is only supported together with increment switch");
5760
5761 return (-1);
5762 }
5763
5764 if ((increment == 0) && (increment_max_chgd == 1))
5765 {
5766 log_error ("ERROR: increment-max is only supported together with increment switch");
5767
5768 return (-1);
5769 }
5770
5771 if (rp_files_cnt && rp_gen)
5772 {
5773 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
5774
5775 return (-1);
5776 }
5777
5778 if (rp_files_cnt || rp_gen)
5779 {
5780 if (attack_mode != ATTACK_MODE_STRAIGHT)
5781 {
5782 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
5783
5784 return (-1);
5785 }
5786 }
5787
5788 if (rp_gen_func_min > rp_gen_func_max)
5789 {
5790 log_error ("ERROR: Invalid rp-gen-func-min specified");
5791
5792 return (-1);
5793 }
5794
5795 if (kernel_accel_chgd == 1)
5796 {
5797 if (workload_profile != WORKLOAD_PROFILE)
5798 {
5799 log_error ("ERROR: kernel-accel parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5800
5801 return (-1);
5802 }
5803
5804 if (kernel_accel < 1)
5805 {
5806 log_error ("ERROR: Invalid kernel-accel specified");
5807
5808 return (-1);
5809 }
5810
5811 if (kernel_accel > 800)
5812 {
5813 log_error ("ERROR: Invalid kernel-accel specified");
5814
5815 return (-1);
5816 }
5817 }
5818
5819 if (kernel_loops_chgd == 1)
5820 {
5821 if (workload_profile != WORKLOAD_PROFILE)
5822 {
5823 log_error ("ERROR: kernel-loops parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5824
5825 return (-1);
5826 }
5827
5828 if (kernel_loops < 1)
5829 {
5830 log_error ("ERROR: Invalid kernel-loops specified");
5831
5832 return (-1);
5833 }
5834
5835 if (kernel_loops > 1024)
5836 {
5837 log_error ("ERROR: Invalid kernel-loops specified");
5838
5839 return (-1);
5840 }
5841 }
5842
5843 if (benchmark == 1)
5844 {
5845 if (workload_profile != WORKLOAD_PROFILE)
5846 {
5847 log_error ("ERROR: Using the workload-profile in benchmark mode is not allowed");
5848
5849 return (-1);
5850 }
5851 }
5852
5853 if ((workload_profile < 1) || (workload_profile > 3))
5854 {
5855 log_error ("ERROR: workload-profile %i not available", workload_profile);
5856
5857 return (-1);
5858 }
5859
5860 if (show == 1 || left == 1)
5861 {
5862 attack_mode = ATTACK_MODE_NONE;
5863
5864 if (remove == 1)
5865 {
5866 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
5867
5868 return (-1);
5869 }
5870
5871 if (potfile_disable == 1)
5872 {
5873 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
5874
5875 return (-1);
5876 }
5877 }
5878
5879 uint attack_kern = ATTACK_KERN_NONE;
5880
5881 switch (attack_mode)
5882 {
5883 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
5884 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
5885 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
5886 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
5887 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
5888 }
5889
5890 if (benchmark == 0)
5891 {
5892 if (keyspace == 1)
5893 {
5894 int num_additional_params = 1;
5895
5896 if (attack_kern == ATTACK_KERN_COMBI)
5897 {
5898 num_additional_params = 2;
5899 }
5900
5901 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
5902
5903 if (keyspace_wordlist_specified == 0) optind--;
5904 }
5905
5906 if (attack_kern == ATTACK_KERN_NONE)
5907 {
5908 if ((optind + 1) != myargc)
5909 {
5910 usage_mini_print (myargv[0]);
5911
5912 return (-1);
5913 }
5914 }
5915 else if (attack_kern == ATTACK_KERN_STRAIGHT)
5916 {
5917 if ((optind + 1) > myargc)
5918 {
5919 usage_mini_print (myargv[0]);
5920
5921 return (-1);
5922 }
5923 }
5924 else if (attack_kern == ATTACK_KERN_COMBI)
5925 {
5926 if ((optind + 3) != myargc)
5927 {
5928 usage_mini_print (myargv[0]);
5929
5930 return (-1);
5931 }
5932 }
5933 else if (attack_kern == ATTACK_KERN_BF)
5934 {
5935 if ((optind + 1) > myargc)
5936 {
5937 usage_mini_print (myargv[0]);
5938
5939 return (-1);
5940 }
5941 }
5942 else
5943 {
5944 usage_mini_print (myargv[0]);
5945
5946 return (-1);
5947 }
5948 }
5949 else
5950 {
5951 if (myargv[optind] != 0)
5952 {
5953 log_error ("ERROR: Invalid argument for benchmark mode specified");
5954
5955 return (-1);
5956 }
5957
5958 if (attack_mode_chgd == 1)
5959 {
5960 if (attack_mode != ATTACK_MODE_BF)
5961 {
5962 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
5963
5964 return (-1);
5965 }
5966 }
5967
5968 if (benchmark_mode == 0)
5969 {
5970 // nothing to do
5971 }
5972 else if (benchmark_mode == 1)
5973 {
5974 if (kernel_accel_chgd == 1 || kernel_loops_chgd == 1)
5975 {
5976 log_error ("ERROR: Benchmark-mode 1 does not allow kernel-accel or kernel-loops changed");
5977
5978 return (-1);
5979 }
5980 }
5981 else
5982 {
5983 log_error ("ERROR: Benchmark-mode must be 0 or 1");
5984
5985 return (-1);
5986 }
5987 }
5988
5989 if (skip != 0 && limit != 0)
5990 {
5991 limit += skip;
5992 }
5993
5994 if (keyspace == 1)
5995 {
5996 if (show == 1)
5997 {
5998 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
5999
6000 return (-1);
6001 }
6002 else if (left == 1)
6003 {
6004 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6005
6006 return (-1);
6007 }
6008
6009 potfile_disable = 1;
6010
6011 restore_disable = 1;
6012
6013 restore = 0;
6014
6015 weak_hash_threshold = 0;
6016
6017 quiet = 1;
6018 }
6019
6020 if (remove_timer_chgd == 1)
6021 {
6022 if (remove == 0)
6023 {
6024 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6025
6026 return (-1);
6027 }
6028
6029 if (remove_timer < 1)
6030 {
6031 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6032
6033 return (-1);
6034 }
6035 }
6036
6037 if (loopback == 1)
6038 {
6039 if (attack_mode == ATTACK_MODE_BF)
6040 {
6041 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6042
6043 return (-1);
6044 }
6045 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6046 {
6047 if ((rp_files_cnt == 0) && (rp_gen == 0))
6048 {
6049 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6050
6051 return (-1);
6052 }
6053 }
6054 }
6055
6056 if (debug_mode > 0)
6057 {
6058 if (attack_mode != ATTACK_MODE_STRAIGHT)
6059 {
6060 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6061
6062 return (-1);
6063 }
6064
6065 if ((rp_files_cnt == 0) && (rp_gen == 0))
6066 {
6067 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6068
6069 return (-1);
6070 }
6071 }
6072
6073 if (debug_mode > 4)
6074 {
6075 log_error ("ERROR: Invalid debug-mode specified");
6076
6077 return (-1);
6078 }
6079
6080 if (debug_file != NULL)
6081 {
6082 if (debug_mode < 1)
6083 {
6084 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6085
6086 return (-1);
6087 }
6088 }
6089
6090 if (induction_dir != NULL)
6091 {
6092 if (attack_mode == ATTACK_MODE_BF)
6093 {
6094 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6095
6096 return (-1);
6097 }
6098 }
6099
6100 /**
6101 * induction directory
6102 */
6103
6104 char *induction_directory = NULL;
6105
6106 if (attack_mode != ATTACK_MODE_BF)
6107 {
6108 if (induction_dir == NULL)
6109 {
6110 induction_directory = (char *) mymalloc (session_size);
6111
6112 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6113
6114 // create induction folder if it does not already exist
6115
6116 if (keyspace == 0)
6117 {
6118 if (rmdir (induction_directory) == -1)
6119 {
6120 if (errno == ENOENT)
6121 {
6122 // good, we can ignore
6123 }
6124 else if (errno == ENOTEMPTY)
6125 {
6126 char *induction_directory_mv = (char *) mymalloc (session_size);
6127
6128 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6129
6130 if (rename (induction_directory, induction_directory_mv) != 0)
6131 {
6132 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6133
6134 return (-1);
6135 }
6136 }
6137 else
6138 {
6139 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6140
6141 return (-1);
6142 }
6143 }
6144
6145 if (mkdir (induction_directory, 0700) == -1)
6146 {
6147 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6148
6149 return (-1);
6150 }
6151 }
6152 }
6153 else
6154 {
6155 induction_directory = induction_dir;
6156 }
6157 }
6158
6159 data.induction_directory = induction_directory;
6160
6161 /**
6162 * loopback
6163 */
6164
6165 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6166
6167 char *loopback_file = (char *) mymalloc (loopback_size);
6168
6169 /**
6170 * outfile-check directory
6171 */
6172
6173 char *outfile_check_directory = NULL;
6174
6175 if (outfile_check_dir == NULL)
6176 {
6177 outfile_check_directory = (char *) mymalloc (session_size);
6178
6179 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6180 }
6181 else
6182 {
6183 outfile_check_directory = outfile_check_dir;
6184 }
6185
6186 data.outfile_check_directory = outfile_check_directory;
6187
6188 if (keyspace == 0)
6189 {
6190 struct stat outfile_check_stat;
6191
6192 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6193 {
6194 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6195
6196 if (is_dir == 0)
6197 {
6198 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6199
6200 return (-1);
6201 }
6202 }
6203 else if (outfile_check_dir == NULL)
6204 {
6205 if (mkdir (outfile_check_directory, 0700) == -1)
6206 {
6207 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6208
6209 return (-1);
6210 }
6211 }
6212 }
6213
6214 /**
6215 * special other stuff
6216 */
6217
6218 if (hash_mode == 9710)
6219 {
6220 outfile_format = 5;
6221 outfile_format_chgd = 1;
6222 }
6223
6224 if (hash_mode == 9810)
6225 {
6226 outfile_format = 5;
6227 outfile_format_chgd = 1;
6228 }
6229
6230 if (hash_mode == 10410)
6231 {
6232 outfile_format = 5;
6233 outfile_format_chgd = 1;
6234 }
6235
6236 /**
6237 * store stuff
6238 */
6239
6240 data.hash_mode = hash_mode;
6241 data.restore = restore;
6242 data.restore_timer = restore_timer;
6243 data.restore_disable = restore_disable;
6244 data.status = status;
6245 data.status_timer = status_timer;
6246 data.status_automat = status_automat;
6247 data.loopback = loopback;
6248 data.runtime = runtime;
6249 data.remove = remove;
6250 data.remove_timer = remove_timer;
6251 data.debug_mode = debug_mode;
6252 data.debug_file = debug_file;
6253 data.username = username;
6254 data.quiet = quiet;
6255 data.outfile = outfile;
6256 data.outfile_format = outfile_format;
6257 data.outfile_autohex = outfile_autohex;
6258 data.hex_charset = hex_charset;
6259 data.hex_salt = hex_salt;
6260 data.hex_wordlist = hex_wordlist;
6261 data.separator = separator;
6262 data.rp_files = rp_files;
6263 data.rp_files_cnt = rp_files_cnt;
6264 data.rp_gen = rp_gen;
6265 data.rp_gen_seed = rp_gen_seed;
6266 data.force = force;
6267 data.benchmark = benchmark;
6268 data.skip = skip;
6269 data.limit = limit;
6270 data.powertune_enable = powertune_enable;
6271 data.logfile_disable = logfile_disable;
6272 data.truecrypt_keyfiles = truecrypt_keyfiles;
6273 data.scrypt_tmto = scrypt_tmto;
6274
6275 /**
6276 * cpu affinity
6277 */
6278
6279 if (cpu_affinity)
6280 {
6281 set_cpu_affinity (cpu_affinity);
6282 }
6283
6284 if (rp_gen_seed_chgd == 0)
6285 {
6286 srand (proc_start);
6287 }
6288 else
6289 {
6290 srand (rp_gen_seed);
6291 }
6292
6293 /**
6294 * logfile init
6295 */
6296
6297 if (logfile_disable == 0)
6298 {
6299 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6300
6301 char *logfile = (char *) mymalloc (logfile_size);
6302
6303 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6304
6305 data.logfile = logfile;
6306
6307 char *topid = logfile_generate_topid ();
6308
6309 data.topid = topid;
6310 }
6311
6312 // logfile_append() checks for logfile_disable internally to make it easier from here
6313
6314 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6315 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6316 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6317 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6318 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6319 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6320 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6321 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6322 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6323 #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));
6324
6325 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6326 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6327 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6328 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6329 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6330 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6331 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6332 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6333
6334 logfile_top_msg ("START");
6335
6336 logfile_top_uint (attack_mode);
6337 logfile_top_uint (attack_kern);
6338 logfile_top_uint (benchmark);
6339 logfile_top_uint (benchmark_mode);
6340 logfile_top_uint (bitmap_min);
6341 logfile_top_uint (bitmap_max);
6342 logfile_top_uint (debug_mode);
6343 logfile_top_uint (force);
6344 logfile_top_uint (kernel_accel);
6345 logfile_top_uint (kernel_loops);
6346 logfile_top_uint (gpu_temp_abort);
6347 logfile_top_uint (gpu_temp_disable);
6348 logfile_top_uint (gpu_temp_retain);
6349 logfile_top_uint (hash_mode);
6350 logfile_top_uint (hex_charset);
6351 logfile_top_uint (hex_salt);
6352 logfile_top_uint (hex_wordlist);
6353 logfile_top_uint (increment);
6354 logfile_top_uint (increment_max);
6355 logfile_top_uint (increment_min);
6356 logfile_top_uint (keyspace);
6357 logfile_top_uint (left);
6358 logfile_top_uint (logfile_disable);
6359 logfile_top_uint (loopback);
6360 logfile_top_uint (markov_classic);
6361 logfile_top_uint (markov_disable);
6362 logfile_top_uint (markov_threshold);
6363 logfile_top_uint (outfile_autohex);
6364 logfile_top_uint (outfile_check_timer);
6365 logfile_top_uint (outfile_format);
6366 logfile_top_uint (potfile_disable);
6367 logfile_top_uint (powertune_enable);
6368 logfile_top_uint (scrypt_tmto);
6369 logfile_top_uint (quiet);
6370 logfile_top_uint (remove);
6371 logfile_top_uint (remove_timer);
6372 logfile_top_uint (restore);
6373 logfile_top_uint (restore_disable);
6374 logfile_top_uint (restore_timer);
6375 logfile_top_uint (rp_gen);
6376 logfile_top_uint (rp_gen_func_max);
6377 logfile_top_uint (rp_gen_func_min);
6378 logfile_top_uint (rp_gen_seed);
6379 logfile_top_uint (runtime);
6380 logfile_top_uint (segment_size);
6381 logfile_top_uint (show);
6382 logfile_top_uint (status);
6383 logfile_top_uint (status_automat);
6384 logfile_top_uint (status_timer);
6385 logfile_top_uint (usage);
6386 logfile_top_uint (username);
6387 logfile_top_uint (version);
6388 logfile_top_uint (weak_hash_threshold);
6389 logfile_top_uint (workload_profile);
6390 logfile_top_uint64 (limit);
6391 logfile_top_uint64 (skip);
6392 logfile_top_char (separator);
6393 logfile_top_string (cpu_affinity);
6394 logfile_top_string (custom_charset_1);
6395 logfile_top_string (custom_charset_2);
6396 logfile_top_string (custom_charset_3);
6397 logfile_top_string (custom_charset_4);
6398 logfile_top_string (debug_file);
6399 logfile_top_string (opencl_devices);
6400 logfile_top_string (opencl_platforms);
6401 logfile_top_string (opencl_device_types);
6402 logfile_top_string (induction_dir);
6403 logfile_top_string (markov_hcstat);
6404 logfile_top_string (outfile);
6405 logfile_top_string (outfile_check_dir);
6406 logfile_top_string (rule_buf_l);
6407 logfile_top_string (rule_buf_r);
6408 logfile_top_string (session);
6409 logfile_top_string (truecrypt_keyfiles);
6410
6411 /**
6412 * OpenCL platform selection
6413 */
6414
6415 uint opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6416
6417 /**
6418 * OpenCL device selection
6419 */
6420
6421 uint opencl_devicemask = devices_to_devicemask (opencl_devices);
6422
6423 /**
6424 * OpenCL device type selection
6425 */
6426
6427 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6428
6429 /**
6430 * benchmark
6431 */
6432
6433 if (benchmark == 1)
6434 {
6435 /**
6436 * disable useless stuff for benchmark
6437 */
6438
6439 restore_timer = 0;
6440 status_timer = 0;
6441 restore_disable = 1;
6442 potfile_disable = 1;
6443 weak_hash_threshold = 0;
6444
6445 data.restore_timer = restore_timer;
6446 data.status_timer = status_timer;
6447 data.restore_disable = restore_disable;
6448
6449 if (benchmark_mode == 1)
6450 {
6451 markov_disable = 1;
6452 }
6453
6454 /**
6455 * force attack mode to be bruteforce
6456 */
6457
6458 attack_mode = ATTACK_MODE_BF;
6459 attack_kern = ATTACK_KERN_BF;
6460
6461 if (runtime_chgd == 0)
6462 {
6463 runtime = 4;
6464
6465 if (benchmark_mode == 1) runtime = 17;
6466
6467 data.runtime = runtime;
6468 }
6469 }
6470
6471 /**
6472 * config
6473 */
6474
6475 uint hash_type = 0;
6476 uint salt_type = 0;
6477 uint attack_exec = 0;
6478 uint opts_type = 0;
6479 uint kern_type = 0;
6480 uint dgst_size = 0;
6481 uint esalt_size = 0;
6482 uint opti_type = 0;
6483 uint dgst_pos0 = -1;
6484 uint dgst_pos1 = -1;
6485 uint dgst_pos2 = -1;
6486 uint dgst_pos3 = -1;
6487
6488 int (*parse_func) (char *, uint, hash_t *);
6489 int (*sort_by_digest) (const void *, const void *);
6490
6491 uint algorithm_pos = 0;
6492 uint algorithm_max = 1;
6493
6494 uint *algorithms = default_benchmark_algorithms;
6495
6496 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6497
6498 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6499 {
6500 /*
6501 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6502 * the following algos are skipped entirely
6503 */
6504
6505 if (algorithm_pos > 0)
6506 {
6507 local_free (rd);
6508
6509 rd = init_restore (argc, argv);
6510
6511 data.rd = rd;
6512 }
6513
6514 /**
6515 * update hash_mode in case of multihash benchmark
6516 */
6517
6518 if (benchmark == 1)
6519 {
6520 if (hash_mode_chgd == 0)
6521 {
6522 hash_mode = algorithms[algorithm_pos];
6523
6524 data.hash_mode = hash_mode;
6525 }
6526
6527 quiet = 1;
6528
6529 data.quiet = quiet;
6530 }
6531
6532 switch (hash_mode)
6533 {
6534 case 0: hash_type = HASH_TYPE_MD5;
6535 salt_type = SALT_TYPE_NONE;
6536 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6537 opts_type = OPTS_TYPE_PT_GENERATE_LE
6538 | OPTS_TYPE_PT_ADD80
6539 | OPTS_TYPE_PT_ADDBITS14;
6540 kern_type = KERN_TYPE_MD5;
6541 dgst_size = DGST_SIZE_4_4;
6542 parse_func = md5_parse_hash;
6543 sort_by_digest = sort_by_digest_4_4;
6544 opti_type = OPTI_TYPE_ZERO_BYTE
6545 | OPTI_TYPE_PRECOMPUTE_INIT
6546 | OPTI_TYPE_PRECOMPUTE_MERKLE
6547 | OPTI_TYPE_MEET_IN_MIDDLE
6548 | OPTI_TYPE_EARLY_SKIP
6549 | OPTI_TYPE_NOT_ITERATED
6550 | OPTI_TYPE_NOT_SALTED
6551 | OPTI_TYPE_RAW_HASH;
6552 dgst_pos0 = 0;
6553 dgst_pos1 = 3;
6554 dgst_pos2 = 2;
6555 dgst_pos3 = 1;
6556 break;
6557
6558 case 10: hash_type = HASH_TYPE_MD5;
6559 salt_type = SALT_TYPE_INTERN;
6560 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6561 opts_type = OPTS_TYPE_PT_GENERATE_LE
6562 | OPTS_TYPE_ST_ADD80
6563 | OPTS_TYPE_ST_ADDBITS14;
6564 kern_type = KERN_TYPE_MD5_PWSLT;
6565 dgst_size = DGST_SIZE_4_4;
6566 parse_func = md5s_parse_hash;
6567 sort_by_digest = sort_by_digest_4_4;
6568 opti_type = OPTI_TYPE_ZERO_BYTE
6569 | OPTI_TYPE_PRECOMPUTE_INIT
6570 | OPTI_TYPE_PRECOMPUTE_MERKLE
6571 | OPTI_TYPE_MEET_IN_MIDDLE
6572 | OPTI_TYPE_EARLY_SKIP
6573 | OPTI_TYPE_NOT_ITERATED
6574 | OPTI_TYPE_APPENDED_SALT
6575 | OPTI_TYPE_RAW_HASH;
6576 dgst_pos0 = 0;
6577 dgst_pos1 = 3;
6578 dgst_pos2 = 2;
6579 dgst_pos3 = 1;
6580 break;
6581
6582 case 11: hash_type = HASH_TYPE_MD5;
6583 salt_type = SALT_TYPE_INTERN;
6584 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6585 opts_type = OPTS_TYPE_PT_GENERATE_LE
6586 | OPTS_TYPE_ST_ADD80
6587 | OPTS_TYPE_ST_ADDBITS14;
6588 kern_type = KERN_TYPE_MD5_PWSLT;
6589 dgst_size = DGST_SIZE_4_4;
6590 parse_func = joomla_parse_hash;
6591 sort_by_digest = sort_by_digest_4_4;
6592 opti_type = OPTI_TYPE_ZERO_BYTE
6593 | OPTI_TYPE_PRECOMPUTE_INIT
6594 | OPTI_TYPE_PRECOMPUTE_MERKLE
6595 | OPTI_TYPE_MEET_IN_MIDDLE
6596 | OPTI_TYPE_EARLY_SKIP
6597 | OPTI_TYPE_NOT_ITERATED
6598 | OPTI_TYPE_APPENDED_SALT
6599 | OPTI_TYPE_RAW_HASH;
6600 dgst_pos0 = 0;
6601 dgst_pos1 = 3;
6602 dgst_pos2 = 2;
6603 dgst_pos3 = 1;
6604 break;
6605
6606 case 12: hash_type = HASH_TYPE_MD5;
6607 salt_type = SALT_TYPE_INTERN;
6608 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6609 opts_type = OPTS_TYPE_PT_GENERATE_LE
6610 | OPTS_TYPE_ST_ADD80
6611 | OPTS_TYPE_ST_ADDBITS14;
6612 kern_type = KERN_TYPE_MD5_PWSLT;
6613 dgst_size = DGST_SIZE_4_4;
6614 parse_func = postgresql_parse_hash;
6615 sort_by_digest = sort_by_digest_4_4;
6616 opti_type = OPTI_TYPE_ZERO_BYTE
6617 | OPTI_TYPE_PRECOMPUTE_INIT
6618 | OPTI_TYPE_PRECOMPUTE_MERKLE
6619 | OPTI_TYPE_MEET_IN_MIDDLE
6620 | OPTI_TYPE_EARLY_SKIP
6621 | OPTI_TYPE_NOT_ITERATED
6622 | OPTI_TYPE_APPENDED_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 20: hash_type = HASH_TYPE_MD5;
6631 salt_type = SALT_TYPE_INTERN;
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 = md5s_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 21: hash_type = HASH_TYPE_MD5;
6654 salt_type = SALT_TYPE_INTERN;
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 = osc_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 22: hash_type = HASH_TYPE_MD5;
6677 salt_type = SALT_TYPE_EMBEDDED;
6678 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6679 opts_type = OPTS_TYPE_PT_GENERATE_LE
6680 | OPTS_TYPE_PT_ADD80
6681 | OPTS_TYPE_PT_ADDBITS14;
6682 kern_type = KERN_TYPE_MD5_SLTPW;
6683 dgst_size = DGST_SIZE_4_4;
6684 parse_func = netscreen_parse_hash;
6685 sort_by_digest = sort_by_digest_4_4;
6686 opti_type = OPTI_TYPE_ZERO_BYTE
6687 | OPTI_TYPE_PRECOMPUTE_INIT
6688 | OPTI_TYPE_PRECOMPUTE_MERKLE
6689 | OPTI_TYPE_EARLY_SKIP
6690 | OPTI_TYPE_NOT_ITERATED
6691 | OPTI_TYPE_PREPENDED_SALT
6692 | OPTI_TYPE_RAW_HASH;
6693 dgst_pos0 = 0;
6694 dgst_pos1 = 3;
6695 dgst_pos2 = 2;
6696 dgst_pos3 = 1;
6697 break;
6698
6699 case 23: hash_type = HASH_TYPE_MD5;
6700 salt_type = SALT_TYPE_EMBEDDED;
6701 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6702 opts_type = OPTS_TYPE_PT_GENERATE_LE
6703 | OPTS_TYPE_PT_ADD80
6704 | OPTS_TYPE_PT_ADDBITS14;
6705 kern_type = KERN_TYPE_MD5_SLTPW;
6706 dgst_size = DGST_SIZE_4_4;
6707 parse_func = skype_parse_hash;
6708 sort_by_digest = sort_by_digest_4_4;
6709 opti_type = OPTI_TYPE_ZERO_BYTE
6710 | OPTI_TYPE_PRECOMPUTE_INIT
6711 | OPTI_TYPE_PRECOMPUTE_MERKLE
6712 | OPTI_TYPE_EARLY_SKIP
6713 | OPTI_TYPE_NOT_ITERATED
6714 | OPTI_TYPE_PREPENDED_SALT
6715 | OPTI_TYPE_RAW_HASH;
6716 dgst_pos0 = 0;
6717 dgst_pos1 = 3;
6718 dgst_pos2 = 2;
6719 dgst_pos3 = 1;
6720 break;
6721
6722 case 30: hash_type = HASH_TYPE_MD5;
6723 salt_type = SALT_TYPE_INTERN;
6724 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6725 opts_type = OPTS_TYPE_PT_GENERATE_LE
6726 | OPTS_TYPE_PT_UNICODE
6727 | OPTS_TYPE_ST_ADD80
6728 | OPTS_TYPE_ST_ADDBITS14;
6729 kern_type = KERN_TYPE_MD5_PWUSLT;
6730 dgst_size = DGST_SIZE_4_4;
6731 parse_func = md5s_parse_hash;
6732 sort_by_digest = sort_by_digest_4_4;
6733 opti_type = OPTI_TYPE_ZERO_BYTE
6734 | OPTI_TYPE_PRECOMPUTE_INIT
6735 | OPTI_TYPE_PRECOMPUTE_MERKLE
6736 | OPTI_TYPE_MEET_IN_MIDDLE
6737 | OPTI_TYPE_EARLY_SKIP
6738 | OPTI_TYPE_NOT_ITERATED
6739 | OPTI_TYPE_APPENDED_SALT
6740 | OPTI_TYPE_RAW_HASH;
6741 dgst_pos0 = 0;
6742 dgst_pos1 = 3;
6743 dgst_pos2 = 2;
6744 dgst_pos3 = 1;
6745 break;
6746
6747 case 40: hash_type = HASH_TYPE_MD5;
6748 salt_type = SALT_TYPE_INTERN;
6749 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6750 opts_type = OPTS_TYPE_PT_GENERATE_LE
6751 | OPTS_TYPE_PT_ADD80
6752 | OPTS_TYPE_PT_ADDBITS14
6753 | OPTS_TYPE_PT_UNICODE;
6754 kern_type = KERN_TYPE_MD5_SLTPWU;
6755 dgst_size = DGST_SIZE_4_4;
6756 parse_func = md5s_parse_hash;
6757 sort_by_digest = sort_by_digest_4_4;
6758 opti_type = OPTI_TYPE_ZERO_BYTE
6759 | OPTI_TYPE_PRECOMPUTE_INIT
6760 | OPTI_TYPE_PRECOMPUTE_MERKLE
6761 | OPTI_TYPE_EARLY_SKIP
6762 | OPTI_TYPE_NOT_ITERATED
6763 | OPTI_TYPE_PREPENDED_SALT
6764 | OPTI_TYPE_RAW_HASH;
6765 dgst_pos0 = 0;
6766 dgst_pos1 = 3;
6767 dgst_pos2 = 2;
6768 dgst_pos3 = 1;
6769 break;
6770
6771 case 50: hash_type = HASH_TYPE_MD5;
6772 salt_type = SALT_TYPE_INTERN;
6773 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6774 opts_type = OPTS_TYPE_PT_GENERATE_LE
6775 | OPTS_TYPE_ST_ADD80
6776 | OPTS_TYPE_ST_ADDBITS14;
6777 kern_type = KERN_TYPE_HMACMD5_PW;
6778 dgst_size = DGST_SIZE_4_4;
6779 parse_func = hmacmd5_parse_hash;
6780 sort_by_digest = sort_by_digest_4_4;
6781 opti_type = OPTI_TYPE_ZERO_BYTE
6782 | OPTI_TYPE_NOT_ITERATED;
6783 dgst_pos0 = 0;
6784 dgst_pos1 = 3;
6785 dgst_pos2 = 2;
6786 dgst_pos3 = 1;
6787 break;
6788
6789 case 60: hash_type = HASH_TYPE_MD5;
6790 salt_type = SALT_TYPE_INTERN;
6791 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6792 opts_type = OPTS_TYPE_PT_GENERATE_LE
6793 | OPTS_TYPE_PT_ADD80
6794 | OPTS_TYPE_PT_ADDBITS14;
6795 kern_type = KERN_TYPE_HMACMD5_SLT;
6796 dgst_size = DGST_SIZE_4_4;
6797 parse_func = hmacmd5_parse_hash;
6798 sort_by_digest = sort_by_digest_4_4;
6799 opti_type = OPTI_TYPE_ZERO_BYTE
6800 | OPTI_TYPE_NOT_ITERATED;
6801 dgst_pos0 = 0;
6802 dgst_pos1 = 3;
6803 dgst_pos2 = 2;
6804 dgst_pos3 = 1;
6805 break;
6806
6807 case 100: hash_type = HASH_TYPE_SHA1;
6808 salt_type = SALT_TYPE_NONE;
6809 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6810 opts_type = OPTS_TYPE_PT_GENERATE_BE
6811 | OPTS_TYPE_PT_ADD80
6812 | OPTS_TYPE_PT_ADDBITS15;
6813 kern_type = KERN_TYPE_SHA1;
6814 dgst_size = DGST_SIZE_4_5;
6815 parse_func = sha1_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_NOT_SALTED
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 101: hash_type = HASH_TYPE_SHA1;
6831 salt_type = SALT_TYPE_NONE;
6832 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6833 opts_type = OPTS_TYPE_PT_GENERATE_BE
6834 | OPTS_TYPE_PT_ADD80
6835 | OPTS_TYPE_PT_ADDBITS15;
6836 kern_type = KERN_TYPE_SHA1;
6837 dgst_size = DGST_SIZE_4_5;
6838 parse_func = sha1b64_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_NOT_SALTED
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 110: 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 kern_type = KERN_TYPE_SHA1_PWSLT;
6860 dgst_size = DGST_SIZE_4_5;
6861 parse_func = sha1s_parse_hash;
6862 sort_by_digest = sort_by_digest_4_5;
6863 opti_type = OPTI_TYPE_ZERO_BYTE
6864 | OPTI_TYPE_PRECOMPUTE_INIT
6865 | OPTI_TYPE_PRECOMPUTE_MERKLE
6866 | OPTI_TYPE_EARLY_SKIP
6867 | OPTI_TYPE_NOT_ITERATED
6868 | OPTI_TYPE_APPENDED_SALT
6869 | OPTI_TYPE_RAW_HASH;
6870 dgst_pos0 = 3;
6871 dgst_pos1 = 4;
6872 dgst_pos2 = 2;
6873 dgst_pos3 = 1;
6874 break;
6875
6876 case 111: hash_type = HASH_TYPE_SHA1;
6877 salt_type = SALT_TYPE_EMBEDDED;
6878 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6879 opts_type = OPTS_TYPE_PT_GENERATE_BE
6880 | OPTS_TYPE_ST_ADD80
6881 | OPTS_TYPE_ST_ADDBITS15;
6882 kern_type = KERN_TYPE_SHA1_PWSLT;
6883 dgst_size = DGST_SIZE_4_5;
6884 parse_func = sha1b64s_parse_hash;
6885 sort_by_digest = sort_by_digest_4_5;
6886 opti_type = OPTI_TYPE_ZERO_BYTE
6887 | OPTI_TYPE_PRECOMPUTE_INIT
6888 | OPTI_TYPE_PRECOMPUTE_MERKLE
6889 | OPTI_TYPE_EARLY_SKIP
6890 | OPTI_TYPE_NOT_ITERATED
6891 | OPTI_TYPE_APPENDED_SALT
6892 | OPTI_TYPE_RAW_HASH;
6893 dgst_pos0 = 3;
6894 dgst_pos1 = 4;
6895 dgst_pos2 = 2;
6896 dgst_pos3 = 1;
6897 break;
6898
6899 case 112: hash_type = HASH_TYPE_SHA1;
6900 salt_type = SALT_TYPE_INTERN;
6901 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6902 opts_type = OPTS_TYPE_PT_GENERATE_BE
6903 | OPTS_TYPE_ST_ADD80
6904 | OPTS_TYPE_ST_ADDBITS15
6905 | OPTS_TYPE_ST_HEX;
6906 kern_type = KERN_TYPE_SHA1_PWSLT;
6907 dgst_size = DGST_SIZE_4_5;
6908 parse_func = oracles_parse_hash;
6909 sort_by_digest = sort_by_digest_4_5;
6910 opti_type = OPTI_TYPE_ZERO_BYTE
6911 | OPTI_TYPE_PRECOMPUTE_INIT
6912 | OPTI_TYPE_PRECOMPUTE_MERKLE
6913 | OPTI_TYPE_EARLY_SKIP
6914 | OPTI_TYPE_NOT_ITERATED
6915 | OPTI_TYPE_APPENDED_SALT
6916 | OPTI_TYPE_RAW_HASH;
6917 dgst_pos0 = 3;
6918 dgst_pos1 = 4;
6919 dgst_pos2 = 2;
6920 dgst_pos3 = 1;
6921 break;
6922
6923 case 120: hash_type = HASH_TYPE_SHA1;
6924 salt_type = SALT_TYPE_INTERN;
6925 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6926 opts_type = OPTS_TYPE_PT_GENERATE_BE
6927 | OPTS_TYPE_PT_ADD80
6928 | OPTS_TYPE_PT_ADDBITS15;
6929 kern_type = KERN_TYPE_SHA1_SLTPW;
6930 dgst_size = DGST_SIZE_4_5;
6931 parse_func = sha1s_parse_hash;
6932 sort_by_digest = sort_by_digest_4_5;
6933 opti_type = OPTI_TYPE_ZERO_BYTE
6934 | OPTI_TYPE_PRECOMPUTE_INIT
6935 | OPTI_TYPE_PRECOMPUTE_MERKLE
6936 | OPTI_TYPE_EARLY_SKIP
6937 | OPTI_TYPE_NOT_ITERATED
6938 | OPTI_TYPE_PREPENDED_SALT
6939 | OPTI_TYPE_RAW_HASH;
6940 dgst_pos0 = 3;
6941 dgst_pos1 = 4;
6942 dgst_pos2 = 2;
6943 dgst_pos3 = 1;
6944 break;
6945
6946 case 121: hash_type = HASH_TYPE_SHA1;
6947 salt_type = SALT_TYPE_INTERN;
6948 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6949 opts_type = OPTS_TYPE_PT_GENERATE_BE
6950 | OPTS_TYPE_PT_ADD80
6951 | OPTS_TYPE_PT_ADDBITS15
6952 | OPTS_TYPE_ST_LOWER;
6953 kern_type = KERN_TYPE_SHA1_SLTPW;
6954 dgst_size = DGST_SIZE_4_5;
6955 parse_func = smf_parse_hash;
6956 sort_by_digest = sort_by_digest_4_5;
6957 opti_type = OPTI_TYPE_ZERO_BYTE
6958 | OPTI_TYPE_PRECOMPUTE_INIT
6959 | OPTI_TYPE_PRECOMPUTE_MERKLE
6960 | OPTI_TYPE_EARLY_SKIP
6961 | OPTI_TYPE_NOT_ITERATED
6962 | OPTI_TYPE_PREPENDED_SALT
6963 | OPTI_TYPE_RAW_HASH;
6964 dgst_pos0 = 3;
6965 dgst_pos1 = 4;
6966 dgst_pos2 = 2;
6967 dgst_pos3 = 1;
6968 break;
6969
6970 case 122: hash_type = HASH_TYPE_SHA1;
6971 salt_type = SALT_TYPE_EMBEDDED;
6972 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6973 opts_type = OPTS_TYPE_PT_GENERATE_BE
6974 | OPTS_TYPE_PT_ADD80
6975 | OPTS_TYPE_PT_ADDBITS15
6976 | OPTS_TYPE_ST_HEX;
6977 kern_type = KERN_TYPE_SHA1_SLTPW;
6978 dgst_size = DGST_SIZE_4_5;
6979 parse_func = osx1_parse_hash;
6980 sort_by_digest = sort_by_digest_4_5;
6981 opti_type = OPTI_TYPE_ZERO_BYTE
6982 | OPTI_TYPE_PRECOMPUTE_INIT
6983 | OPTI_TYPE_PRECOMPUTE_MERKLE
6984 | OPTI_TYPE_EARLY_SKIP
6985 | OPTI_TYPE_NOT_ITERATED
6986 | OPTI_TYPE_PREPENDED_SALT
6987 | OPTI_TYPE_RAW_HASH;
6988 dgst_pos0 = 3;
6989 dgst_pos1 = 4;
6990 dgst_pos2 = 2;
6991 dgst_pos3 = 1;
6992 break;
6993
6994 case 124: hash_type = HASH_TYPE_SHA1;
6995 salt_type = SALT_TYPE_EMBEDDED;
6996 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6997 opts_type = OPTS_TYPE_PT_GENERATE_BE
6998 | OPTS_TYPE_PT_ADD80
6999 | OPTS_TYPE_PT_ADDBITS15;
7000 kern_type = KERN_TYPE_SHA1_SLTPW;
7001 dgst_size = DGST_SIZE_4_5;
7002 parse_func = djangosha1_parse_hash;
7003 sort_by_digest = sort_by_digest_4_5;
7004 opti_type = OPTI_TYPE_ZERO_BYTE
7005 | OPTI_TYPE_PRECOMPUTE_INIT
7006 | OPTI_TYPE_PRECOMPUTE_MERKLE
7007 | OPTI_TYPE_EARLY_SKIP
7008 | OPTI_TYPE_NOT_ITERATED
7009 | OPTI_TYPE_PREPENDED_SALT
7010 | OPTI_TYPE_RAW_HASH;
7011 dgst_pos0 = 3;
7012 dgst_pos1 = 4;
7013 dgst_pos2 = 2;
7014 dgst_pos3 = 1;
7015 break;
7016
7017 case 130: hash_type = HASH_TYPE_SHA1;
7018 salt_type = SALT_TYPE_INTERN;
7019 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7020 opts_type = OPTS_TYPE_PT_GENERATE_BE
7021 | OPTS_TYPE_PT_UNICODE
7022 | OPTS_TYPE_ST_ADD80
7023 | OPTS_TYPE_ST_ADDBITS15;
7024 kern_type = KERN_TYPE_SHA1_PWUSLT;
7025 dgst_size = DGST_SIZE_4_5;
7026 parse_func = sha1s_parse_hash;
7027 sort_by_digest = sort_by_digest_4_5;
7028 opti_type = OPTI_TYPE_ZERO_BYTE
7029 | OPTI_TYPE_PRECOMPUTE_INIT
7030 | OPTI_TYPE_PRECOMPUTE_MERKLE
7031 | OPTI_TYPE_EARLY_SKIP
7032 | OPTI_TYPE_NOT_ITERATED
7033 | OPTI_TYPE_APPENDED_SALT
7034 | OPTI_TYPE_RAW_HASH;
7035 dgst_pos0 = 3;
7036 dgst_pos1 = 4;
7037 dgst_pos2 = 2;
7038 dgst_pos3 = 1;
7039 break;
7040
7041 case 131: hash_type = HASH_TYPE_SHA1;
7042 salt_type = SALT_TYPE_EMBEDDED;
7043 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7044 opts_type = OPTS_TYPE_PT_GENERATE_BE
7045 | OPTS_TYPE_PT_UNICODE
7046 | OPTS_TYPE_PT_UPPER
7047 | OPTS_TYPE_ST_ADD80
7048 | OPTS_TYPE_ST_ADDBITS15
7049 | OPTS_TYPE_ST_HEX;
7050 kern_type = KERN_TYPE_SHA1_PWUSLT;
7051 dgst_size = DGST_SIZE_4_5;
7052 parse_func = mssql2000_parse_hash;
7053 sort_by_digest = sort_by_digest_4_5;
7054 opti_type = OPTI_TYPE_ZERO_BYTE
7055 | OPTI_TYPE_PRECOMPUTE_INIT
7056 | OPTI_TYPE_PRECOMPUTE_MERKLE
7057 | OPTI_TYPE_EARLY_SKIP
7058 | OPTI_TYPE_NOT_ITERATED
7059 | OPTI_TYPE_APPENDED_SALT
7060 | OPTI_TYPE_RAW_HASH;
7061 dgst_pos0 = 3;
7062 dgst_pos1 = 4;
7063 dgst_pos2 = 2;
7064 dgst_pos3 = 1;
7065 break;
7066
7067 case 132: hash_type = HASH_TYPE_SHA1;
7068 salt_type = SALT_TYPE_EMBEDDED;
7069 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7070 opts_type = OPTS_TYPE_PT_GENERATE_BE
7071 | OPTS_TYPE_PT_UNICODE
7072 | OPTS_TYPE_ST_ADD80
7073 | OPTS_TYPE_ST_ADDBITS15
7074 | OPTS_TYPE_ST_HEX;
7075 kern_type = KERN_TYPE_SHA1_PWUSLT;
7076 dgst_size = DGST_SIZE_4_5;
7077 parse_func = mssql2005_parse_hash;
7078 sort_by_digest = sort_by_digest_4_5;
7079 opti_type = OPTI_TYPE_ZERO_BYTE
7080 | OPTI_TYPE_PRECOMPUTE_INIT
7081 | OPTI_TYPE_PRECOMPUTE_MERKLE
7082 | OPTI_TYPE_EARLY_SKIP
7083 | OPTI_TYPE_NOT_ITERATED
7084 | OPTI_TYPE_APPENDED_SALT
7085 | OPTI_TYPE_RAW_HASH;
7086 dgst_pos0 = 3;
7087 dgst_pos1 = 4;
7088 dgst_pos2 = 2;
7089 dgst_pos3 = 1;
7090 break;
7091
7092 case 133: hash_type = HASH_TYPE_SHA1;
7093 salt_type = SALT_TYPE_EMBEDDED;
7094 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7095 opts_type = OPTS_TYPE_PT_GENERATE_BE
7096 | OPTS_TYPE_PT_UNICODE
7097 | OPTS_TYPE_ST_ADD80
7098 | OPTS_TYPE_ST_ADDBITS15;
7099 kern_type = KERN_TYPE_SHA1_PWUSLT;
7100 dgst_size = DGST_SIZE_4_5;
7101 parse_func = peoplesoft_parse_hash;
7102 sort_by_digest = sort_by_digest_4_5;
7103 opti_type = OPTI_TYPE_ZERO_BYTE
7104 | OPTI_TYPE_PRECOMPUTE_INIT
7105 | OPTI_TYPE_PRECOMPUTE_MERKLE
7106 | OPTI_TYPE_EARLY_SKIP
7107 | OPTI_TYPE_NOT_ITERATED
7108 | OPTI_TYPE_APPENDED_SALT
7109 | OPTI_TYPE_RAW_HASH;
7110 dgst_pos0 = 3;
7111 dgst_pos1 = 4;
7112 dgst_pos2 = 2;
7113 dgst_pos3 = 1;
7114 break;
7115
7116 case 140: hash_type = HASH_TYPE_SHA1;
7117 salt_type = SALT_TYPE_INTERN;
7118 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7119 opts_type = OPTS_TYPE_PT_GENERATE_BE
7120 | OPTS_TYPE_PT_ADD80
7121 | OPTS_TYPE_PT_ADDBITS15
7122 | OPTS_TYPE_PT_UNICODE;
7123 kern_type = KERN_TYPE_SHA1_SLTPWU;
7124 dgst_size = DGST_SIZE_4_5;
7125 parse_func = sha1s_parse_hash;
7126 sort_by_digest = sort_by_digest_4_5;
7127 opti_type = OPTI_TYPE_ZERO_BYTE
7128 | OPTI_TYPE_PRECOMPUTE_INIT
7129 | OPTI_TYPE_PRECOMPUTE_MERKLE
7130 | OPTI_TYPE_EARLY_SKIP
7131 | OPTI_TYPE_NOT_ITERATED
7132 | OPTI_TYPE_PREPENDED_SALT
7133 | OPTI_TYPE_RAW_HASH;
7134 dgst_pos0 = 3;
7135 dgst_pos1 = 4;
7136 dgst_pos2 = 2;
7137 dgst_pos3 = 1;
7138 break;
7139
7140 case 141: hash_type = HASH_TYPE_SHA1;
7141 salt_type = SALT_TYPE_EMBEDDED;
7142 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7143 opts_type = OPTS_TYPE_PT_GENERATE_BE
7144 | OPTS_TYPE_PT_ADD80
7145 | OPTS_TYPE_PT_ADDBITS15
7146 | OPTS_TYPE_PT_UNICODE
7147 | OPTS_TYPE_ST_BASE64;
7148 kern_type = KERN_TYPE_SHA1_SLTPWU;
7149 dgst_size = DGST_SIZE_4_5;
7150 parse_func = episerver_parse_hash;
7151 sort_by_digest = sort_by_digest_4_5;
7152 opti_type = OPTI_TYPE_ZERO_BYTE
7153 | OPTI_TYPE_PRECOMPUTE_INIT
7154 | OPTI_TYPE_PRECOMPUTE_MERKLE
7155 | OPTI_TYPE_EARLY_SKIP
7156 | OPTI_TYPE_NOT_ITERATED
7157 | OPTI_TYPE_PREPENDED_SALT
7158 | OPTI_TYPE_RAW_HASH;
7159 dgst_pos0 = 3;
7160 dgst_pos1 = 4;
7161 dgst_pos2 = 2;
7162 dgst_pos3 = 1;
7163 break;
7164
7165 case 150: hash_type = HASH_TYPE_SHA1;
7166 salt_type = SALT_TYPE_INTERN;
7167 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7168 opts_type = OPTS_TYPE_PT_GENERATE_BE
7169 | OPTS_TYPE_ST_ADD80
7170 | OPTS_TYPE_ST_ADDBITS15;
7171 kern_type = KERN_TYPE_HMACSHA1_PW;
7172 dgst_size = DGST_SIZE_4_5;
7173 parse_func = hmacsha1_parse_hash;
7174 sort_by_digest = sort_by_digest_4_5;
7175 opti_type = OPTI_TYPE_ZERO_BYTE
7176 | OPTI_TYPE_NOT_ITERATED;
7177 dgst_pos0 = 3;
7178 dgst_pos1 = 4;
7179 dgst_pos2 = 2;
7180 dgst_pos3 = 1;
7181 break;
7182
7183 case 160: hash_type = HASH_TYPE_SHA1;
7184 salt_type = SALT_TYPE_INTERN;
7185 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7186 opts_type = OPTS_TYPE_PT_GENERATE_BE
7187 | OPTS_TYPE_PT_ADD80
7188 | OPTS_TYPE_PT_ADDBITS15;
7189 kern_type = KERN_TYPE_HMACSHA1_SLT;
7190 dgst_size = DGST_SIZE_4_5;
7191 parse_func = hmacsha1_parse_hash;
7192 sort_by_digest = sort_by_digest_4_5;
7193 opti_type = OPTI_TYPE_ZERO_BYTE
7194 | OPTI_TYPE_NOT_ITERATED;
7195 dgst_pos0 = 3;
7196 dgst_pos1 = 4;
7197 dgst_pos2 = 2;
7198 dgst_pos3 = 1;
7199 break;
7200
7201 case 190: hash_type = HASH_TYPE_SHA1;
7202 salt_type = SALT_TYPE_NONE;
7203 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7204 opts_type = OPTS_TYPE_PT_GENERATE_BE
7205 | OPTS_TYPE_PT_ADD80
7206 | OPTS_TYPE_PT_ADDBITS15;
7207 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7208 dgst_size = DGST_SIZE_4_5;
7209 parse_func = sha1linkedin_parse_hash;
7210 sort_by_digest = sort_by_digest_4_5;
7211 opti_type = OPTI_TYPE_ZERO_BYTE
7212 | OPTI_TYPE_PRECOMPUTE_INIT
7213 | OPTI_TYPE_EARLY_SKIP
7214 | OPTI_TYPE_NOT_ITERATED
7215 | OPTI_TYPE_NOT_SALTED;
7216 dgst_pos0 = 0;
7217 dgst_pos1 = 4;
7218 dgst_pos2 = 3;
7219 dgst_pos3 = 2;
7220 break;
7221
7222 case 200: hash_type = HASH_TYPE_MYSQL;
7223 salt_type = SALT_TYPE_NONE;
7224 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7225 opts_type = 0;
7226 kern_type = KERN_TYPE_MYSQL;
7227 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7228 parse_func = mysql323_parse_hash;
7229 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7230 opti_type = OPTI_TYPE_ZERO_BYTE;
7231 dgst_pos0 = 0;
7232 dgst_pos1 = 1;
7233 dgst_pos2 = 2;
7234 dgst_pos3 = 3;
7235 break;
7236
7237 case 300: hash_type = HASH_TYPE_SHA1;
7238 salt_type = SALT_TYPE_NONE;
7239 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7240 opts_type = OPTS_TYPE_PT_GENERATE_BE
7241 | OPTS_TYPE_PT_ADD80
7242 | OPTS_TYPE_PT_ADDBITS15;
7243 kern_type = KERN_TYPE_MYSQL41;
7244 dgst_size = DGST_SIZE_4_5;
7245 parse_func = sha1_parse_hash;
7246 sort_by_digest = sort_by_digest_4_5;
7247 opti_type = OPTI_TYPE_ZERO_BYTE
7248 | OPTI_TYPE_PRECOMPUTE_INIT
7249 | OPTI_TYPE_PRECOMPUTE_MERKLE
7250 | OPTI_TYPE_EARLY_SKIP
7251 | OPTI_TYPE_NOT_ITERATED
7252 | OPTI_TYPE_NOT_SALTED;
7253 dgst_pos0 = 3;
7254 dgst_pos1 = 4;
7255 dgst_pos2 = 2;
7256 dgst_pos3 = 1;
7257 break;
7258
7259 case 400: hash_type = HASH_TYPE_MD5;
7260 salt_type = SALT_TYPE_EMBEDDED;
7261 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7262 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7263 kern_type = KERN_TYPE_PHPASS;
7264 dgst_size = DGST_SIZE_4_4;
7265 parse_func = phpass_parse_hash;
7266 sort_by_digest = sort_by_digest_4_4;
7267 opti_type = OPTI_TYPE_ZERO_BYTE;
7268 dgst_pos0 = 0;
7269 dgst_pos1 = 1;
7270 dgst_pos2 = 2;
7271 dgst_pos3 = 3;
7272 break;
7273
7274 case 500: hash_type = HASH_TYPE_MD5;
7275 salt_type = SALT_TYPE_EMBEDDED;
7276 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7277 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7278 kern_type = KERN_TYPE_MD5CRYPT;
7279 dgst_size = DGST_SIZE_4_4;
7280 parse_func = md5crypt_parse_hash;
7281 sort_by_digest = sort_by_digest_4_4;
7282 opti_type = OPTI_TYPE_ZERO_BYTE;
7283 dgst_pos0 = 0;
7284 dgst_pos1 = 1;
7285 dgst_pos2 = 2;
7286 dgst_pos3 = 3;
7287 break;
7288
7289 case 501: hash_type = HASH_TYPE_MD5;
7290 salt_type = SALT_TYPE_EMBEDDED;
7291 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7292 opts_type = OPTS_TYPE_PT_GENERATE_LE
7293 | OPTS_TYPE_HASH_COPY;
7294 kern_type = KERN_TYPE_MD5CRYPT;
7295 dgst_size = DGST_SIZE_4_4;
7296 parse_func = juniper_parse_hash;
7297 sort_by_digest = sort_by_digest_4_4;
7298 opti_type = OPTI_TYPE_ZERO_BYTE;
7299 dgst_pos0 = 0;
7300 dgst_pos1 = 1;
7301 dgst_pos2 = 2;
7302 dgst_pos3 = 3;
7303 break;
7304
7305 case 900: hash_type = HASH_TYPE_MD4;
7306 salt_type = SALT_TYPE_NONE;
7307 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7308 opts_type = OPTS_TYPE_PT_GENERATE_LE
7309 | OPTS_TYPE_PT_ADD80
7310 | OPTS_TYPE_PT_ADDBITS14;
7311 kern_type = KERN_TYPE_MD4;
7312 dgst_size = DGST_SIZE_4_4;
7313 parse_func = md4_parse_hash;
7314 sort_by_digest = sort_by_digest_4_4;
7315 opti_type = OPTI_TYPE_ZERO_BYTE
7316 | OPTI_TYPE_PRECOMPUTE_INIT
7317 | OPTI_TYPE_PRECOMPUTE_MERKLE
7318 | OPTI_TYPE_MEET_IN_MIDDLE
7319 | OPTI_TYPE_EARLY_SKIP
7320 | OPTI_TYPE_NOT_ITERATED
7321 | OPTI_TYPE_NOT_SALTED
7322 | OPTI_TYPE_RAW_HASH;
7323 dgst_pos0 = 0;
7324 dgst_pos1 = 3;
7325 dgst_pos2 = 2;
7326 dgst_pos3 = 1;
7327 break;
7328
7329 case 1000: hash_type = HASH_TYPE_MD4;
7330 salt_type = SALT_TYPE_NONE;
7331 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7332 opts_type = OPTS_TYPE_PT_GENERATE_LE
7333 | OPTS_TYPE_PT_ADD80
7334 | OPTS_TYPE_PT_ADDBITS14
7335 | OPTS_TYPE_PT_UNICODE;
7336 kern_type = KERN_TYPE_MD4_PWU;
7337 dgst_size = DGST_SIZE_4_4;
7338 parse_func = md4_parse_hash;
7339 sort_by_digest = sort_by_digest_4_4;
7340 opti_type = OPTI_TYPE_ZERO_BYTE
7341 | OPTI_TYPE_PRECOMPUTE_INIT
7342 | OPTI_TYPE_PRECOMPUTE_MERKLE
7343 | OPTI_TYPE_MEET_IN_MIDDLE
7344 | OPTI_TYPE_EARLY_SKIP
7345 | OPTI_TYPE_NOT_ITERATED
7346 | OPTI_TYPE_NOT_SALTED
7347 | OPTI_TYPE_RAW_HASH;
7348 dgst_pos0 = 0;
7349 dgst_pos1 = 3;
7350 dgst_pos2 = 2;
7351 dgst_pos3 = 1;
7352 break;
7353
7354 case 1100: hash_type = HASH_TYPE_MD4;
7355 salt_type = SALT_TYPE_INTERN;
7356 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7357 opts_type = OPTS_TYPE_PT_GENERATE_LE
7358 | OPTS_TYPE_PT_ADD80
7359 | OPTS_TYPE_PT_ADDBITS14
7360 | OPTS_TYPE_PT_UNICODE
7361 | OPTS_TYPE_ST_ADD80
7362 | OPTS_TYPE_ST_UNICODE
7363 | OPTS_TYPE_ST_LOWER;
7364 kern_type = KERN_TYPE_MD44_PWUSLT;
7365 dgst_size = DGST_SIZE_4_4;
7366 parse_func = dcc_parse_hash;
7367 sort_by_digest = sort_by_digest_4_4;
7368 opti_type = OPTI_TYPE_ZERO_BYTE
7369 | OPTI_TYPE_PRECOMPUTE_INIT
7370 | OPTI_TYPE_PRECOMPUTE_MERKLE
7371 | OPTI_TYPE_EARLY_SKIP
7372 | OPTI_TYPE_NOT_ITERATED;
7373 dgst_pos0 = 0;
7374 dgst_pos1 = 3;
7375 dgst_pos2 = 2;
7376 dgst_pos3 = 1;
7377 break;
7378
7379 case 1400: hash_type = HASH_TYPE_SHA256;
7380 salt_type = SALT_TYPE_NONE;
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;
7386 dgst_size = DGST_SIZE_4_8;
7387 parse_func = sha256_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_NOT_SALTED
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 1410: hash_type = HASH_TYPE_SHA256;
7403 salt_type = SALT_TYPE_INTERN;
7404 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7405 opts_type = OPTS_TYPE_PT_GENERATE_BE
7406 | OPTS_TYPE_ST_ADD80
7407 | OPTS_TYPE_ST_ADDBITS15;
7408 kern_type = KERN_TYPE_SHA256_PWSLT;
7409 dgst_size = DGST_SIZE_4_8;
7410 parse_func = sha256s_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_APPENDED_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 1420: 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_ADD80
7430 | OPTS_TYPE_PT_ADDBITS15;
7431 kern_type = KERN_TYPE_SHA256_SLTPW;
7432 dgst_size = DGST_SIZE_4_8;
7433 parse_func = sha256s_parse_hash;
7434 sort_by_digest = sort_by_digest_4_8;
7435 opti_type = OPTI_TYPE_ZERO_BYTE
7436 | OPTI_TYPE_PRECOMPUTE_INIT
7437 | OPTI_TYPE_PRECOMPUTE_MERKLE
7438 | OPTI_TYPE_EARLY_SKIP
7439 | OPTI_TYPE_NOT_ITERATED
7440 | OPTI_TYPE_PREPENDED_SALT
7441 | OPTI_TYPE_RAW_HASH;
7442 dgst_pos0 = 3;
7443 dgst_pos1 = 7;
7444 dgst_pos2 = 2;
7445 dgst_pos3 = 6;
7446 break;
7447
7448 case 1421: hash_type = HASH_TYPE_SHA256;
7449 salt_type = SALT_TYPE_EMBEDDED;
7450 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7451 opts_type = OPTS_TYPE_PT_GENERATE_BE
7452 | OPTS_TYPE_PT_ADD80
7453 | OPTS_TYPE_PT_ADDBITS15;
7454 kern_type = KERN_TYPE_SHA256_SLTPW;
7455 dgst_size = DGST_SIZE_4_8;
7456 parse_func = hmailserver_parse_hash;
7457 sort_by_digest = sort_by_digest_4_8;
7458 opti_type = OPTI_TYPE_ZERO_BYTE
7459 | OPTI_TYPE_PRECOMPUTE_INIT
7460 | OPTI_TYPE_PRECOMPUTE_MERKLE
7461 | OPTI_TYPE_EARLY_SKIP
7462 | OPTI_TYPE_NOT_ITERATED
7463 | OPTI_TYPE_PREPENDED_SALT
7464 | OPTI_TYPE_RAW_HASH;
7465 dgst_pos0 = 3;
7466 dgst_pos1 = 7;
7467 dgst_pos2 = 2;
7468 dgst_pos3 = 6;
7469 break;
7470
7471 case 1430: hash_type = HASH_TYPE_SHA256;
7472 salt_type = SALT_TYPE_INTERN;
7473 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7474 opts_type = OPTS_TYPE_PT_GENERATE_BE
7475 | OPTS_TYPE_PT_UNICODE
7476 | OPTS_TYPE_ST_ADD80
7477 | OPTS_TYPE_ST_ADDBITS15;
7478 kern_type = KERN_TYPE_SHA256_PWUSLT;
7479 dgst_size = DGST_SIZE_4_8;
7480 parse_func = sha256s_parse_hash;
7481 sort_by_digest = sort_by_digest_4_8;
7482 opti_type = OPTI_TYPE_ZERO_BYTE
7483 | OPTI_TYPE_PRECOMPUTE_INIT
7484 | OPTI_TYPE_PRECOMPUTE_MERKLE
7485 | OPTI_TYPE_EARLY_SKIP
7486 | OPTI_TYPE_NOT_ITERATED
7487 | OPTI_TYPE_APPENDED_SALT
7488 | OPTI_TYPE_RAW_HASH;
7489 dgst_pos0 = 3;
7490 dgst_pos1 = 7;
7491 dgst_pos2 = 2;
7492 dgst_pos3 = 6;
7493 break;
7494
7495 case 1440: hash_type = HASH_TYPE_SHA256;
7496 salt_type = SALT_TYPE_INTERN;
7497 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7498 opts_type = OPTS_TYPE_PT_GENERATE_BE
7499 | OPTS_TYPE_PT_ADD80
7500 | OPTS_TYPE_PT_ADDBITS15
7501 | OPTS_TYPE_PT_UNICODE;
7502 kern_type = KERN_TYPE_SHA256_SLTPWU;
7503 dgst_size = DGST_SIZE_4_8;
7504 parse_func = sha256s_parse_hash;
7505 sort_by_digest = sort_by_digest_4_8;
7506 opti_type = OPTI_TYPE_ZERO_BYTE
7507 | OPTI_TYPE_PRECOMPUTE_INIT
7508 | OPTI_TYPE_PRECOMPUTE_MERKLE
7509 | OPTI_TYPE_EARLY_SKIP
7510 | OPTI_TYPE_NOT_ITERATED
7511 | OPTI_TYPE_PREPENDED_SALT
7512 | OPTI_TYPE_RAW_HASH;
7513 dgst_pos0 = 3;
7514 dgst_pos1 = 7;
7515 dgst_pos2 = 2;
7516 dgst_pos3 = 6;
7517 break;
7518
7519 case 1441: hash_type = HASH_TYPE_SHA256;
7520 salt_type = SALT_TYPE_EMBEDDED;
7521 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7522 opts_type = OPTS_TYPE_PT_GENERATE_BE
7523 | OPTS_TYPE_PT_ADD80
7524 | OPTS_TYPE_PT_ADDBITS15
7525 | OPTS_TYPE_PT_UNICODE
7526 | OPTS_TYPE_ST_BASE64;
7527 kern_type = KERN_TYPE_SHA256_SLTPWU;
7528 dgst_size = DGST_SIZE_4_8;
7529 parse_func = episerver4_parse_hash;
7530 sort_by_digest = sort_by_digest_4_8;
7531 opti_type = OPTI_TYPE_ZERO_BYTE
7532 | OPTI_TYPE_PRECOMPUTE_INIT
7533 | OPTI_TYPE_PRECOMPUTE_MERKLE
7534 | OPTI_TYPE_EARLY_SKIP
7535 | OPTI_TYPE_NOT_ITERATED
7536 | OPTI_TYPE_PREPENDED_SALT
7537 | OPTI_TYPE_RAW_HASH;
7538 dgst_pos0 = 3;
7539 dgst_pos1 = 7;
7540 dgst_pos2 = 2;
7541 dgst_pos3 = 6;
7542 break;
7543
7544 case 1450: hash_type = HASH_TYPE_SHA256;
7545 salt_type = SALT_TYPE_INTERN;
7546 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7547 opts_type = OPTS_TYPE_PT_GENERATE_BE
7548 | OPTS_TYPE_ST_ADD80;
7549 kern_type = KERN_TYPE_HMACSHA256_PW;
7550 dgst_size = DGST_SIZE_4_8;
7551 parse_func = hmacsha256_parse_hash;
7552 sort_by_digest = sort_by_digest_4_8;
7553 opti_type = OPTI_TYPE_ZERO_BYTE
7554 | OPTI_TYPE_NOT_ITERATED;
7555 dgst_pos0 = 3;
7556 dgst_pos1 = 7;
7557 dgst_pos2 = 2;
7558 dgst_pos3 = 6;
7559 break;
7560
7561 case 1460: hash_type = HASH_TYPE_SHA256;
7562 salt_type = SALT_TYPE_INTERN;
7563 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7564 opts_type = OPTS_TYPE_PT_GENERATE_BE
7565 | OPTS_TYPE_PT_ADD80
7566 | OPTS_TYPE_PT_ADDBITS15;
7567 kern_type = KERN_TYPE_HMACSHA256_SLT;
7568 dgst_size = DGST_SIZE_4_8;
7569 parse_func = hmacsha256_parse_hash;
7570 sort_by_digest = sort_by_digest_4_8;
7571 opti_type = OPTI_TYPE_ZERO_BYTE
7572 | OPTI_TYPE_NOT_ITERATED;
7573 dgst_pos0 = 3;
7574 dgst_pos1 = 7;
7575 dgst_pos2 = 2;
7576 dgst_pos3 = 6;
7577 break;
7578
7579 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7580 salt_type = SALT_TYPE_EMBEDDED;
7581 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7582 opts_type = OPTS_TYPE_PT_GENERATE_LE
7583 | OPTS_TYPE_PT_BITSLICE;
7584 kern_type = KERN_TYPE_DESCRYPT;
7585 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7586 parse_func = descrypt_parse_hash;
7587 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7588 opti_type = OPTI_TYPE_ZERO_BYTE
7589 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7590 dgst_pos0 = 0;
7591 dgst_pos1 = 1;
7592 dgst_pos2 = 2;
7593 dgst_pos3 = 3;
7594 break;
7595
7596 case 1600: hash_type = HASH_TYPE_MD5;
7597 salt_type = SALT_TYPE_EMBEDDED;
7598 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7599 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7600 kern_type = KERN_TYPE_APR1CRYPT;
7601 dgst_size = DGST_SIZE_4_4;
7602 parse_func = md5apr1_parse_hash;
7603 sort_by_digest = sort_by_digest_4_4;
7604 opti_type = OPTI_TYPE_ZERO_BYTE;
7605 dgst_pos0 = 0;
7606 dgst_pos1 = 1;
7607 dgst_pos2 = 2;
7608 dgst_pos3 = 3;
7609 break;
7610
7611 case 1700: hash_type = HASH_TYPE_SHA512;
7612 salt_type = SALT_TYPE_NONE;
7613 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7614 opts_type = OPTS_TYPE_PT_GENERATE_BE
7615 | OPTS_TYPE_PT_ADD80
7616 | OPTS_TYPE_PT_ADDBITS15;
7617 kern_type = KERN_TYPE_SHA512;
7618 dgst_size = DGST_SIZE_8_8;
7619 parse_func = sha512_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_NOT_SALTED
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 1710: 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_ST_ADD80
7639 | OPTS_TYPE_ST_ADDBITS15;
7640 kern_type = KERN_TYPE_SHA512_PWSLT;
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_APPENDED_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 1711: 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_ST_ADD80
7662 | OPTS_TYPE_ST_ADDBITS15;
7663 kern_type = KERN_TYPE_SHA512_PWSLT;
7664 dgst_size = DGST_SIZE_8_8;
7665 parse_func = sha512b64s_parse_hash;
7666 sort_by_digest = sort_by_digest_8_8;
7667 opti_type = OPTI_TYPE_ZERO_BYTE
7668 | OPTI_TYPE_PRECOMPUTE_INIT
7669 | OPTI_TYPE_PRECOMPUTE_MERKLE
7670 | OPTI_TYPE_EARLY_SKIP
7671 | OPTI_TYPE_NOT_ITERATED
7672 | OPTI_TYPE_APPENDED_SALT
7673 | OPTI_TYPE_RAW_HASH;
7674 dgst_pos0 = 14;
7675 dgst_pos1 = 15;
7676 dgst_pos2 = 6;
7677 dgst_pos3 = 7;
7678 break;
7679
7680 case 1720: hash_type = HASH_TYPE_SHA512;
7681 salt_type = SALT_TYPE_INTERN;
7682 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7683 opts_type = OPTS_TYPE_PT_GENERATE_BE
7684 | OPTS_TYPE_PT_ADD80
7685 | OPTS_TYPE_PT_ADDBITS15;
7686 kern_type = KERN_TYPE_SHA512_SLTPW;
7687 dgst_size = DGST_SIZE_8_8;
7688 parse_func = sha512s_parse_hash;
7689 sort_by_digest = sort_by_digest_8_8;
7690 opti_type = OPTI_TYPE_ZERO_BYTE
7691 | OPTI_TYPE_PRECOMPUTE_INIT
7692 | OPTI_TYPE_PRECOMPUTE_MERKLE
7693 | OPTI_TYPE_EARLY_SKIP
7694 | OPTI_TYPE_NOT_ITERATED
7695 | OPTI_TYPE_PREPENDED_SALT
7696 | OPTI_TYPE_RAW_HASH;
7697 dgst_pos0 = 14;
7698 dgst_pos1 = 15;
7699 dgst_pos2 = 6;
7700 dgst_pos3 = 7;
7701 break;
7702
7703 case 1722: hash_type = HASH_TYPE_SHA512;
7704 salt_type = SALT_TYPE_EMBEDDED;
7705 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7706 opts_type = OPTS_TYPE_PT_GENERATE_BE
7707 | OPTS_TYPE_PT_ADD80
7708 | OPTS_TYPE_PT_ADDBITS15
7709 | OPTS_TYPE_ST_HEX;
7710 kern_type = KERN_TYPE_SHA512_SLTPW;
7711 dgst_size = DGST_SIZE_8_8;
7712 parse_func = osx512_parse_hash;
7713 sort_by_digest = sort_by_digest_8_8;
7714 opti_type = OPTI_TYPE_ZERO_BYTE
7715 | OPTI_TYPE_PRECOMPUTE_INIT
7716 | OPTI_TYPE_PRECOMPUTE_MERKLE
7717 | OPTI_TYPE_EARLY_SKIP
7718 | OPTI_TYPE_NOT_ITERATED
7719 | OPTI_TYPE_PREPENDED_SALT
7720 | OPTI_TYPE_RAW_HASH;
7721 dgst_pos0 = 14;
7722 dgst_pos1 = 15;
7723 dgst_pos2 = 6;
7724 dgst_pos3 = 7;
7725 break;
7726
7727 case 1730: hash_type = HASH_TYPE_SHA512;
7728 salt_type = SALT_TYPE_INTERN;
7729 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7730 opts_type = OPTS_TYPE_PT_GENERATE_BE
7731 | OPTS_TYPE_PT_UNICODE
7732 | OPTS_TYPE_ST_ADD80
7733 | OPTS_TYPE_ST_ADDBITS15;
7734 kern_type = KERN_TYPE_SHA512_PWSLTU;
7735 dgst_size = DGST_SIZE_8_8;
7736 parse_func = sha512s_parse_hash;
7737 sort_by_digest = sort_by_digest_8_8;
7738 opti_type = OPTI_TYPE_ZERO_BYTE
7739 | OPTI_TYPE_PRECOMPUTE_INIT
7740 | OPTI_TYPE_PRECOMPUTE_MERKLE
7741 | OPTI_TYPE_EARLY_SKIP
7742 | OPTI_TYPE_NOT_ITERATED
7743 | OPTI_TYPE_APPENDED_SALT
7744 | OPTI_TYPE_RAW_HASH;
7745 dgst_pos0 = 14;
7746 dgst_pos1 = 15;
7747 dgst_pos2 = 6;
7748 dgst_pos3 = 7;
7749 break;
7750
7751 case 1731: hash_type = HASH_TYPE_SHA512;
7752 salt_type = SALT_TYPE_EMBEDDED;
7753 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7754 opts_type = OPTS_TYPE_PT_GENERATE_BE
7755 | OPTS_TYPE_PT_UNICODE
7756 | OPTS_TYPE_ST_ADD80
7757 | OPTS_TYPE_ST_ADDBITS15
7758 | OPTS_TYPE_ST_HEX;
7759 kern_type = KERN_TYPE_SHA512_PWSLTU;
7760 dgst_size = DGST_SIZE_8_8;
7761 parse_func = mssql2012_parse_hash;
7762 sort_by_digest = sort_by_digest_8_8;
7763 opti_type = OPTI_TYPE_ZERO_BYTE
7764 | OPTI_TYPE_PRECOMPUTE_INIT
7765 | OPTI_TYPE_PRECOMPUTE_MERKLE
7766 | OPTI_TYPE_EARLY_SKIP
7767 | OPTI_TYPE_NOT_ITERATED
7768 | OPTI_TYPE_APPENDED_SALT
7769 | OPTI_TYPE_RAW_HASH;
7770 dgst_pos0 = 14;
7771 dgst_pos1 = 15;
7772 dgst_pos2 = 6;
7773 dgst_pos3 = 7;
7774 break;
7775
7776 case 1740: hash_type = HASH_TYPE_SHA512;
7777 salt_type = SALT_TYPE_INTERN;
7778 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7779 opts_type = OPTS_TYPE_PT_GENERATE_BE
7780 | OPTS_TYPE_PT_ADD80
7781 | OPTS_TYPE_PT_ADDBITS15
7782 | OPTS_TYPE_PT_UNICODE;
7783 kern_type = KERN_TYPE_SHA512_SLTPWU;
7784 dgst_size = DGST_SIZE_8_8;
7785 parse_func = sha512s_parse_hash;
7786 sort_by_digest = sort_by_digest_8_8;
7787 opti_type = OPTI_TYPE_ZERO_BYTE
7788 | OPTI_TYPE_PRECOMPUTE_INIT
7789 | OPTI_TYPE_PRECOMPUTE_MERKLE
7790 | OPTI_TYPE_EARLY_SKIP
7791 | OPTI_TYPE_NOT_ITERATED
7792 | OPTI_TYPE_PREPENDED_SALT
7793 | OPTI_TYPE_RAW_HASH;
7794 dgst_pos0 = 14;
7795 dgst_pos1 = 15;
7796 dgst_pos2 = 6;
7797 dgst_pos3 = 7;
7798 break;
7799
7800 case 1750: hash_type = HASH_TYPE_SHA512;
7801 salt_type = SALT_TYPE_INTERN;
7802 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7803 opts_type = OPTS_TYPE_PT_GENERATE_BE
7804 | OPTS_TYPE_ST_ADD80;
7805 kern_type = KERN_TYPE_HMACSHA512_PW;
7806 dgst_size = DGST_SIZE_8_8;
7807 parse_func = hmacsha512_parse_hash;
7808 sort_by_digest = sort_by_digest_8_8;
7809 opti_type = OPTI_TYPE_ZERO_BYTE
7810 | OPTI_TYPE_NOT_ITERATED;
7811 dgst_pos0 = 14;
7812 dgst_pos1 = 15;
7813 dgst_pos2 = 6;
7814 dgst_pos3 = 7;
7815 break;
7816
7817 case 1760: hash_type = HASH_TYPE_SHA512;
7818 salt_type = SALT_TYPE_INTERN;
7819 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7820 opts_type = OPTS_TYPE_PT_GENERATE_BE
7821 | OPTS_TYPE_PT_ADD80
7822 | OPTS_TYPE_PT_ADDBITS15;
7823 kern_type = KERN_TYPE_HMACSHA512_SLT;
7824 dgst_size = DGST_SIZE_8_8;
7825 parse_func = hmacsha512_parse_hash;
7826 sort_by_digest = sort_by_digest_8_8;
7827 opti_type = OPTI_TYPE_ZERO_BYTE
7828 | OPTI_TYPE_NOT_ITERATED;
7829 dgst_pos0 = 14;
7830 dgst_pos1 = 15;
7831 dgst_pos2 = 6;
7832 dgst_pos3 = 7;
7833 break;
7834
7835 case 1800: hash_type = HASH_TYPE_SHA512;
7836 salt_type = SALT_TYPE_EMBEDDED;
7837 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7838 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7839 kern_type = KERN_TYPE_SHA512CRYPT;
7840 dgst_size = DGST_SIZE_8_8;
7841 parse_func = sha512crypt_parse_hash;
7842 sort_by_digest = sort_by_digest_8_8;
7843 opti_type = OPTI_TYPE_ZERO_BYTE;
7844 dgst_pos0 = 0;
7845 dgst_pos1 = 1;
7846 dgst_pos2 = 2;
7847 dgst_pos3 = 3;
7848 break;
7849
7850 case 2100: hash_type = HASH_TYPE_DCC2;
7851 salt_type = SALT_TYPE_EMBEDDED;
7852 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7853 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
7854 | OPTS_TYPE_ST_LOWER
7855 | OPTS_TYPE_ST_UNICODE;
7856 kern_type = KERN_TYPE_DCC2;
7857 dgst_size = DGST_SIZE_4_4;
7858 parse_func = dcc2_parse_hash;
7859 sort_by_digest = sort_by_digest_4_4;
7860 opti_type = OPTI_TYPE_ZERO_BYTE;
7861 dgst_pos0 = 0;
7862 dgst_pos1 = 1;
7863 dgst_pos2 = 2;
7864 dgst_pos3 = 3;
7865 break;
7866
7867 case 2400: hash_type = HASH_TYPE_MD5;
7868 salt_type = SALT_TYPE_NONE;
7869 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7870 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7871 kern_type = KERN_TYPE_MD5PIX;
7872 dgst_size = DGST_SIZE_4_4;
7873 parse_func = md5pix_parse_hash;
7874 sort_by_digest = sort_by_digest_4_4;
7875 opti_type = OPTI_TYPE_ZERO_BYTE
7876 | OPTI_TYPE_PRECOMPUTE_INIT
7877 | OPTI_TYPE_PRECOMPUTE_MERKLE
7878 | OPTI_TYPE_EARLY_SKIP
7879 | OPTI_TYPE_NOT_ITERATED
7880 | OPTI_TYPE_NOT_SALTED;
7881 dgst_pos0 = 0;
7882 dgst_pos1 = 3;
7883 dgst_pos2 = 2;
7884 dgst_pos3 = 1;
7885 break;
7886
7887 case 2410: hash_type = HASH_TYPE_MD5;
7888 salt_type = SALT_TYPE_INTERN;
7889 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7890 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7891 kern_type = KERN_TYPE_MD5ASA;
7892 dgst_size = DGST_SIZE_4_4;
7893 parse_func = md5asa_parse_hash;
7894 sort_by_digest = sort_by_digest_4_4;
7895 opti_type = OPTI_TYPE_ZERO_BYTE
7896 | OPTI_TYPE_PRECOMPUTE_INIT
7897 | OPTI_TYPE_PRECOMPUTE_MERKLE
7898 | OPTI_TYPE_EARLY_SKIP
7899 | OPTI_TYPE_NOT_ITERATED;
7900 dgst_pos0 = 0;
7901 dgst_pos1 = 3;
7902 dgst_pos2 = 2;
7903 dgst_pos3 = 1;
7904 break;
7905
7906 case 2500: hash_type = HASH_TYPE_WPA;
7907 salt_type = SALT_TYPE_EMBEDDED;
7908 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7909 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7910 kern_type = KERN_TYPE_WPA;
7911 dgst_size = DGST_SIZE_4_4;
7912 parse_func = wpa_parse_hash;
7913 sort_by_digest = sort_by_digest_4_4;
7914 opti_type = OPTI_TYPE_ZERO_BYTE;
7915 dgst_pos0 = 0;
7916 dgst_pos1 = 1;
7917 dgst_pos2 = 2;
7918 dgst_pos3 = 3;
7919 break;
7920
7921 case 2600: hash_type = HASH_TYPE_MD5;
7922 salt_type = SALT_TYPE_VIRTUAL;
7923 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7924 opts_type = OPTS_TYPE_PT_GENERATE_LE
7925 | OPTS_TYPE_PT_ADD80
7926 | OPTS_TYPE_PT_ADDBITS14
7927 | OPTS_TYPE_ST_ADD80;
7928 kern_type = KERN_TYPE_MD55_PWSLT1;
7929 dgst_size = DGST_SIZE_4_4;
7930 parse_func = md5md5_parse_hash;
7931 sort_by_digest = sort_by_digest_4_4;
7932 opti_type = OPTI_TYPE_ZERO_BYTE
7933 | OPTI_TYPE_PRECOMPUTE_INIT
7934 | OPTI_TYPE_PRECOMPUTE_MERKLE
7935 | OPTI_TYPE_EARLY_SKIP;
7936 dgst_pos0 = 0;
7937 dgst_pos1 = 3;
7938 dgst_pos2 = 2;
7939 dgst_pos3 = 1;
7940 break;
7941
7942 case 2611: hash_type = HASH_TYPE_MD5;
7943 salt_type = SALT_TYPE_INTERN;
7944 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7945 opts_type = OPTS_TYPE_PT_GENERATE_LE
7946 | OPTS_TYPE_PT_ADD80
7947 | OPTS_TYPE_PT_ADDBITS14
7948 | OPTS_TYPE_ST_ADD80;
7949 kern_type = KERN_TYPE_MD55_PWSLT1;
7950 dgst_size = DGST_SIZE_4_4;
7951 parse_func = vb3_parse_hash;
7952 sort_by_digest = sort_by_digest_4_4;
7953 opti_type = OPTI_TYPE_ZERO_BYTE
7954 | OPTI_TYPE_PRECOMPUTE_INIT
7955 | OPTI_TYPE_PRECOMPUTE_MERKLE
7956 | OPTI_TYPE_EARLY_SKIP;
7957 dgst_pos0 = 0;
7958 dgst_pos1 = 3;
7959 dgst_pos2 = 2;
7960 dgst_pos3 = 1;
7961 break;
7962
7963 case 2612: hash_type = HASH_TYPE_MD5;
7964 salt_type = SALT_TYPE_EMBEDDED;
7965 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7966 opts_type = OPTS_TYPE_PT_GENERATE_LE
7967 | OPTS_TYPE_PT_ADD80
7968 | OPTS_TYPE_PT_ADDBITS14
7969 | OPTS_TYPE_ST_ADD80
7970 | OPTS_TYPE_ST_HEX;
7971 kern_type = KERN_TYPE_MD55_PWSLT1;
7972 dgst_size = DGST_SIZE_4_4;
7973 parse_func = phps_parse_hash;
7974 sort_by_digest = sort_by_digest_4_4;
7975 opti_type = OPTI_TYPE_ZERO_BYTE
7976 | OPTI_TYPE_PRECOMPUTE_INIT
7977 | OPTI_TYPE_PRECOMPUTE_MERKLE
7978 | OPTI_TYPE_EARLY_SKIP;
7979 dgst_pos0 = 0;
7980 dgst_pos1 = 3;
7981 dgst_pos2 = 2;
7982 dgst_pos3 = 1;
7983 break;
7984
7985 case 2711: hash_type = HASH_TYPE_MD5;
7986 salt_type = SALT_TYPE_INTERN;
7987 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7988 opts_type = OPTS_TYPE_PT_GENERATE_LE
7989 | OPTS_TYPE_PT_ADD80
7990 | OPTS_TYPE_PT_ADDBITS14
7991 | OPTS_TYPE_ST_ADD80;
7992 kern_type = KERN_TYPE_MD55_PWSLT2;
7993 dgst_size = DGST_SIZE_4_4;
7994 parse_func = vb30_parse_hash;
7995 sort_by_digest = sort_by_digest_4_4;
7996 opti_type = OPTI_TYPE_ZERO_BYTE
7997 | OPTI_TYPE_PRECOMPUTE_INIT
7998 | OPTI_TYPE_EARLY_SKIP;
7999 dgst_pos0 = 0;
8000 dgst_pos1 = 3;
8001 dgst_pos2 = 2;
8002 dgst_pos3 = 1;
8003 break;
8004
8005 case 2811: hash_type = HASH_TYPE_MD5;
8006 salt_type = SALT_TYPE_INTERN;
8007 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8008 opts_type = OPTS_TYPE_PT_GENERATE_LE
8009 | OPTS_TYPE_PT_ADD80
8010 | OPTS_TYPE_PT_ADDBITS14;
8011 kern_type = KERN_TYPE_MD55_SLTPW;
8012 dgst_size = DGST_SIZE_4_4;
8013 parse_func = ipb2_parse_hash;
8014 sort_by_digest = sort_by_digest_4_4;
8015 opti_type = OPTI_TYPE_ZERO_BYTE
8016 | OPTI_TYPE_PRECOMPUTE_INIT
8017 | OPTI_TYPE_EARLY_SKIP;
8018 dgst_pos0 = 0;
8019 dgst_pos1 = 3;
8020 dgst_pos2 = 2;
8021 dgst_pos3 = 1;
8022 break;
8023
8024 case 3000: hash_type = HASH_TYPE_LM;
8025 salt_type = SALT_TYPE_NONE;
8026 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8027 opts_type = OPTS_TYPE_PT_GENERATE_LE
8028 | OPTS_TYPE_PT_UPPER
8029 | OPTS_TYPE_PT_BITSLICE;
8030 kern_type = KERN_TYPE_LM;
8031 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8032 parse_func = lm_parse_hash;
8033 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8034 opti_type = OPTI_TYPE_ZERO_BYTE
8035 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8036 dgst_pos0 = 0;
8037 dgst_pos1 = 1;
8038 dgst_pos2 = 2;
8039 dgst_pos3 = 3;
8040 break;
8041
8042 case 3100: hash_type = HASH_TYPE_ORACLEH;
8043 salt_type = SALT_TYPE_INTERN;
8044 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8045 opts_type = OPTS_TYPE_PT_GENERATE_LE
8046 | OPTS_TYPE_PT_UPPER
8047 | OPTS_TYPE_ST_UPPER;
8048 kern_type = KERN_TYPE_ORACLEH;
8049 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8050 parse_func = oracleh_parse_hash;
8051 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8052 opti_type = OPTI_TYPE_ZERO_BYTE;
8053 dgst_pos0 = 0;
8054 dgst_pos1 = 1;
8055 dgst_pos2 = 2;
8056 dgst_pos3 = 3;
8057 break;
8058
8059 case 3200: hash_type = HASH_TYPE_BCRYPT;
8060 salt_type = SALT_TYPE_EMBEDDED;
8061 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8062 opts_type = OPTS_TYPE_PT_GENERATE_LE
8063 | OPTS_TYPE_ST_GENERATE_LE;
8064 kern_type = KERN_TYPE_BCRYPT;
8065 dgst_size = DGST_SIZE_4_6;
8066 parse_func = bcrypt_parse_hash;
8067 sort_by_digest = sort_by_digest_4_6;
8068 opti_type = OPTI_TYPE_ZERO_BYTE;
8069 dgst_pos0 = 0;
8070 dgst_pos1 = 1;
8071 dgst_pos2 = 2;
8072 dgst_pos3 = 3;
8073 break;
8074
8075 case 3710: hash_type = HASH_TYPE_MD5;
8076 salt_type = SALT_TYPE_INTERN;
8077 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8078 opts_type = OPTS_TYPE_PT_GENERATE_LE
8079 | OPTS_TYPE_PT_ADD80
8080 | OPTS_TYPE_PT_ADDBITS14;
8081 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8082 dgst_size = DGST_SIZE_4_4;
8083 parse_func = md5s_parse_hash;
8084 sort_by_digest = sort_by_digest_4_4;
8085 opti_type = OPTI_TYPE_ZERO_BYTE
8086 | OPTI_TYPE_PRECOMPUTE_INIT
8087 | OPTI_TYPE_PRECOMPUTE_MERKLE
8088 | OPTI_TYPE_EARLY_SKIP;
8089 dgst_pos0 = 0;
8090 dgst_pos1 = 3;
8091 dgst_pos2 = 2;
8092 dgst_pos3 = 1;
8093 break;
8094
8095 case 3711: hash_type = HASH_TYPE_MD5;
8096 salt_type = SALT_TYPE_EMBEDDED;
8097 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8098 opts_type = OPTS_TYPE_PT_GENERATE_LE
8099 | OPTS_TYPE_PT_ADD80
8100 | OPTS_TYPE_PT_ADDBITS14;
8101 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8102 dgst_size = DGST_SIZE_4_4;
8103 parse_func = mediawiki_b_parse_hash;
8104 sort_by_digest = sort_by_digest_4_4;
8105 opti_type = OPTI_TYPE_ZERO_BYTE
8106 | OPTI_TYPE_PRECOMPUTE_INIT
8107 | OPTI_TYPE_PRECOMPUTE_MERKLE
8108 | OPTI_TYPE_EARLY_SKIP;
8109 dgst_pos0 = 0;
8110 dgst_pos1 = 3;
8111 dgst_pos2 = 2;
8112 dgst_pos3 = 1;
8113 break;
8114
8115 case 3800: hash_type = HASH_TYPE_MD5;
8116 salt_type = SALT_TYPE_INTERN;
8117 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8118 opts_type = OPTS_TYPE_PT_GENERATE_LE
8119 | OPTS_TYPE_ST_ADDBITS14;
8120 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8121 dgst_size = DGST_SIZE_4_4;
8122 parse_func = md5s_parse_hash;
8123 sort_by_digest = sort_by_digest_4_4;
8124 opti_type = OPTI_TYPE_ZERO_BYTE
8125 | OPTI_TYPE_PRECOMPUTE_INIT
8126 | OPTI_TYPE_PRECOMPUTE_MERKLE
8127 | OPTI_TYPE_EARLY_SKIP
8128 | OPTI_TYPE_NOT_ITERATED
8129 | OPTI_TYPE_RAW_HASH;
8130 dgst_pos0 = 0;
8131 dgst_pos1 = 3;
8132 dgst_pos2 = 2;
8133 dgst_pos3 = 1;
8134 break;
8135
8136 case 4300: hash_type = HASH_TYPE_MD5;
8137 salt_type = SALT_TYPE_VIRTUAL;
8138 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8139 opts_type = OPTS_TYPE_PT_GENERATE_LE
8140 | OPTS_TYPE_PT_ADD80
8141 | OPTS_TYPE_PT_ADDBITS14
8142 | OPTS_TYPE_ST_ADD80;
8143 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8144 dgst_size = DGST_SIZE_4_4;
8145 parse_func = md5md5_parse_hash;
8146 sort_by_digest = sort_by_digest_4_4;
8147 opti_type = OPTI_TYPE_ZERO_BYTE
8148 | OPTI_TYPE_PRECOMPUTE_INIT
8149 | OPTI_TYPE_PRECOMPUTE_MERKLE
8150 | OPTI_TYPE_EARLY_SKIP;
8151 dgst_pos0 = 0;
8152 dgst_pos1 = 3;
8153 dgst_pos2 = 2;
8154 dgst_pos3 = 1;
8155 break;
8156
8157
8158 case 4400: hash_type = HASH_TYPE_MD5;
8159 salt_type = SALT_TYPE_NONE;
8160 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8161 opts_type = OPTS_TYPE_PT_GENERATE_BE
8162 | OPTS_TYPE_PT_ADD80
8163 | OPTS_TYPE_PT_ADDBITS15;
8164 kern_type = KERN_TYPE_MD5_SHA1;
8165 dgst_size = DGST_SIZE_4_4;
8166 parse_func = md5_parse_hash;
8167 sort_by_digest = sort_by_digest_4_4;
8168 opti_type = OPTI_TYPE_ZERO_BYTE
8169 | OPTI_TYPE_PRECOMPUTE_INIT
8170 | OPTI_TYPE_PRECOMPUTE_MERKLE
8171 | OPTI_TYPE_EARLY_SKIP
8172 | OPTI_TYPE_NOT_ITERATED
8173 | OPTI_TYPE_NOT_SALTED
8174 | OPTI_TYPE_RAW_HASH;
8175 dgst_pos0 = 0;
8176 dgst_pos1 = 3;
8177 dgst_pos2 = 2;
8178 dgst_pos3 = 1;
8179 break;
8180
8181 case 4500: hash_type = HASH_TYPE_SHA1;
8182 salt_type = SALT_TYPE_NONE;
8183 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8184 opts_type = OPTS_TYPE_PT_GENERATE_BE
8185 | OPTS_TYPE_PT_ADD80
8186 | OPTS_TYPE_PT_ADDBITS15;
8187 kern_type = KERN_TYPE_SHA11;
8188 dgst_size = DGST_SIZE_4_5;
8189 parse_func = sha1_parse_hash;
8190 sort_by_digest = sort_by_digest_4_5;
8191 opti_type = OPTI_TYPE_ZERO_BYTE
8192 | OPTI_TYPE_PRECOMPUTE_INIT
8193 | OPTI_TYPE_PRECOMPUTE_MERKLE
8194 | OPTI_TYPE_EARLY_SKIP
8195 | OPTI_TYPE_NOT_SALTED;
8196 dgst_pos0 = 3;
8197 dgst_pos1 = 4;
8198 dgst_pos2 = 2;
8199 dgst_pos3 = 1;
8200 break;
8201
8202 case 4700: hash_type = HASH_TYPE_SHA1;
8203 salt_type = SALT_TYPE_NONE;
8204 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8205 opts_type = OPTS_TYPE_PT_GENERATE_LE
8206 | OPTS_TYPE_PT_ADD80
8207 | OPTS_TYPE_PT_ADDBITS14;
8208 kern_type = KERN_TYPE_SHA1_MD5;
8209 dgst_size = DGST_SIZE_4_5;
8210 parse_func = sha1_parse_hash;
8211 sort_by_digest = sort_by_digest_4_5;
8212 opti_type = OPTI_TYPE_ZERO_BYTE
8213 | OPTI_TYPE_PRECOMPUTE_INIT
8214 | OPTI_TYPE_PRECOMPUTE_MERKLE
8215 | OPTI_TYPE_EARLY_SKIP
8216 | OPTI_TYPE_NOT_ITERATED
8217 | OPTI_TYPE_NOT_SALTED
8218 | OPTI_TYPE_RAW_HASH;
8219 dgst_pos0 = 3;
8220 dgst_pos1 = 4;
8221 dgst_pos2 = 2;
8222 dgst_pos3 = 1;
8223 break;
8224
8225 case 4800: hash_type = HASH_TYPE_MD5;
8226 salt_type = SALT_TYPE_EMBEDDED;
8227 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8228 opts_type = OPTS_TYPE_PT_GENERATE_LE
8229 | OPTS_TYPE_PT_ADDBITS14;
8230 kern_type = KERN_TYPE_MD5_CHAP;
8231 dgst_size = DGST_SIZE_4_4;
8232 parse_func = chap_parse_hash;
8233 sort_by_digest = sort_by_digest_4_4;
8234 opti_type = OPTI_TYPE_ZERO_BYTE
8235 | OPTI_TYPE_PRECOMPUTE_INIT
8236 | OPTI_TYPE_PRECOMPUTE_MERKLE
8237 | OPTI_TYPE_MEET_IN_MIDDLE
8238 | OPTI_TYPE_EARLY_SKIP
8239 | OPTI_TYPE_NOT_ITERATED
8240 | OPTI_TYPE_RAW_HASH;
8241 dgst_pos0 = 0;
8242 dgst_pos1 = 3;
8243 dgst_pos2 = 2;
8244 dgst_pos3 = 1;
8245 break;
8246
8247 case 4900: hash_type = HASH_TYPE_SHA1;
8248 salt_type = SALT_TYPE_INTERN;
8249 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8250 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8251 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8252 dgst_size = DGST_SIZE_4_5;
8253 parse_func = sha1s_parse_hash;
8254 sort_by_digest = sort_by_digest_4_5;
8255 opti_type = OPTI_TYPE_ZERO_BYTE
8256 | OPTI_TYPE_PRECOMPUTE_INIT
8257 | OPTI_TYPE_PRECOMPUTE_MERKLE
8258 | OPTI_TYPE_EARLY_SKIP;
8259 dgst_pos0 = 3;
8260 dgst_pos1 = 4;
8261 dgst_pos2 = 2;
8262 dgst_pos3 = 1;
8263 break;
8264
8265 case 5000: hash_type = HASH_TYPE_KECCAK;
8266 salt_type = SALT_TYPE_EMBEDDED;
8267 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8268 opts_type = OPTS_TYPE_PT_GENERATE_LE
8269 | OPTS_TYPE_PT_ADD01;
8270 kern_type = KERN_TYPE_KECCAK;
8271 dgst_size = DGST_SIZE_8_25;
8272 parse_func = keccak_parse_hash;
8273 sort_by_digest = sort_by_digest_8_25;
8274 opti_type = OPTI_TYPE_ZERO_BYTE
8275 | OPTI_TYPE_RAW_HASH;
8276 dgst_pos0 = 2;
8277 dgst_pos1 = 3;
8278 dgst_pos2 = 4;
8279 dgst_pos3 = 5;
8280 break;
8281
8282 case 5100: hash_type = HASH_TYPE_MD5H;
8283 salt_type = SALT_TYPE_NONE;
8284 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8285 opts_type = OPTS_TYPE_PT_GENERATE_LE
8286 | OPTS_TYPE_PT_ADD80
8287 | OPTS_TYPE_PT_ADDBITS14;
8288 kern_type = KERN_TYPE_MD5H;
8289 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8290 parse_func = md5half_parse_hash;
8291 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8292 opti_type = OPTI_TYPE_ZERO_BYTE
8293 | OPTI_TYPE_RAW_HASH;
8294 dgst_pos0 = 0;
8295 dgst_pos1 = 1;
8296 dgst_pos2 = 2;
8297 dgst_pos3 = 3;
8298 break;
8299
8300 case 5200: hash_type = HASH_TYPE_SHA256;
8301 salt_type = SALT_TYPE_EMBEDDED;
8302 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8303 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8304 kern_type = KERN_TYPE_PSAFE3;
8305 dgst_size = DGST_SIZE_4_8;
8306 parse_func = psafe3_parse_hash;
8307 sort_by_digest = sort_by_digest_4_8;
8308 opti_type = OPTI_TYPE_ZERO_BYTE;
8309 dgst_pos0 = 0;
8310 dgst_pos1 = 1;
8311 dgst_pos2 = 2;
8312 dgst_pos3 = 3;
8313 break;
8314
8315 case 5300: hash_type = HASH_TYPE_MD5;
8316 salt_type = SALT_TYPE_EMBEDDED;
8317 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8318 opts_type = OPTS_TYPE_PT_GENERATE_LE
8319 | OPTS_TYPE_ST_ADD80;
8320 kern_type = KERN_TYPE_IKEPSK_MD5;
8321 dgst_size = DGST_SIZE_4_4;
8322 parse_func = ikepsk_md5_parse_hash;
8323 sort_by_digest = sort_by_digest_4_4;
8324 opti_type = OPTI_TYPE_ZERO_BYTE;
8325 dgst_pos0 = 0;
8326 dgst_pos1 = 3;
8327 dgst_pos2 = 2;
8328 dgst_pos3 = 1;
8329 break;
8330
8331 case 5400: hash_type = HASH_TYPE_SHA1;
8332 salt_type = SALT_TYPE_EMBEDDED;
8333 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8334 opts_type = OPTS_TYPE_PT_GENERATE_BE
8335 | OPTS_TYPE_ST_ADD80;
8336 kern_type = KERN_TYPE_IKEPSK_SHA1;
8337 dgst_size = DGST_SIZE_4_5;
8338 parse_func = ikepsk_sha1_parse_hash;
8339 sort_by_digest = sort_by_digest_4_5;
8340 opti_type = OPTI_TYPE_ZERO_BYTE;
8341 dgst_pos0 = 3;
8342 dgst_pos1 = 4;
8343 dgst_pos2 = 2;
8344 dgst_pos3 = 1;
8345 break;
8346
8347 case 5500: hash_type = HASH_TYPE_NETNTLM;
8348 salt_type = SALT_TYPE_EMBEDDED;
8349 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8350 opts_type = OPTS_TYPE_PT_GENERATE_LE
8351 | OPTS_TYPE_PT_ADD80
8352 | OPTS_TYPE_PT_ADDBITS14
8353 | OPTS_TYPE_PT_UNICODE
8354 | OPTS_TYPE_ST_HEX;
8355 kern_type = KERN_TYPE_NETNTLMv1;
8356 dgst_size = DGST_SIZE_4_4;
8357 parse_func = netntlmv1_parse_hash;
8358 sort_by_digest = sort_by_digest_4_4;
8359 opti_type = OPTI_TYPE_ZERO_BYTE
8360 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8361 dgst_pos0 = 0;
8362 dgst_pos1 = 1;
8363 dgst_pos2 = 2;
8364 dgst_pos3 = 3;
8365 break;
8366
8367 case 5600: hash_type = HASH_TYPE_MD5;
8368 salt_type = SALT_TYPE_EMBEDDED;
8369 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8370 opts_type = OPTS_TYPE_PT_GENERATE_LE
8371 | OPTS_TYPE_PT_ADD80
8372 | OPTS_TYPE_PT_ADDBITS14
8373 | OPTS_TYPE_PT_UNICODE;
8374 kern_type = KERN_TYPE_NETNTLMv2;
8375 dgst_size = DGST_SIZE_4_4;
8376 parse_func = netntlmv2_parse_hash;
8377 sort_by_digest = sort_by_digest_4_4;
8378 opti_type = OPTI_TYPE_ZERO_BYTE;
8379 dgst_pos0 = 0;
8380 dgst_pos1 = 3;
8381 dgst_pos2 = 2;
8382 dgst_pos3 = 1;
8383 break;
8384
8385 case 5700: hash_type = HASH_TYPE_SHA256;
8386 salt_type = SALT_TYPE_NONE;
8387 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8388 opts_type = OPTS_TYPE_PT_GENERATE_BE
8389 | OPTS_TYPE_PT_ADD80
8390 | OPTS_TYPE_PT_ADDBITS15;
8391 kern_type = KERN_TYPE_SHA256;
8392 dgst_size = DGST_SIZE_4_8;
8393 parse_func = cisco4_parse_hash;
8394 sort_by_digest = sort_by_digest_4_8;
8395 opti_type = OPTI_TYPE_ZERO_BYTE
8396 | OPTI_TYPE_PRECOMPUTE_INIT
8397 | OPTI_TYPE_PRECOMPUTE_MERKLE
8398 | OPTI_TYPE_EARLY_SKIP
8399 | OPTI_TYPE_NOT_ITERATED
8400 | OPTI_TYPE_NOT_SALTED
8401 | OPTI_TYPE_RAW_HASH;
8402 dgst_pos0 = 3;
8403 dgst_pos1 = 7;
8404 dgst_pos2 = 2;
8405 dgst_pos3 = 6;
8406 break;
8407
8408 case 5800: hash_type = HASH_TYPE_SHA1;
8409 salt_type = SALT_TYPE_INTERN;
8410 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8411 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8412 | OPTS_TYPE_ST_ADD80;
8413 kern_type = KERN_TYPE_ANDROIDPIN;
8414 dgst_size = DGST_SIZE_4_5;
8415 parse_func = androidpin_parse_hash;
8416 sort_by_digest = sort_by_digest_4_5;
8417 opti_type = OPTI_TYPE_ZERO_BYTE;
8418 dgst_pos0 = 0;
8419 dgst_pos1 = 1;
8420 dgst_pos2 = 2;
8421 dgst_pos3 = 3;
8422 break;
8423
8424 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8425 salt_type = SALT_TYPE_NONE;
8426 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8427 opts_type = OPTS_TYPE_PT_GENERATE_LE
8428 | OPTS_TYPE_PT_ADD80;
8429 kern_type = KERN_TYPE_RIPEMD160;
8430 dgst_size = DGST_SIZE_4_5;
8431 parse_func = ripemd160_parse_hash;
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 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8441 salt_type = SALT_TYPE_NONE;
8442 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8443 opts_type = OPTS_TYPE_PT_GENERATE_BE
8444 | OPTS_TYPE_PT_ADD80;
8445 kern_type = KERN_TYPE_WHIRLPOOL;
8446 dgst_size = DGST_SIZE_4_16;
8447 parse_func = whirlpool_parse_hash;
8448 sort_by_digest = sort_by_digest_4_16;
8449 opti_type = OPTI_TYPE_ZERO_BYTE;
8450 dgst_pos0 = 0;
8451 dgst_pos1 = 1;
8452 dgst_pos2 = 2;
8453 dgst_pos3 = 3;
8454 break;
8455
8456 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8457 salt_type = SALT_TYPE_EMBEDDED;
8458 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8459 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8460 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8461 dgst_size = DGST_SIZE_4_5;
8462 parse_func = truecrypt_parse_hash_2k;
8463 sort_by_digest = sort_by_digest_4_5;
8464 opti_type = OPTI_TYPE_ZERO_BYTE;
8465 dgst_pos0 = 0;
8466 dgst_pos1 = 1;
8467 dgst_pos2 = 2;
8468 dgst_pos3 = 3;
8469 break;
8470
8471 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8472 salt_type = SALT_TYPE_EMBEDDED;
8473 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8474 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8475 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8476 dgst_size = DGST_SIZE_4_5;
8477 parse_func = truecrypt_parse_hash_2k;
8478 sort_by_digest = sort_by_digest_4_5;
8479 opti_type = OPTI_TYPE_ZERO_BYTE;
8480 dgst_pos0 = 0;
8481 dgst_pos1 = 1;
8482 dgst_pos2 = 2;
8483 dgst_pos3 = 3;
8484 break;
8485
8486 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8487 salt_type = SALT_TYPE_EMBEDDED;
8488 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8489 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8490 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8491 dgst_size = DGST_SIZE_4_5;
8492 parse_func = truecrypt_parse_hash_2k;
8493 sort_by_digest = sort_by_digest_4_5;
8494 opti_type = OPTI_TYPE_ZERO_BYTE;
8495 dgst_pos0 = 0;
8496 dgst_pos1 = 1;
8497 dgst_pos2 = 2;
8498 dgst_pos3 = 3;
8499 break;
8500
8501 case 6221: hash_type = HASH_TYPE_SHA512;
8502 salt_type = SALT_TYPE_EMBEDDED;
8503 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8504 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8505 kern_type = KERN_TYPE_TCSHA512_XTS512;
8506 dgst_size = DGST_SIZE_8_8;
8507 parse_func = truecrypt_parse_hash_1k;
8508 sort_by_digest = sort_by_digest_8_8;
8509 opti_type = OPTI_TYPE_ZERO_BYTE;
8510 dgst_pos0 = 0;
8511 dgst_pos1 = 1;
8512 dgst_pos2 = 2;
8513 dgst_pos3 = 3;
8514 break;
8515
8516 case 6222: hash_type = HASH_TYPE_SHA512;
8517 salt_type = SALT_TYPE_EMBEDDED;
8518 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8519 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8520 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8521 dgst_size = DGST_SIZE_8_8;
8522 parse_func = truecrypt_parse_hash_1k;
8523 sort_by_digest = sort_by_digest_8_8;
8524 opti_type = OPTI_TYPE_ZERO_BYTE;
8525 dgst_pos0 = 0;
8526 dgst_pos1 = 1;
8527 dgst_pos2 = 2;
8528 dgst_pos3 = 3;
8529 break;
8530
8531 case 6223: hash_type = HASH_TYPE_SHA512;
8532 salt_type = SALT_TYPE_EMBEDDED;
8533 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8534 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8535 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8536 dgst_size = DGST_SIZE_8_8;
8537 parse_func = truecrypt_parse_hash_1k;
8538 sort_by_digest = sort_by_digest_8_8;
8539 opti_type = OPTI_TYPE_ZERO_BYTE;
8540 dgst_pos0 = 0;
8541 dgst_pos1 = 1;
8542 dgst_pos2 = 2;
8543 dgst_pos3 = 3;
8544 break;
8545
8546 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8547 salt_type = SALT_TYPE_EMBEDDED;
8548 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8549 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8550 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8551 dgst_size = DGST_SIZE_4_8;
8552 parse_func = truecrypt_parse_hash_1k;
8553 sort_by_digest = sort_by_digest_4_8;
8554 opti_type = OPTI_TYPE_ZERO_BYTE;
8555 dgst_pos0 = 0;
8556 dgst_pos1 = 1;
8557 dgst_pos2 = 2;
8558 dgst_pos3 = 3;
8559 break;
8560
8561 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8562 salt_type = SALT_TYPE_EMBEDDED;
8563 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8564 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8565 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8566 dgst_size = DGST_SIZE_4_8;
8567 parse_func = truecrypt_parse_hash_1k;
8568 sort_by_digest = sort_by_digest_4_8;
8569 opti_type = OPTI_TYPE_ZERO_BYTE;
8570 dgst_pos0 = 0;
8571 dgst_pos1 = 1;
8572 dgst_pos2 = 2;
8573 dgst_pos3 = 3;
8574 break;
8575
8576 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8577 salt_type = SALT_TYPE_EMBEDDED;
8578 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8579 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8580 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8581 dgst_size = DGST_SIZE_4_8;
8582 parse_func = truecrypt_parse_hash_1k;
8583 sort_by_digest = sort_by_digest_4_8;
8584 opti_type = OPTI_TYPE_ZERO_BYTE;
8585 dgst_pos0 = 0;
8586 dgst_pos1 = 1;
8587 dgst_pos2 = 2;
8588 dgst_pos3 = 3;
8589 break;
8590
8591 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8592 salt_type = SALT_TYPE_EMBEDDED;
8593 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8594 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8595 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8596 dgst_size = DGST_SIZE_4_5;
8597 parse_func = truecrypt_parse_hash_1k;
8598 sort_by_digest = sort_by_digest_4_5;
8599 opti_type = OPTI_TYPE_ZERO_BYTE;
8600 dgst_pos0 = 0;
8601 dgst_pos1 = 1;
8602 dgst_pos2 = 2;
8603 dgst_pos3 = 3;
8604 break;
8605
8606 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8607 salt_type = SALT_TYPE_EMBEDDED;
8608 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8609 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8610 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8611 dgst_size = DGST_SIZE_4_5;
8612 parse_func = truecrypt_parse_hash_1k;
8613 sort_by_digest = sort_by_digest_4_5;
8614 opti_type = OPTI_TYPE_ZERO_BYTE;
8615 dgst_pos0 = 0;
8616 dgst_pos1 = 1;
8617 dgst_pos2 = 2;
8618 dgst_pos3 = 3;
8619 break;
8620
8621 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8622 salt_type = SALT_TYPE_EMBEDDED;
8623 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8624 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8625 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8626 dgst_size = DGST_SIZE_4_5;
8627 parse_func = truecrypt_parse_hash_1k;
8628 sort_by_digest = sort_by_digest_4_5;
8629 opti_type = OPTI_TYPE_ZERO_BYTE;
8630 dgst_pos0 = 0;
8631 dgst_pos1 = 1;
8632 dgst_pos2 = 2;
8633 dgst_pos3 = 3;
8634 break;
8635
8636 case 6300: hash_type = HASH_TYPE_MD5;
8637 salt_type = SALT_TYPE_EMBEDDED;
8638 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8639 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8640 kern_type = KERN_TYPE_MD5AIX;
8641 dgst_size = DGST_SIZE_4_4;
8642 parse_func = md5aix_parse_hash;
8643 sort_by_digest = sort_by_digest_4_4;
8644 opti_type = OPTI_TYPE_ZERO_BYTE;
8645 dgst_pos0 = 0;
8646 dgst_pos1 = 1;
8647 dgst_pos2 = 2;
8648 dgst_pos3 = 3;
8649 break;
8650
8651 case 6400: hash_type = HASH_TYPE_SHA256;
8652 salt_type = SALT_TYPE_EMBEDDED;
8653 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8654 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8655 kern_type = KERN_TYPE_SHA256AIX;
8656 dgst_size = DGST_SIZE_4_8;
8657 parse_func = sha256aix_parse_hash;
8658 sort_by_digest = sort_by_digest_4_8;
8659 opti_type = OPTI_TYPE_ZERO_BYTE;
8660 dgst_pos0 = 0;
8661 dgst_pos1 = 1;
8662 dgst_pos2 = 2;
8663 dgst_pos3 = 3;
8664 break;
8665
8666 case 6500: hash_type = HASH_TYPE_SHA512;
8667 salt_type = SALT_TYPE_EMBEDDED;
8668 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8669 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8670 kern_type = KERN_TYPE_SHA512AIX;
8671 dgst_size = DGST_SIZE_8_8;
8672 parse_func = sha512aix_parse_hash;
8673 sort_by_digest = sort_by_digest_8_8;
8674 opti_type = OPTI_TYPE_ZERO_BYTE;
8675 dgst_pos0 = 0;
8676 dgst_pos1 = 1;
8677 dgst_pos2 = 2;
8678 dgst_pos3 = 3;
8679 break;
8680
8681 case 6600: hash_type = HASH_TYPE_AES;
8682 salt_type = SALT_TYPE_EMBEDDED;
8683 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8684 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8685 kern_type = KERN_TYPE_AGILEKEY;
8686 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8687 parse_func = agilekey_parse_hash;
8688 sort_by_digest = sort_by_digest_4_5;
8689 opti_type = OPTI_TYPE_ZERO_BYTE;
8690 dgst_pos0 = 0;
8691 dgst_pos1 = 1;
8692 dgst_pos2 = 2;
8693 dgst_pos3 = 3;
8694 break;
8695
8696 case 6700: hash_type = HASH_TYPE_SHA1;
8697 salt_type = SALT_TYPE_EMBEDDED;
8698 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8699 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8700 kern_type = KERN_TYPE_SHA1AIX;
8701 dgst_size = DGST_SIZE_4_5;
8702 parse_func = sha1aix_parse_hash;
8703 sort_by_digest = sort_by_digest_4_5;
8704 opti_type = OPTI_TYPE_ZERO_BYTE;
8705 dgst_pos0 = 0;
8706 dgst_pos1 = 1;
8707 dgst_pos2 = 2;
8708 dgst_pos3 = 3;
8709 break;
8710
8711 case 6800: hash_type = HASH_TYPE_AES;
8712 salt_type = SALT_TYPE_EMBEDDED;
8713 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8714 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8715 kern_type = KERN_TYPE_LASTPASS;
8716 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
8717 parse_func = lastpass_parse_hash;
8718 sort_by_digest = sort_by_digest_4_8;
8719 opti_type = OPTI_TYPE_ZERO_BYTE;
8720 dgst_pos0 = 0;
8721 dgst_pos1 = 1;
8722 dgst_pos2 = 2;
8723 dgst_pos3 = 3;
8724 break;
8725
8726 case 6900: hash_type = HASH_TYPE_GOST;
8727 salt_type = SALT_TYPE_NONE;
8728 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8729 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8730 kern_type = KERN_TYPE_GOST;
8731 dgst_size = DGST_SIZE_4_8;
8732 parse_func = gost_parse_hash;
8733 sort_by_digest = sort_by_digest_4_8;
8734 opti_type = OPTI_TYPE_ZERO_BYTE;
8735 dgst_pos0 = 0;
8736 dgst_pos1 = 1;
8737 dgst_pos2 = 2;
8738 dgst_pos3 = 3;
8739 break;
8740
8741 case 7100: hash_type = HASH_TYPE_SHA512;
8742 salt_type = SALT_TYPE_EMBEDDED;
8743 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8744 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8745 kern_type = KERN_TYPE_PBKDF2_SHA512;
8746 dgst_size = DGST_SIZE_8_16;
8747 parse_func = sha512osx_parse_hash;
8748 sort_by_digest = sort_by_digest_8_16;
8749 opti_type = OPTI_TYPE_ZERO_BYTE;
8750 dgst_pos0 = 0;
8751 dgst_pos1 = 1;
8752 dgst_pos2 = 2;
8753 dgst_pos3 = 3;
8754 break;
8755
8756 case 7200: hash_type = HASH_TYPE_SHA512;
8757 salt_type = SALT_TYPE_EMBEDDED;
8758 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8759 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8760 kern_type = KERN_TYPE_PBKDF2_SHA512;
8761 dgst_size = DGST_SIZE_8_16;
8762 parse_func = sha512grub_parse_hash;
8763 sort_by_digest = sort_by_digest_8_16;
8764 opti_type = OPTI_TYPE_ZERO_BYTE;
8765 dgst_pos0 = 0;
8766 dgst_pos1 = 1;
8767 dgst_pos2 = 2;
8768 dgst_pos3 = 3;
8769 break;
8770
8771 case 7300: hash_type = HASH_TYPE_SHA1;
8772 salt_type = SALT_TYPE_EMBEDDED;
8773 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8774 opts_type = OPTS_TYPE_PT_GENERATE_BE
8775 | OPTS_TYPE_ST_ADD80
8776 | OPTS_TYPE_ST_ADDBITS15;
8777 kern_type = KERN_TYPE_RAKP;
8778 dgst_size = DGST_SIZE_4_5;
8779 parse_func = rakp_parse_hash;
8780 sort_by_digest = sort_by_digest_4_5;
8781 opti_type = OPTI_TYPE_ZERO_BYTE
8782 | OPTI_TYPE_NOT_ITERATED;
8783 dgst_pos0 = 3;
8784 dgst_pos1 = 4;
8785 dgst_pos2 = 2;
8786 dgst_pos3 = 1;
8787 break;
8788
8789 case 7400: hash_type = HASH_TYPE_SHA256;
8790 salt_type = SALT_TYPE_EMBEDDED;
8791 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8792 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8793 kern_type = KERN_TYPE_SHA256CRYPT;
8794 dgst_size = DGST_SIZE_4_8;
8795 parse_func = sha256crypt_parse_hash;
8796 sort_by_digest = sort_by_digest_4_8;
8797 opti_type = OPTI_TYPE_ZERO_BYTE;
8798 dgst_pos0 = 0;
8799 dgst_pos1 = 1;
8800 dgst_pos2 = 2;
8801 dgst_pos3 = 3;
8802 break;
8803
8804 case 7500: hash_type = HASH_TYPE_KRB5PA;
8805 salt_type = SALT_TYPE_EMBEDDED;
8806 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8807 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8808 kern_type = KERN_TYPE_KRB5PA;
8809 dgst_size = DGST_SIZE_4_4;
8810 parse_func = krb5pa_parse_hash;
8811 sort_by_digest = sort_by_digest_4_4;
8812 opti_type = OPTI_TYPE_ZERO_BYTE
8813 | OPTI_TYPE_NOT_ITERATED;
8814 dgst_pos0 = 3;
8815 dgst_pos1 = 7;
8816 dgst_pos2 = 2;
8817 dgst_pos3 = 6;
8818 break;
8819
8820 case 7600: hash_type = HASH_TYPE_SHA1;
8821 salt_type = SALT_TYPE_INTERN;
8822 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8823 opts_type = OPTS_TYPE_PT_GENERATE_BE
8824 | OPTS_TYPE_PT_ADD80
8825 | OPTS_TYPE_PT_ADDBITS15;
8826 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
8827 dgst_size = DGST_SIZE_4_5;
8828 parse_func = redmine_parse_hash;
8829 sort_by_digest = sort_by_digest_4_5;
8830 opti_type = OPTI_TYPE_ZERO_BYTE
8831 | OPTI_TYPE_PRECOMPUTE_INIT
8832 | OPTI_TYPE_EARLY_SKIP
8833 | OPTI_TYPE_NOT_ITERATED
8834 | OPTI_TYPE_PREPENDED_SALT;
8835 dgst_pos0 = 3;
8836 dgst_pos1 = 4;
8837 dgst_pos2 = 2;
8838 dgst_pos3 = 1;
8839 break;
8840
8841 case 7700: hash_type = HASH_TYPE_SAPB;
8842 salt_type = SALT_TYPE_EMBEDDED;
8843 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8844 opts_type = OPTS_TYPE_PT_GENERATE_LE
8845 | OPTS_TYPE_PT_UPPER
8846 | OPTS_TYPE_ST_UPPER;
8847 kern_type = KERN_TYPE_SAPB;
8848 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8849 parse_func = sapb_parse_hash;
8850 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8851 opti_type = OPTI_TYPE_ZERO_BYTE
8852 | OPTI_TYPE_PRECOMPUTE_INIT
8853 | OPTI_TYPE_NOT_ITERATED;
8854 dgst_pos0 = 0;
8855 dgst_pos1 = 1;
8856 dgst_pos2 = 2;
8857 dgst_pos3 = 3;
8858 break;
8859
8860 case 7800: hash_type = HASH_TYPE_SAPG;
8861 salt_type = SALT_TYPE_EMBEDDED;
8862 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8863 opts_type = OPTS_TYPE_PT_GENERATE_BE
8864 | OPTS_TYPE_ST_ADD80
8865 | OPTS_TYPE_ST_UPPER;
8866 kern_type = KERN_TYPE_SAPG;
8867 dgst_size = DGST_SIZE_4_5;
8868 parse_func = sapg_parse_hash;
8869 sort_by_digest = sort_by_digest_4_5;
8870 opti_type = OPTI_TYPE_ZERO_BYTE
8871 | OPTI_TYPE_PRECOMPUTE_INIT
8872 | OPTI_TYPE_NOT_ITERATED;
8873 dgst_pos0 = 3;
8874 dgst_pos1 = 4;
8875 dgst_pos2 = 2;
8876 dgst_pos3 = 1;
8877 break;
8878
8879 case 7900: hash_type = HASH_TYPE_SHA512;
8880 salt_type = SALT_TYPE_EMBEDDED;
8881 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8882 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8883 kern_type = KERN_TYPE_DRUPAL7;
8884 dgst_size = DGST_SIZE_8_8;
8885 parse_func = drupal7_parse_hash;
8886 sort_by_digest = sort_by_digest_8_8;
8887 opti_type = OPTI_TYPE_ZERO_BYTE;
8888 dgst_pos0 = 0;
8889 dgst_pos1 = 1;
8890 dgst_pos2 = 2;
8891 dgst_pos3 = 3;
8892 break;
8893
8894 case 8000: hash_type = HASH_TYPE_SHA256;
8895 salt_type = SALT_TYPE_EMBEDDED;
8896 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8897 opts_type = OPTS_TYPE_PT_GENERATE_BE
8898 | OPTS_TYPE_PT_UNICODE
8899 | OPTS_TYPE_ST_ADD80
8900 | OPTS_TYPE_ST_HEX;
8901 kern_type = KERN_TYPE_SYBASEASE;
8902 dgst_size = DGST_SIZE_4_8;
8903 parse_func = sybasease_parse_hash;
8904 sort_by_digest = sort_by_digest_4_8;
8905 opti_type = OPTI_TYPE_ZERO_BYTE
8906 | OPTI_TYPE_PRECOMPUTE_INIT
8907 | OPTI_TYPE_EARLY_SKIP
8908 | OPTI_TYPE_NOT_ITERATED
8909 | OPTI_TYPE_RAW_HASH;
8910 dgst_pos0 = 3;
8911 dgst_pos1 = 7;
8912 dgst_pos2 = 2;
8913 dgst_pos3 = 6;
8914 break;
8915
8916 case 8100: hash_type = HASH_TYPE_SHA1;
8917 salt_type = SALT_TYPE_EMBEDDED;
8918 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8919 opts_type = OPTS_TYPE_PT_GENERATE_BE;
8920 kern_type = KERN_TYPE_NETSCALER;
8921 dgst_size = DGST_SIZE_4_5;
8922 parse_func = netscaler_parse_hash;
8923 sort_by_digest = sort_by_digest_4_5;
8924 opti_type = OPTI_TYPE_ZERO_BYTE
8925 | OPTI_TYPE_PRECOMPUTE_INIT
8926 | OPTI_TYPE_PRECOMPUTE_MERKLE
8927 | OPTI_TYPE_EARLY_SKIP
8928 | OPTI_TYPE_NOT_ITERATED
8929 | OPTI_TYPE_PREPENDED_SALT
8930 | OPTI_TYPE_RAW_HASH;
8931 dgst_pos0 = 3;
8932 dgst_pos1 = 4;
8933 dgst_pos2 = 2;
8934 dgst_pos3 = 1;
8935 break;
8936
8937 case 8200: hash_type = HASH_TYPE_SHA256;
8938 salt_type = SALT_TYPE_EMBEDDED;
8939 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8940 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8941 kern_type = KERN_TYPE_CLOUDKEY;
8942 dgst_size = DGST_SIZE_4_8;
8943 parse_func = cloudkey_parse_hash;
8944 sort_by_digest = sort_by_digest_4_8;
8945 opti_type = OPTI_TYPE_ZERO_BYTE;
8946 dgst_pos0 = 0;
8947 dgst_pos1 = 1;
8948 dgst_pos2 = 2;
8949 dgst_pos3 = 3;
8950 break;
8951
8952 case 8300: hash_type = HASH_TYPE_SHA1;
8953 salt_type = SALT_TYPE_EMBEDDED;
8954 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8955 opts_type = OPTS_TYPE_PT_GENERATE_LE
8956 | OPTS_TYPE_ST_HEX
8957 | OPTS_TYPE_ST_ADD80;
8958 kern_type = KERN_TYPE_NSEC3;
8959 dgst_size = DGST_SIZE_4_5;
8960 parse_func = nsec3_parse_hash;
8961 sort_by_digest = sort_by_digest_4_5;
8962 opti_type = OPTI_TYPE_ZERO_BYTE;
8963 dgst_pos0 = 3;
8964 dgst_pos1 = 4;
8965 dgst_pos2 = 2;
8966 dgst_pos3 = 1;
8967 break;
8968
8969 case 8400: hash_type = HASH_TYPE_SHA1;
8970 salt_type = SALT_TYPE_INTERN;
8971 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8972 opts_type = OPTS_TYPE_PT_GENERATE_BE
8973 | OPTS_TYPE_PT_ADD80
8974 | OPTS_TYPE_PT_ADDBITS15;
8975 kern_type = KERN_TYPE_WBB3;
8976 dgst_size = DGST_SIZE_4_5;
8977 parse_func = wbb3_parse_hash;
8978 sort_by_digest = sort_by_digest_4_5;
8979 opti_type = OPTI_TYPE_ZERO_BYTE
8980 | OPTI_TYPE_PRECOMPUTE_INIT
8981 | OPTI_TYPE_NOT_ITERATED;
8982 dgst_pos0 = 3;
8983 dgst_pos1 = 4;
8984 dgst_pos2 = 2;
8985 dgst_pos3 = 1;
8986 break;
8987
8988 case 8500: hash_type = HASH_TYPE_DESRACF;
8989 salt_type = SALT_TYPE_EMBEDDED;
8990 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8991 opts_type = OPTS_TYPE_PT_GENERATE_LE
8992 | OPTS_TYPE_ST_UPPER;
8993 kern_type = KERN_TYPE_RACF;
8994 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8995 parse_func = racf_parse_hash;
8996 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8997 opti_type = OPTI_TYPE_ZERO_BYTE
8998 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8999 dgst_pos0 = 0;
9000 dgst_pos1 = 1;
9001 dgst_pos2 = 2;
9002 dgst_pos3 = 3;
9003 break;
9004
9005 case 8600: hash_type = HASH_TYPE_LOTUS5;
9006 salt_type = SALT_TYPE_NONE;
9007 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9008 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9009 kern_type = KERN_TYPE_LOTUS5;
9010 dgst_size = DGST_SIZE_4_4;
9011 parse_func = lotus5_parse_hash;
9012 sort_by_digest = sort_by_digest_4_4;
9013 opti_type = OPTI_TYPE_EARLY_SKIP
9014 | OPTI_TYPE_NOT_ITERATED
9015 | OPTI_TYPE_NOT_SALTED
9016 | OPTI_TYPE_RAW_HASH;
9017 dgst_pos0 = 0;
9018 dgst_pos1 = 1;
9019 dgst_pos2 = 2;
9020 dgst_pos3 = 3;
9021 break;
9022
9023 case 8700: hash_type = HASH_TYPE_LOTUS6;
9024 salt_type = SALT_TYPE_EMBEDDED;
9025 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9026 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9027 kern_type = KERN_TYPE_LOTUS6;
9028 dgst_size = DGST_SIZE_4_4;
9029 parse_func = lotus6_parse_hash;
9030 sort_by_digest = sort_by_digest_4_4;
9031 opti_type = OPTI_TYPE_EARLY_SKIP
9032 | OPTI_TYPE_NOT_ITERATED
9033 | OPTI_TYPE_RAW_HASH;
9034 dgst_pos0 = 0;
9035 dgst_pos1 = 1;
9036 dgst_pos2 = 2;
9037 dgst_pos3 = 3;
9038 break;
9039
9040 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
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_ANDROIDFDE;
9045 dgst_size = DGST_SIZE_4_4;
9046 parse_func = androidfde_parse_hash;
9047 sort_by_digest = sort_by_digest_4_4;
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 8900: hash_type = HASH_TYPE_SCRYPT;
9056 salt_type = SALT_TYPE_EMBEDDED;
9057 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9058 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9059 kern_type = KERN_TYPE_SCRYPT;
9060 dgst_size = DGST_SIZE_4_8;
9061 parse_func = scrypt_parse_hash;
9062 sort_by_digest = sort_by_digest_4_8;
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 9000: hash_type = HASH_TYPE_SHA1;
9071 salt_type = SALT_TYPE_EMBEDDED;
9072 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9073 opts_type = OPTS_TYPE_PT_GENERATE_LE
9074 | OPTS_TYPE_ST_GENERATE_LE;
9075 kern_type = KERN_TYPE_PSAFE2;
9076 dgst_size = DGST_SIZE_4_5;
9077 parse_func = psafe2_parse_hash;
9078 sort_by_digest = sort_by_digest_4_5;
9079 opti_type = OPTI_TYPE_ZERO_BYTE;
9080 dgst_pos0 = 0;
9081 dgst_pos1 = 1;
9082 dgst_pos2 = 2;
9083 dgst_pos3 = 3;
9084 break;
9085
9086 case 9100: hash_type = HASH_TYPE_LOTUS8;
9087 salt_type = SALT_TYPE_EMBEDDED;
9088 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9089 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9090 kern_type = KERN_TYPE_LOTUS8;
9091 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9092 parse_func = lotus8_parse_hash;
9093 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9094 opti_type = OPTI_TYPE_ZERO_BYTE;
9095 dgst_pos0 = 0;
9096 dgst_pos1 = 1;
9097 dgst_pos2 = 2;
9098 dgst_pos3 = 3;
9099 break;
9100
9101 case 9200: hash_type = HASH_TYPE_SHA256;
9102 salt_type = SALT_TYPE_EMBEDDED;
9103 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9104 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9105 kern_type = KERN_TYPE_PBKDF2_SHA256;
9106 dgst_size = DGST_SIZE_4_32;
9107 parse_func = cisco8_parse_hash;
9108 sort_by_digest = sort_by_digest_4_32;
9109 opti_type = OPTI_TYPE_ZERO_BYTE;
9110 dgst_pos0 = 0;
9111 dgst_pos1 = 1;
9112 dgst_pos2 = 2;
9113 dgst_pos3 = 3;
9114 break;
9115
9116 case 9300: hash_type = HASH_TYPE_SCRYPT;
9117 salt_type = SALT_TYPE_EMBEDDED;
9118 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9119 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9120 kern_type = KERN_TYPE_SCRYPT;
9121 dgst_size = DGST_SIZE_4_8;
9122 parse_func = cisco9_parse_hash;
9123 sort_by_digest = sort_by_digest_4_8;
9124 opti_type = OPTI_TYPE_ZERO_BYTE;
9125 dgst_pos0 = 0;
9126 dgst_pos1 = 1;
9127 dgst_pos2 = 2;
9128 dgst_pos3 = 3;
9129 break;
9130
9131 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9132 salt_type = SALT_TYPE_EMBEDDED;
9133 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9134 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9135 kern_type = KERN_TYPE_OFFICE2007;
9136 dgst_size = DGST_SIZE_4_4;
9137 parse_func = office2007_parse_hash;
9138 sort_by_digest = sort_by_digest_4_4;
9139 opti_type = OPTI_TYPE_ZERO_BYTE;
9140 dgst_pos0 = 0;
9141 dgst_pos1 = 1;
9142 dgst_pos2 = 2;
9143 dgst_pos3 = 3;
9144 break;
9145
9146 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9147 salt_type = SALT_TYPE_EMBEDDED;
9148 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9149 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9150 kern_type = KERN_TYPE_OFFICE2010;
9151 dgst_size = DGST_SIZE_4_4;
9152 parse_func = office2010_parse_hash;
9153 sort_by_digest = sort_by_digest_4_4;
9154 opti_type = OPTI_TYPE_ZERO_BYTE;
9155 dgst_pos0 = 0;
9156 dgst_pos1 = 1;
9157 dgst_pos2 = 2;
9158 dgst_pos3 = 3;
9159 break;
9160
9161 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9162 salt_type = SALT_TYPE_EMBEDDED;
9163 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9164 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9165 kern_type = KERN_TYPE_OFFICE2013;
9166 dgst_size = DGST_SIZE_4_4;
9167 parse_func = office2013_parse_hash;
9168 sort_by_digest = sort_by_digest_4_4;
9169 opti_type = OPTI_TYPE_ZERO_BYTE;
9170 dgst_pos0 = 0;
9171 dgst_pos1 = 1;
9172 dgst_pos2 = 2;
9173 dgst_pos3 = 3;
9174 break;
9175
9176 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9177 salt_type = SALT_TYPE_EMBEDDED;
9178 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9179 opts_type = OPTS_TYPE_PT_GENERATE_LE
9180 | OPTS_TYPE_PT_ADD80
9181 | OPTS_TYPE_PT_UNICODE;
9182 kern_type = KERN_TYPE_OLDOFFICE01;
9183 dgst_size = DGST_SIZE_4_4;
9184 parse_func = oldoffice01_parse_hash;
9185 sort_by_digest = sort_by_digest_4_4;
9186 opti_type = OPTI_TYPE_ZERO_BYTE
9187 | OPTI_TYPE_PRECOMPUTE_INIT
9188 | OPTI_TYPE_NOT_ITERATED;
9189 dgst_pos0 = 0;
9190 dgst_pos1 = 1;
9191 dgst_pos2 = 2;
9192 dgst_pos3 = 3;
9193 break;
9194
9195 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9196 salt_type = SALT_TYPE_EMBEDDED;
9197 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9198 opts_type = OPTS_TYPE_PT_GENERATE_LE
9199 | OPTS_TYPE_PT_ADD80;
9200 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9201 dgst_size = DGST_SIZE_4_4;
9202 parse_func = oldoffice01cm1_parse_hash;
9203 sort_by_digest = sort_by_digest_4_4;
9204 opti_type = OPTI_TYPE_ZERO_BYTE
9205 | OPTI_TYPE_PRECOMPUTE_INIT
9206 | OPTI_TYPE_NOT_ITERATED;
9207 dgst_pos0 = 0;
9208 dgst_pos1 = 1;
9209 dgst_pos2 = 2;
9210 dgst_pos3 = 3;
9211 break;
9212
9213 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9214 salt_type = SALT_TYPE_EMBEDDED;
9215 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9216 opts_type = OPTS_TYPE_PT_GENERATE_LE
9217 | OPTS_TYPE_PT_ADD80
9218 | OPTS_TYPE_PT_UNICODE
9219 | OPTS_TYPE_PT_NEVERCRACK;
9220 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9221 dgst_size = DGST_SIZE_4_4;
9222 parse_func = oldoffice01cm2_parse_hash;
9223 sort_by_digest = sort_by_digest_4_4;
9224 opti_type = OPTI_TYPE_ZERO_BYTE
9225 | OPTI_TYPE_PRECOMPUTE_INIT
9226 | OPTI_TYPE_NOT_ITERATED;
9227 dgst_pos0 = 0;
9228 dgst_pos1 = 1;
9229 dgst_pos2 = 2;
9230 dgst_pos3 = 3;
9231 break;
9232
9233 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9234 salt_type = SALT_TYPE_EMBEDDED;
9235 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9236 opts_type = OPTS_TYPE_PT_GENERATE_BE
9237 | OPTS_TYPE_PT_ADD80
9238 | OPTS_TYPE_PT_UNICODE;
9239 kern_type = KERN_TYPE_OLDOFFICE34;
9240 dgst_size = DGST_SIZE_4_4;
9241 parse_func = oldoffice34_parse_hash;
9242 sort_by_digest = sort_by_digest_4_4;
9243 opti_type = OPTI_TYPE_ZERO_BYTE
9244 | OPTI_TYPE_PRECOMPUTE_INIT
9245 | OPTI_TYPE_NOT_ITERATED;
9246 dgst_pos0 = 0;
9247 dgst_pos1 = 1;
9248 dgst_pos2 = 2;
9249 dgst_pos3 = 3;
9250 break;
9251
9252 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9253 salt_type = SALT_TYPE_EMBEDDED;
9254 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9255 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9256 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9257 dgst_size = DGST_SIZE_4_4;
9258 parse_func = oldoffice34cm1_parse_hash;
9259 sort_by_digest = sort_by_digest_4_4;
9260 opti_type = OPTI_TYPE_ZERO_BYTE
9261 | OPTI_TYPE_PRECOMPUTE_INIT
9262 | OPTI_TYPE_NOT_ITERATED;
9263 dgst_pos0 = 0;
9264 dgst_pos1 = 1;
9265 dgst_pos2 = 2;
9266 dgst_pos3 = 3;
9267 break;
9268
9269 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9270 salt_type = SALT_TYPE_EMBEDDED;
9271 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9272 opts_type = OPTS_TYPE_PT_GENERATE_BE
9273 | OPTS_TYPE_PT_ADD80
9274 | OPTS_TYPE_PT_UNICODE
9275 | OPTS_TYPE_PT_NEVERCRACK;
9276 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9277 dgst_size = DGST_SIZE_4_4;
9278 parse_func = oldoffice34cm2_parse_hash;
9279 sort_by_digest = sort_by_digest_4_4;
9280 opti_type = OPTI_TYPE_ZERO_BYTE
9281 | OPTI_TYPE_PRECOMPUTE_INIT
9282 | OPTI_TYPE_NOT_ITERATED;
9283 dgst_pos0 = 0;
9284 dgst_pos1 = 1;
9285 dgst_pos2 = 2;
9286 dgst_pos3 = 3;
9287 break;
9288
9289 case 9900: hash_type = HASH_TYPE_MD5;
9290 salt_type = SALT_TYPE_NONE;
9291 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9292 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9293 kern_type = KERN_TYPE_RADMIN2;
9294 dgst_size = DGST_SIZE_4_4;
9295 parse_func = radmin2_parse_hash;
9296 sort_by_digest = sort_by_digest_4_4;
9297 opti_type = OPTI_TYPE_ZERO_BYTE
9298 | OPTI_TYPE_PRECOMPUTE_INIT
9299 | OPTI_TYPE_EARLY_SKIP
9300 | OPTI_TYPE_NOT_ITERATED
9301 | OPTI_TYPE_NOT_SALTED;
9302 dgst_pos0 = 0;
9303 dgst_pos1 = 3;
9304 dgst_pos2 = 2;
9305 dgst_pos3 = 1;
9306 break;
9307
9308 case 10000: hash_type = HASH_TYPE_SHA256;
9309 salt_type = SALT_TYPE_EMBEDDED;
9310 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9311 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9312 kern_type = KERN_TYPE_PBKDF2_SHA256;
9313 dgst_size = DGST_SIZE_4_32;
9314 parse_func = djangopbkdf2_parse_hash;
9315 sort_by_digest = sort_by_digest_4_32;
9316 opti_type = OPTI_TYPE_ZERO_BYTE;
9317 dgst_pos0 = 0;
9318 dgst_pos1 = 1;
9319 dgst_pos2 = 2;
9320 dgst_pos3 = 3;
9321 break;
9322
9323 case 10100: hash_type = HASH_TYPE_SIPHASH;
9324 salt_type = SALT_TYPE_EMBEDDED;
9325 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9326 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9327 kern_type = KERN_TYPE_SIPHASH;
9328 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9329 parse_func = siphash_parse_hash;
9330 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9331 opti_type = OPTI_TYPE_ZERO_BYTE
9332 | OPTI_TYPE_NOT_ITERATED
9333 | OPTI_TYPE_RAW_HASH;
9334 dgst_pos0 = 0;
9335 dgst_pos1 = 1;
9336 dgst_pos2 = 2;
9337 dgst_pos3 = 3;
9338 break;
9339
9340 case 10200: hash_type = HASH_TYPE_MD5;
9341 salt_type = SALT_TYPE_EMBEDDED;
9342 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9343 opts_type = OPTS_TYPE_PT_GENERATE_LE
9344 | OPTS_TYPE_ST_ADD80
9345 | OPTS_TYPE_ST_ADDBITS14;
9346 kern_type = KERN_TYPE_HMACMD5_PW;
9347 dgst_size = DGST_SIZE_4_4;
9348 parse_func = crammd5_parse_hash;
9349 sort_by_digest = sort_by_digest_4_4;
9350 opti_type = OPTI_TYPE_ZERO_BYTE
9351 | OPTI_TYPE_NOT_ITERATED;
9352 dgst_pos0 = 0;
9353 dgst_pos1 = 3;
9354 dgst_pos2 = 2;
9355 dgst_pos3 = 1;
9356 break;
9357
9358 case 10300: hash_type = HASH_TYPE_SHA1;
9359 salt_type = SALT_TYPE_EMBEDDED;
9360 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9361 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9362 kern_type = KERN_TYPE_SAPH_SHA1;
9363 dgst_size = DGST_SIZE_4_5;
9364 parse_func = saph_sha1_parse_hash;
9365 sort_by_digest = sort_by_digest_4_5;
9366 opti_type = OPTI_TYPE_ZERO_BYTE;
9367 dgst_pos0 = 0;
9368 dgst_pos1 = 1;
9369 dgst_pos2 = 2;
9370 dgst_pos3 = 3;
9371 break;
9372
9373 case 10400: hash_type = HASH_TYPE_PDFU16;
9374 salt_type = SALT_TYPE_EMBEDDED;
9375 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9376 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9377 kern_type = KERN_TYPE_PDF11;
9378 dgst_size = DGST_SIZE_4_4;
9379 parse_func = pdf11_parse_hash;
9380 sort_by_digest = sort_by_digest_4_4;
9381 opti_type = OPTI_TYPE_ZERO_BYTE
9382 | OPTI_TYPE_NOT_ITERATED;
9383 dgst_pos0 = 0;
9384 dgst_pos1 = 1;
9385 dgst_pos2 = 2;
9386 dgst_pos3 = 3;
9387 break;
9388
9389 case 10410: hash_type = HASH_TYPE_PDFU16;
9390 salt_type = SALT_TYPE_EMBEDDED;
9391 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9392 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9393 kern_type = KERN_TYPE_PDF11CM1;
9394 dgst_size = DGST_SIZE_4_4;
9395 parse_func = pdf11cm1_parse_hash;
9396 sort_by_digest = sort_by_digest_4_4;
9397 opti_type = OPTI_TYPE_ZERO_BYTE
9398 | OPTI_TYPE_NOT_ITERATED;
9399 dgst_pos0 = 0;
9400 dgst_pos1 = 1;
9401 dgst_pos2 = 2;
9402 dgst_pos3 = 3;
9403 break;
9404
9405 case 10420: hash_type = HASH_TYPE_PDFU16;
9406 salt_type = SALT_TYPE_EMBEDDED;
9407 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9408 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9409 kern_type = KERN_TYPE_PDF11CM2;
9410 dgst_size = DGST_SIZE_4_4;
9411 parse_func = pdf11cm2_parse_hash;
9412 sort_by_digest = sort_by_digest_4_4;
9413 opti_type = OPTI_TYPE_ZERO_BYTE
9414 | OPTI_TYPE_NOT_ITERATED;
9415 dgst_pos0 = 0;
9416 dgst_pos1 = 1;
9417 dgst_pos2 = 2;
9418 dgst_pos3 = 3;
9419 break;
9420
9421 case 10500: hash_type = HASH_TYPE_PDFU16;
9422 salt_type = SALT_TYPE_EMBEDDED;
9423 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9424 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9425 kern_type = KERN_TYPE_PDF14;
9426 dgst_size = DGST_SIZE_4_4;
9427 parse_func = pdf14_parse_hash;
9428 sort_by_digest = sort_by_digest_4_4;
9429 opti_type = OPTI_TYPE_ZERO_BYTE
9430 | OPTI_TYPE_NOT_ITERATED;
9431 dgst_pos0 = 0;
9432 dgst_pos1 = 1;
9433 dgst_pos2 = 2;
9434 dgst_pos3 = 3;
9435 break;
9436
9437 case 10600: hash_type = HASH_TYPE_SHA256;
9438 salt_type = SALT_TYPE_EMBEDDED;
9439 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9440 opts_type = OPTS_TYPE_PT_GENERATE_BE
9441 | OPTS_TYPE_ST_ADD80
9442 | OPTS_TYPE_ST_ADDBITS15
9443 | OPTS_TYPE_HASH_COPY;
9444 kern_type = KERN_TYPE_SHA256_PWSLT;
9445 dgst_size = DGST_SIZE_4_8;
9446 parse_func = pdf17l3_parse_hash;
9447 sort_by_digest = sort_by_digest_4_8;
9448 opti_type = OPTI_TYPE_ZERO_BYTE
9449 | OPTI_TYPE_PRECOMPUTE_INIT
9450 | OPTI_TYPE_PRECOMPUTE_MERKLE
9451 | OPTI_TYPE_EARLY_SKIP
9452 | OPTI_TYPE_NOT_ITERATED
9453 | OPTI_TYPE_APPENDED_SALT
9454 | OPTI_TYPE_RAW_HASH;
9455 dgst_pos0 = 3;
9456 dgst_pos1 = 7;
9457 dgst_pos2 = 2;
9458 dgst_pos3 = 6;
9459 break;
9460
9461 case 10700: hash_type = HASH_TYPE_PDFU32;
9462 salt_type = SALT_TYPE_EMBEDDED;
9463 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9464 opts_type = OPTS_TYPE_PT_GENERATE_LE
9465 | OPTS_TYPE_HASH_COPY;
9466 kern_type = KERN_TYPE_PDF17L8;
9467 dgst_size = DGST_SIZE_4_8;
9468 parse_func = pdf17l8_parse_hash;
9469 sort_by_digest = sort_by_digest_4_8;
9470 opti_type = OPTI_TYPE_ZERO_BYTE
9471 | OPTI_TYPE_NOT_ITERATED;
9472 dgst_pos0 = 0;
9473 dgst_pos1 = 1;
9474 dgst_pos2 = 2;
9475 dgst_pos3 = 3;
9476 break;
9477
9478 case 10800: hash_type = HASH_TYPE_SHA384;
9479 salt_type = SALT_TYPE_NONE;
9480 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9481 opts_type = OPTS_TYPE_PT_GENERATE_BE
9482 | OPTS_TYPE_PT_ADD80
9483 | OPTS_TYPE_PT_ADDBITS15;
9484 kern_type = KERN_TYPE_SHA384;
9485 dgst_size = DGST_SIZE_8_8;
9486 parse_func = sha384_parse_hash;
9487 sort_by_digest = sort_by_digest_8_8;
9488 opti_type = OPTI_TYPE_ZERO_BYTE
9489 | OPTI_TYPE_PRECOMPUTE_INIT
9490 | OPTI_TYPE_PRECOMPUTE_MERKLE
9491 | OPTI_TYPE_EARLY_SKIP
9492 | OPTI_TYPE_NOT_ITERATED
9493 | OPTI_TYPE_NOT_SALTED
9494 | OPTI_TYPE_RAW_HASH;
9495 dgst_pos0 = 6;
9496 dgst_pos1 = 7;
9497 dgst_pos2 = 4;
9498 dgst_pos3 = 5;
9499 break;
9500
9501 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9502 salt_type = SALT_TYPE_EMBEDDED;
9503 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9504 opts_type = OPTS_TYPE_PT_GENERATE_LE
9505 | OPTS_TYPE_ST_BASE64
9506 | OPTS_TYPE_HASH_COPY;
9507 kern_type = KERN_TYPE_PBKDF2_SHA256;
9508 dgst_size = DGST_SIZE_4_32;
9509 parse_func = pbkdf2_sha256_parse_hash;
9510 sort_by_digest = sort_by_digest_4_32;
9511 opti_type = OPTI_TYPE_ZERO_BYTE;
9512 dgst_pos0 = 0;
9513 dgst_pos1 = 1;
9514 dgst_pos2 = 2;
9515 dgst_pos3 = 3;
9516 break;
9517
9518 case 11000: hash_type = HASH_TYPE_MD5;
9519 salt_type = SALT_TYPE_INTERN;
9520 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9521 opts_type = OPTS_TYPE_PT_GENERATE_LE
9522 | OPTS_TYPE_PT_ADD80;
9523 kern_type = KERN_TYPE_PRESTASHOP;
9524 dgst_size = DGST_SIZE_4_4;
9525 parse_func = prestashop_parse_hash;
9526 sort_by_digest = sort_by_digest_4_4;
9527 opti_type = OPTI_TYPE_ZERO_BYTE
9528 | OPTI_TYPE_PRECOMPUTE_INIT
9529 | OPTI_TYPE_NOT_ITERATED
9530 | OPTI_TYPE_PREPENDED_SALT;
9531 dgst_pos0 = 0;
9532 dgst_pos1 = 3;
9533 dgst_pos2 = 2;
9534 dgst_pos3 = 1;
9535 break;
9536
9537 case 11100: hash_type = HASH_TYPE_MD5;
9538 salt_type = SALT_TYPE_EMBEDDED;
9539 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9540 opts_type = OPTS_TYPE_PT_GENERATE_LE
9541 | OPTS_TYPE_ST_ADD80;
9542 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9543 dgst_size = DGST_SIZE_4_4;
9544 parse_func = postgresql_auth_parse_hash;
9545 sort_by_digest = sort_by_digest_4_4;
9546 opti_type = OPTI_TYPE_ZERO_BYTE
9547 | OPTI_TYPE_PRECOMPUTE_INIT
9548 | OPTI_TYPE_PRECOMPUTE_MERKLE
9549 | OPTI_TYPE_EARLY_SKIP;
9550 dgst_pos0 = 0;
9551 dgst_pos1 = 3;
9552 dgst_pos2 = 2;
9553 dgst_pos3 = 1;
9554 break;
9555
9556 case 11200: hash_type = HASH_TYPE_SHA1;
9557 salt_type = SALT_TYPE_EMBEDDED;
9558 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9559 opts_type = OPTS_TYPE_PT_GENERATE_BE
9560 | OPTS_TYPE_PT_ADD80
9561 | OPTS_TYPE_ST_HEX;
9562 kern_type = KERN_TYPE_MYSQL_AUTH;
9563 dgst_size = DGST_SIZE_4_5;
9564 parse_func = mysql_auth_parse_hash;
9565 sort_by_digest = sort_by_digest_4_5;
9566 opti_type = OPTI_TYPE_ZERO_BYTE
9567 | OPTI_TYPE_EARLY_SKIP;
9568 dgst_pos0 = 3;
9569 dgst_pos1 = 4;
9570 dgst_pos2 = 2;
9571 dgst_pos3 = 1;
9572 break;
9573
9574 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9575 salt_type = SALT_TYPE_EMBEDDED;
9576 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9577 opts_type = OPTS_TYPE_PT_GENERATE_LE
9578 | OPTS_TYPE_ST_HEX
9579 | OPTS_TYPE_ST_ADD80;
9580 kern_type = KERN_TYPE_BITCOIN_WALLET;
9581 dgst_size = DGST_SIZE_4_4;
9582 parse_func = bitcoin_wallet_parse_hash;
9583 sort_by_digest = sort_by_digest_4_4;
9584 opti_type = OPTI_TYPE_ZERO_BYTE;
9585 dgst_pos0 = 0;
9586 dgst_pos1 = 1;
9587 dgst_pos2 = 2;
9588 dgst_pos3 = 3;
9589 break;
9590
9591 case 11400: hash_type = HASH_TYPE_MD5;
9592 salt_type = SALT_TYPE_EMBEDDED;
9593 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9594 opts_type = OPTS_TYPE_PT_GENERATE_LE
9595 | OPTS_TYPE_PT_ADD80
9596 | OPTS_TYPE_HASH_COPY;
9597 kern_type = KERN_TYPE_SIP_AUTH;
9598 dgst_size = DGST_SIZE_4_4;
9599 parse_func = sip_auth_parse_hash;
9600 sort_by_digest = sort_by_digest_4_4;
9601 opti_type = OPTI_TYPE_ZERO_BYTE;
9602 dgst_pos0 = 0;
9603 dgst_pos1 = 3;
9604 dgst_pos2 = 2;
9605 dgst_pos3 = 1;
9606 break;
9607
9608 case 11500: hash_type = HASH_TYPE_CRC32;
9609 salt_type = SALT_TYPE_INTERN;
9610 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9611 opts_type = OPTS_TYPE_PT_GENERATE_LE
9612 | OPTS_TYPE_ST_GENERATE_LE
9613 | OPTS_TYPE_ST_HEX;
9614 kern_type = KERN_TYPE_CRC32;
9615 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9616 parse_func = crc32_parse_hash;
9617 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9618 opti_type = OPTI_TYPE_ZERO_BYTE;
9619 dgst_pos0 = 0;
9620 dgst_pos1 = 1;
9621 dgst_pos2 = 2;
9622 dgst_pos3 = 3;
9623 break;
9624
9625 case 11600: hash_type = HASH_TYPE_AES;
9626 salt_type = SALT_TYPE_EMBEDDED;
9627 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9628 opts_type = OPTS_TYPE_PT_GENERATE_LE
9629 | OPTS_TYPE_PT_NEVERCRACK;
9630 kern_type = KERN_TYPE_SEVEN_ZIP;
9631 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9632 parse_func = seven_zip_parse_hash;
9633 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9634 opti_type = OPTI_TYPE_ZERO_BYTE;
9635 dgst_pos0 = 0;
9636 dgst_pos1 = 1;
9637 dgst_pos2 = 2;
9638 dgst_pos3 = 3;
9639 break;
9640
9641 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9642 salt_type = SALT_TYPE_NONE;
9643 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9644 opts_type = OPTS_TYPE_PT_GENERATE_LE
9645 | OPTS_TYPE_PT_ADD01;
9646 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9647 dgst_size = DGST_SIZE_4_8;
9648 parse_func = gost2012sbog_256_parse_hash;
9649 sort_by_digest = sort_by_digest_4_8;
9650 opti_type = OPTI_TYPE_ZERO_BYTE;
9651 dgst_pos0 = 0;
9652 dgst_pos1 = 1;
9653 dgst_pos2 = 2;
9654 dgst_pos3 = 3;
9655 break;
9656
9657 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9658 salt_type = SALT_TYPE_NONE;
9659 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9660 opts_type = OPTS_TYPE_PT_GENERATE_LE
9661 | OPTS_TYPE_PT_ADD01;
9662 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9663 dgst_size = DGST_SIZE_4_16;
9664 parse_func = gost2012sbog_512_parse_hash;
9665 sort_by_digest = sort_by_digest_4_16;
9666 opti_type = OPTI_TYPE_ZERO_BYTE;
9667 dgst_pos0 = 0;
9668 dgst_pos1 = 1;
9669 dgst_pos2 = 2;
9670 dgst_pos3 = 3;
9671 break;
9672
9673 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9674 salt_type = SALT_TYPE_EMBEDDED;
9675 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9676 opts_type = OPTS_TYPE_PT_GENERATE_LE
9677 | OPTS_TYPE_ST_BASE64
9678 | OPTS_TYPE_HASH_COPY;
9679 kern_type = KERN_TYPE_PBKDF2_MD5;
9680 dgst_size = DGST_SIZE_4_32;
9681 parse_func = pbkdf2_md5_parse_hash;
9682 sort_by_digest = sort_by_digest_4_32;
9683 opti_type = OPTI_TYPE_ZERO_BYTE;
9684 dgst_pos0 = 0;
9685 dgst_pos1 = 1;
9686 dgst_pos2 = 2;
9687 dgst_pos3 = 3;
9688 break;
9689
9690 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
9691 salt_type = SALT_TYPE_EMBEDDED;
9692 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9693 opts_type = OPTS_TYPE_PT_GENERATE_LE
9694 | OPTS_TYPE_ST_BASE64
9695 | OPTS_TYPE_HASH_COPY;
9696 kern_type = KERN_TYPE_PBKDF2_SHA1;
9697 dgst_size = DGST_SIZE_4_32;
9698 parse_func = pbkdf2_sha1_parse_hash;
9699 sort_by_digest = sort_by_digest_4_32;
9700 opti_type = OPTI_TYPE_ZERO_BYTE;
9701 dgst_pos0 = 0;
9702 dgst_pos1 = 1;
9703 dgst_pos2 = 2;
9704 dgst_pos3 = 3;
9705 break;
9706
9707 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
9708 salt_type = SALT_TYPE_EMBEDDED;
9709 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9710 opts_type = OPTS_TYPE_PT_GENERATE_LE
9711 | OPTS_TYPE_ST_BASE64
9712 | OPTS_TYPE_HASH_COPY;
9713 kern_type = KERN_TYPE_PBKDF2_SHA512;
9714 dgst_size = DGST_SIZE_8_16;
9715 parse_func = pbkdf2_sha512_parse_hash;
9716 sort_by_digest = sort_by_digest_8_16;
9717 opti_type = OPTI_TYPE_ZERO_BYTE;
9718 dgst_pos0 = 0;
9719 dgst_pos1 = 1;
9720 dgst_pos2 = 2;
9721 dgst_pos3 = 3;
9722 break;
9723
9724 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
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_ECRYPTFS;
9729 dgst_size = DGST_SIZE_8_8;
9730 parse_func = ecryptfs_parse_hash;
9731 sort_by_digest = sort_by_digest_8_8;
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 12300: hash_type = HASH_TYPE_ORACLET;
9740 salt_type = SALT_TYPE_EMBEDDED;
9741 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9742 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9743 kern_type = KERN_TYPE_ORACLET;
9744 dgst_size = DGST_SIZE_8_16;
9745 parse_func = oraclet_parse_hash;
9746 sort_by_digest = sort_by_digest_8_16;
9747 opti_type = OPTI_TYPE_ZERO_BYTE;
9748 dgst_pos0 = 0;
9749 dgst_pos1 = 1;
9750 dgst_pos2 = 2;
9751 dgst_pos3 = 3;
9752 break;
9753
9754 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
9755 salt_type = SALT_TYPE_EMBEDDED;
9756 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9757 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9758 kern_type = KERN_TYPE_BSDICRYPT;
9759 dgst_size = DGST_SIZE_4_4;
9760 parse_func = bsdicrypt_parse_hash;
9761 sort_by_digest = sort_by_digest_4_4;
9762 opti_type = OPTI_TYPE_ZERO_BYTE
9763 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9764 dgst_pos0 = 0;
9765 dgst_pos1 = 1;
9766 dgst_pos2 = 2;
9767 dgst_pos3 = 3;
9768 break;
9769
9770 case 12500: hash_type = HASH_TYPE_RAR3HP;
9771 salt_type = SALT_TYPE_EMBEDDED;
9772 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9773 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9774 kern_type = KERN_TYPE_RAR3;
9775 dgst_size = DGST_SIZE_4_4;
9776 parse_func = rar3hp_parse_hash;
9777 sort_by_digest = sort_by_digest_4_4;
9778 opti_type = OPTI_TYPE_ZERO_BYTE;
9779 dgst_pos0 = 0;
9780 dgst_pos1 = 1;
9781 dgst_pos2 = 2;
9782 dgst_pos3 = 3;
9783 break;
9784
9785 case 12600: hash_type = HASH_TYPE_SHA256;
9786 salt_type = SALT_TYPE_INTERN;
9787 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9788 opts_type = OPTS_TYPE_PT_GENERATE_BE
9789 | OPTS_TYPE_PT_ADD80;
9790 kern_type = KERN_TYPE_CF10;
9791 dgst_size = DGST_SIZE_4_8;
9792 parse_func = cf10_parse_hash;
9793 sort_by_digest = sort_by_digest_4_8;
9794 opti_type = OPTI_TYPE_ZERO_BYTE
9795 | OPTI_TYPE_PRECOMPUTE_INIT
9796 | OPTI_TYPE_EARLY_SKIP
9797 | OPTI_TYPE_NOT_ITERATED;
9798 dgst_pos0 = 3;
9799 dgst_pos1 = 7;
9800 dgst_pos2 = 2;
9801 dgst_pos3 = 6;
9802 break;
9803
9804 case 12700: hash_type = HASH_TYPE_AES;
9805 salt_type = SALT_TYPE_EMBEDDED;
9806 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9807 opts_type = OPTS_TYPE_PT_GENERATE_LE
9808 | OPTS_TYPE_HASH_COPY;
9809 kern_type = KERN_TYPE_MYWALLET;
9810 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9811 parse_func = mywallet_parse_hash;
9812 sort_by_digest = sort_by_digest_4_5;
9813 opti_type = OPTI_TYPE_ZERO_BYTE;
9814 dgst_pos0 = 0;
9815 dgst_pos1 = 1;
9816 dgst_pos2 = 2;
9817 dgst_pos3 = 3;
9818 break;
9819
9820 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
9821 salt_type = SALT_TYPE_EMBEDDED;
9822 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9823 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9824 kern_type = KERN_TYPE_MS_DRSR;
9825 dgst_size = DGST_SIZE_4_8;
9826 parse_func = ms_drsr_parse_hash;
9827 sort_by_digest = sort_by_digest_4_8;
9828 opti_type = OPTI_TYPE_ZERO_BYTE;
9829 dgst_pos0 = 0;
9830 dgst_pos1 = 1;
9831 dgst_pos2 = 2;
9832 dgst_pos3 = 3;
9833 break;
9834
9835 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9836 salt_type = SALT_TYPE_EMBEDDED;
9837 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9838 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9839 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
9840 dgst_size = DGST_SIZE_4_8;
9841 parse_func = androidfde_samsung_parse_hash;
9842 sort_by_digest = sort_by_digest_4_8;
9843 opti_type = OPTI_TYPE_ZERO_BYTE;
9844 dgst_pos0 = 0;
9845 dgst_pos1 = 1;
9846 dgst_pos2 = 2;
9847 dgst_pos3 = 3;
9848 break;
9849
9850 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
9851 salt_type = SALT_TYPE_EMBEDDED;
9852 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9853 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9854 kern_type = KERN_TYPE_RAR5;
9855 dgst_size = DGST_SIZE_4_4;
9856 parse_func = rar5_parse_hash;
9857 sort_by_digest = sort_by_digest_4_4;
9858 opti_type = OPTI_TYPE_ZERO_BYTE;
9859 dgst_pos0 = 0;
9860 dgst_pos1 = 1;
9861 dgst_pos2 = 2;
9862 dgst_pos3 = 3;
9863 break;
9864
9865 default: usage_mini_print (PROGNAME); return (-1);
9866 }
9867
9868 /**
9869 * transpose
9870 */
9871
9872 data.parse_func = parse_func;
9873
9874 /**
9875 * misc stuff
9876 */
9877
9878 if (hex_salt)
9879 {
9880 if (salt_type == SALT_TYPE_INTERN)
9881 {
9882 opts_type |= OPTS_TYPE_ST_HEX;
9883 }
9884 else
9885 {
9886 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
9887
9888 return (-1);
9889 }
9890 }
9891
9892 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
9893 | (salt_type == SALT_TYPE_EXTERN)
9894 | (salt_type == SALT_TYPE_EMBEDDED)
9895 | (salt_type == SALT_TYPE_VIRTUAL));
9896
9897 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
9898
9899 data.hash_type = hash_type;
9900 data.attack_mode = attack_mode;
9901 data.attack_kern = attack_kern;
9902 data.attack_exec = attack_exec;
9903 data.kern_type = kern_type;
9904 data.opts_type = opts_type;
9905 data.dgst_size = dgst_size;
9906 data.salt_type = salt_type;
9907 data.isSalted = isSalted;
9908 data.sort_by_digest = sort_by_digest;
9909 data.dgst_pos0 = dgst_pos0;
9910 data.dgst_pos1 = dgst_pos1;
9911 data.dgst_pos2 = dgst_pos2;
9912 data.dgst_pos3 = dgst_pos3;
9913
9914 esalt_size = 0;
9915
9916 switch (hash_mode)
9917 {
9918 case 2500: esalt_size = sizeof (wpa_t); break;
9919 case 5300: esalt_size = sizeof (ikepsk_t); break;
9920 case 5400: esalt_size = sizeof (ikepsk_t); break;
9921 case 5500: esalt_size = sizeof (netntlm_t); break;
9922 case 5600: esalt_size = sizeof (netntlm_t); break;
9923 case 6211:
9924 case 6212:
9925 case 6213:
9926 case 6221:
9927 case 6222:
9928 case 6223:
9929 case 6231:
9930 case 6232:
9931 case 6233:
9932 case 6241:
9933 case 6242:
9934 case 6243: esalt_size = sizeof (tc_t); break;
9935 case 6600: esalt_size = sizeof (agilekey_t); break;
9936 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
9937 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
9938 case 7300: esalt_size = sizeof (rakp_t); break;
9939 case 7500: esalt_size = sizeof (krb5pa_t); break;
9940 case 8200: esalt_size = sizeof (cloudkey_t); break;
9941 case 8800: esalt_size = sizeof (androidfde_t); break;
9942 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
9943 case 9400: esalt_size = sizeof (office2007_t); break;
9944 case 9500: esalt_size = sizeof (office2010_t); break;
9945 case 9600: esalt_size = sizeof (office2013_t); break;
9946 case 9700: esalt_size = sizeof (oldoffice01_t); break;
9947 case 9710: esalt_size = sizeof (oldoffice01_t); break;
9948 case 9720: esalt_size = sizeof (oldoffice01_t); break;
9949 case 9800: esalt_size = sizeof (oldoffice34_t); break;
9950 case 9810: esalt_size = sizeof (oldoffice34_t); break;
9951 case 9820: esalt_size = sizeof (oldoffice34_t); break;
9952 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
9953 case 10200: esalt_size = sizeof (cram_md5_t); break;
9954 case 10400: esalt_size = sizeof (pdf_t); break;
9955 case 10410: esalt_size = sizeof (pdf_t); break;
9956 case 10420: esalt_size = sizeof (pdf_t); break;
9957 case 10500: esalt_size = sizeof (pdf_t); break;
9958 case 10600: esalt_size = sizeof (pdf_t); break;
9959 case 10700: esalt_size = sizeof (pdf_t); break;
9960 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
9961 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
9962 case 11400: esalt_size = sizeof (sip_t); break;
9963 case 11600: esalt_size = sizeof (seven_zip_t); break;
9964 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
9965 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
9966 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
9967 case 13000: esalt_size = sizeof (rar5_t); break;
9968 }
9969
9970 data.esalt_size = esalt_size;
9971
9972 /**
9973 * choose dictionary parser
9974 */
9975
9976 if (hash_type == HASH_TYPE_LM)
9977 {
9978 get_next_word_func = get_next_word_lm;
9979 }
9980 else if (opts_type & OPTS_TYPE_PT_UPPER)
9981 {
9982 get_next_word_func = get_next_word_uc;
9983 }
9984 else
9985 {
9986 get_next_word_func = get_next_word_std;
9987 }
9988
9989 /**
9990 * dictstat
9991 */
9992
9993 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
9994
9995 #ifdef _POSIX
9996 size_t dictstat_nmemb = 0;
9997 #endif
9998
9999 #ifdef _WIN
10000 uint dictstat_nmemb = 0;
10001 #endif
10002
10003 char dictstat[256];
10004
10005 FILE *dictstat_fp = NULL;
10006
10007 if (keyspace == 0)
10008 {
10009 memset (dictstat, 0, sizeof (dictstat));
10010
10011 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
10012
10013 dictstat_fp = fopen (dictstat, "rb");
10014
10015 if (dictstat_fp)
10016 {
10017 #ifdef _POSIX
10018 struct stat tmpstat;
10019
10020 fstat (fileno (dictstat_fp), &tmpstat);
10021 #endif
10022
10023 #ifdef _WIN
10024 struct stat64 tmpstat;
10025
10026 _fstat64 (fileno (dictstat_fp), &tmpstat);
10027 #endif
10028
10029 if (tmpstat.st_mtime < COMPTIME)
10030 {
10031 /* with v0.15 the format changed so we have to ensure user is using a good version
10032 since there is no version-header in the dictstat file */
10033
10034 fclose (dictstat_fp);
10035
10036 unlink (dictstat);
10037 }
10038 else
10039 {
10040 while (!feof (dictstat_fp))
10041 {
10042 dictstat_t d;
10043
10044 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10045
10046 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10047
10048 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10049 {
10050 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10051
10052 return -1;
10053 }
10054 }
10055
10056 fclose (dictstat_fp);
10057 }
10058 }
10059 }
10060
10061 /**
10062 * potfile
10063 */
10064
10065 char potfile[256];
10066
10067 memset (potfile, 0, sizeof (potfile));
10068
10069 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
10070
10071 data.pot_fp = NULL;
10072
10073 FILE *out_fp = NULL;
10074 FILE *pot_fp = NULL;
10075
10076 if (show == 1 || left == 1)
10077 {
10078 pot_fp = fopen (potfile, "rb");
10079
10080 if (pot_fp == NULL)
10081 {
10082 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10083
10084 return (-1);
10085 }
10086
10087 if (outfile != NULL)
10088 {
10089 if ((out_fp = fopen (outfile, "ab")) == NULL)
10090 {
10091 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10092
10093 fclose (pot_fp);
10094
10095 return (-1);
10096 }
10097 }
10098 else
10099 {
10100 out_fp = stdout;
10101 }
10102 }
10103 else
10104 {
10105 if (potfile_disable == 0)
10106 {
10107 pot_fp = fopen (potfile, "ab");
10108
10109 if (pot_fp == NULL)
10110 {
10111 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10112
10113 return (-1);
10114 }
10115
10116 data.pot_fp = pot_fp;
10117 }
10118 }
10119
10120 pot_t *pot = NULL;
10121
10122 uint pot_cnt = 0;
10123 uint pot_avail = 0;
10124
10125 if (show == 1 || left == 1)
10126 {
10127 SUPPRESS_OUTPUT = 1;
10128
10129 pot_avail = count_lines (pot_fp);
10130
10131 rewind (pot_fp);
10132
10133 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10134
10135 uint pot_hashes_avail = 0;
10136
10137 uint line_num = 0;
10138
10139 while (!feof (pot_fp))
10140 {
10141 line_num++;
10142
10143 char line_buf[BUFSIZ];
10144
10145 int line_len = fgetl (pot_fp, line_buf);
10146
10147 if (line_len == 0) continue;
10148
10149 char *plain_buf = line_buf + line_len;
10150
10151 pot_t *pot_ptr = &pot[pot_cnt];
10152
10153 hash_t *hashes_buf = &pot_ptr->hash;
10154
10155 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10156 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10157
10158 if (pot_cnt == pot_hashes_avail)
10159 {
10160 uint pos = 0;
10161
10162 for (pos = 0; pos < INCR_POT; pos++)
10163 {
10164 if ((pot_cnt + pos) >= pot_avail) break;
10165
10166 pot_t *tmp_pot = &pot[pot_cnt + pos];
10167
10168 hash_t *tmp_hash = &tmp_pot->hash;
10169
10170 tmp_hash->digest = mymalloc (dgst_size);
10171
10172 if (isSalted)
10173 {
10174 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10175 }
10176
10177 if (esalt_size)
10178 {
10179 tmp_hash->esalt = mymalloc (esalt_size);
10180 }
10181
10182 pot_hashes_avail++;
10183 }
10184 }
10185
10186 int plain_len = 0;
10187
10188 int parser_status;
10189
10190 int iter = MAX_CUT_TRIES;
10191
10192 do
10193 {
10194 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10195 {
10196 if (line_buf[i] == ':')
10197 {
10198 line_len--;
10199
10200 break;
10201 }
10202 }
10203
10204 if (data.hash_mode != 2500)
10205 {
10206 parser_status = parse_func (line_buf, line_len, hashes_buf);
10207 }
10208 else
10209 {
10210 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10211
10212 if (line_len > max_salt_size)
10213 {
10214 parser_status = PARSER_GLOBAL_LENGTH;
10215 }
10216 else
10217 {
10218 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10219
10220 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10221
10222 hashes_buf->salt->salt_len = line_len;
10223
10224 parser_status = PARSER_OK;
10225 }
10226 }
10227
10228 // if NOT parsed without error, we add the ":" to the plain
10229
10230 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10231 {
10232 plain_len++;
10233 plain_buf--;
10234 }
10235
10236 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10237
10238 if (parser_status < PARSER_GLOBAL_ZERO)
10239 {
10240 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10241
10242 continue;
10243 }
10244
10245 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10246
10247 pot_ptr->plain_len = plain_len;
10248
10249 pot_cnt++;
10250 }
10251
10252 fclose (pot_fp);
10253
10254 SUPPRESS_OUTPUT = 0;
10255
10256 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10257 }
10258
10259 /**
10260 * kernel accel and loops auto adjustment
10261 */
10262
10263 if (kernel_accel_chgd == 0) kernel_accel = set_kernel_accel (hash_mode);
10264 if (kernel_loops_chgd == 0) kernel_loops = set_kernel_loops (hash_mode);
10265
10266 if (workload_profile == 1)
10267 {
10268 kernel_loops /= 8;
10269 kernel_accel /= 4;
10270
10271 if (kernel_loops == 0) kernel_loops = 8;
10272 if (kernel_accel == 0) kernel_accel = 2;
10273 }
10274 else if (workload_profile == 3)
10275 {
10276 kernel_loops *= 8;
10277 kernel_accel *= 4;
10278
10279 if (kernel_loops > 1024) kernel_loops = 1024;
10280 if (kernel_accel > 256) kernel_accel = 256; // causes memory problems otherwise
10281 }
10282
10283 // those hashes *must* run at a specific kernel_loops count because of some optimization inside the kernel
10284
10285 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
10286 {
10287 kernel_loops = 1024;
10288 }
10289
10290 if (hash_mode == 12500)
10291 {
10292 kernel_loops = ROUNDS_RAR3 / 16;
10293 }
10294
10295 data.kernel_accel = kernel_accel;
10296 data.kernel_loops = kernel_loops;
10297
10298 /**
10299 * word len
10300 */
10301
10302 uint pw_min = PW_MIN;
10303 uint pw_max = PW_MAX;
10304
10305 switch (hash_mode)
10306 {
10307 case 400: if (pw_max > 40) pw_max = 40;
10308 break;
10309 case 500: if (pw_max > 16) pw_max = 16;
10310 break;
10311 case 1500: if (pw_max > 8) pw_max = 8;
10312 break;
10313 case 1600: if (pw_max > 16) pw_max = 16;
10314 break;
10315 case 1800: if (pw_max > 16) pw_max = 16;
10316 break;
10317 case 2100: if (pw_max > 16) pw_max = 16;
10318 break;
10319 case 2500: if (pw_min < 8) pw_min = 8;
10320 break;
10321 case 3000: if (pw_max > 7) pw_max = 7;
10322 break;
10323 case 5200: if (pw_max > 24) pw_max = 24;
10324 break;
10325 case 5800: if (pw_max > 16) pw_max = 16;
10326 break;
10327 case 6300: if (pw_max > 16) pw_max = 16;
10328 break;
10329 case 7400: if (pw_max > 16) pw_max = 16;
10330 break;
10331 case 7900: if (pw_max > 48) pw_max = 48;
10332 break;
10333 case 8500: if (pw_max > 8) pw_max = 8;
10334 break;
10335 case 8600: if (pw_max > 16) pw_max = 16;
10336 break;
10337 case 9710: pw_min = 5;
10338 pw_max = 5;
10339 break;
10340 case 9810: pw_min = 5;
10341 pw_max = 5;
10342 break;
10343 case 10410: pw_min = 5;
10344 pw_max = 5;
10345 break;
10346 case 10300: if (pw_max < 3) pw_min = 3;
10347 if (pw_max > 40) pw_max = 40;
10348 break;
10349 case 10500: if (pw_max < 3) pw_min = 3;
10350 if (pw_max > 40) pw_max = 40;
10351 break;
10352 case 10700: if (pw_max > 16) pw_max = 16;
10353 break;
10354 case 11300: if (pw_max > 40) pw_max = 40;
10355 break;
10356 case 12500: if (pw_max > 20) pw_max = 20;
10357 break;
10358 case 12800: if (pw_max > 24) pw_max = 24;
10359 break;
10360 }
10361
10362 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10363 {
10364 switch (attack_kern)
10365 {
10366 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10367 break;
10368 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10369 break;
10370 }
10371 }
10372
10373 /**
10374 * charsets : keep them together for more easy maintainnce
10375 */
10376
10377 cs_t mp_sys[6];
10378 cs_t mp_usr[4];
10379
10380 memset (mp_sys, 0, sizeof (mp_sys));
10381 memset (mp_usr, 0, sizeof (mp_usr));
10382
10383 mp_setup_sys (mp_sys);
10384
10385 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10386 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10387 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10388 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10389
10390 /**
10391 * load hashes, part I: find input mode, count hashes
10392 */
10393
10394 uint hashlist_mode = 0;
10395 uint hashlist_format = HLFMT_HASHCAT;
10396
10397 uint hashes_avail = 0;
10398
10399 if (benchmark == 0)
10400 {
10401 struct stat f;
10402
10403 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10404
10405 if ((hash_mode == 2500) ||
10406 (hash_mode == 5200) ||
10407 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10408 (hash_mode == 9000))
10409 {
10410 hashlist_mode = HL_MODE_ARG;
10411
10412 char *hashfile = myargv[optind];
10413
10414 data.hashfile = hashfile;
10415
10416 logfile_top_var_string ("target", hashfile);
10417 }
10418
10419 if (hashlist_mode == HL_MODE_ARG)
10420 {
10421 if (hash_mode == 2500)
10422 {
10423 struct stat st;
10424
10425 if (stat (data.hashfile, &st) == -1)
10426 {
10427 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10428
10429 return (-1);
10430 }
10431
10432 hashes_avail = st.st_size / sizeof (hccap_t);
10433 }
10434 else
10435 {
10436 hashes_avail = 1;
10437 }
10438 }
10439 else if (hashlist_mode == HL_MODE_FILE)
10440 {
10441 char *hashfile = myargv[optind];
10442
10443 data.hashfile = hashfile;
10444
10445 logfile_top_var_string ("target", hashfile);
10446
10447 FILE *fp = NULL;
10448
10449 if ((fp = fopen (hashfile, "rb")) == NULL)
10450 {
10451 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10452
10453 return (-1);
10454 }
10455
10456 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10457
10458 hashes_avail = count_lines (fp);
10459
10460 rewind (fp);
10461
10462 if (hashes_avail == 0)
10463 {
10464 log_error ("ERROR: hashfile is empty or corrupt");
10465
10466 fclose (fp);
10467
10468 return (-1);
10469 }
10470
10471 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10472
10473 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10474 {
10475 log_error ("ERROR: remove not supported in native hashfile-format mode");
10476
10477 fclose (fp);
10478
10479 return (-1);
10480 }
10481
10482 fclose (fp);
10483 }
10484 }
10485 else
10486 {
10487 hashlist_mode = HL_MODE_ARG;
10488
10489 hashes_avail = 1;
10490 }
10491
10492 if (hash_mode == 3000) hashes_avail *= 2;
10493
10494 data.hashlist_mode = hashlist_mode;
10495 data.hashlist_format = hashlist_format;
10496
10497 logfile_top_uint (hashlist_mode);
10498 logfile_top_uint (hashlist_format);
10499
10500 /**
10501 * load hashes, part II: allocate required memory, set pointers
10502 */
10503
10504 hash_t *hashes_buf = NULL;
10505 void *digests_buf = NULL;
10506 salt_t *salts_buf = NULL;
10507 void *esalts_buf = NULL;
10508
10509 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10510
10511 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10512
10513 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10514 {
10515 uint32_t hash_pos;
10516
10517 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10518 {
10519 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10520
10521 hashes_buf[hash_pos].hash_info = hash_info;
10522
10523 if (username && (remove || show || left))
10524 {
10525 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10526 }
10527
10528 if (benchmark)
10529 {
10530 hash_info->orighash = (char *) mymalloc (256);
10531 }
10532 }
10533 }
10534
10535 if (isSalted)
10536 {
10537 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10538
10539 if (esalt_size)
10540 {
10541 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10542 }
10543 }
10544 else
10545 {
10546 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10547 }
10548
10549 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10550 {
10551 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10552
10553 if (isSalted)
10554 {
10555 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10556
10557 if (esalt_size)
10558 {
10559 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10560 }
10561 }
10562 else
10563 {
10564 hashes_buf[hash_pos].salt = &salts_buf[0];
10565 }
10566 }
10567
10568 /**
10569 * load hashes, part III: parse hashes or generate them if benchmark
10570 */
10571
10572 uint hashes_cnt = 0;
10573
10574 if (benchmark == 0)
10575 {
10576 if (keyspace == 1)
10577 {
10578 // useless to read hash file for keyspace, cheat a little bit w/ optind
10579 }
10580 else if (hashes_avail == 0)
10581 {
10582 }
10583 else if (hashlist_mode == HL_MODE_ARG)
10584 {
10585 char *input_buf = myargv[optind];
10586
10587 uint input_len = strlen (input_buf);
10588
10589 logfile_top_var_string ("target", input_buf);
10590
10591 char *hash_buf = NULL;
10592 int hash_len = 0;
10593
10594 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10595
10596 if (hash_len)
10597 {
10598 if (opts_type & OPTS_TYPE_HASH_COPY)
10599 {
10600 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10601
10602 hash_info_tmp->orighash = mystrdup (hash_buf);
10603 }
10604
10605 if (isSalted)
10606 {
10607 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10608 }
10609
10610 int parser_status = PARSER_OK;
10611
10612 if (hash_mode == 2500)
10613 {
10614 if (hash_len == 0)
10615 {
10616 log_error ("ERROR: hccap file not specified");
10617
10618 return (-1);
10619 }
10620
10621 hashlist_mode = HL_MODE_FILE;
10622
10623 data.hashlist_mode = hashlist_mode;
10624
10625 FILE *fp = fopen (hash_buf, "rb");
10626
10627 if (fp == NULL)
10628 {
10629 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10630
10631 return (-1);
10632 }
10633
10634 if (hashes_avail < 1)
10635 {
10636 log_error ("ERROR: hccap file is empty or corrupt");
10637
10638 fclose (fp);
10639
10640 return (-1);
10641 }
10642
10643 uint hccap_size = sizeof (hccap_t);
10644
10645 char in[hccap_size];
10646
10647 while (!feof (fp))
10648 {
10649 int n = fread (&in, hccap_size, 1, fp);
10650
10651 if (n != 1)
10652 {
10653 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
10654
10655 break;
10656 }
10657
10658 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
10659
10660 if (parser_status != PARSER_OK)
10661 {
10662 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
10663
10664 continue;
10665 }
10666
10667 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
10668
10669 if ((show == 1) || (left == 1))
10670 {
10671 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
10672
10673 char *salt_ptr = (char *) tmp_salt->salt_buf;
10674
10675 int cur_pos = tmp_salt->salt_len;
10676 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10677
10678 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
10679
10680 unsigned char *pke_ptr = (unsigned char *) wpa->pke;
10681
10682 // do the appending task
10683
10684 snprintf (salt_ptr + cur_pos,
10685 rem_len,
10686 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
10687 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
10688 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
10689
10690
10691 // memset () the remaining part of the salt
10692
10693 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
10694 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10695
10696 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
10697
10698 tmp_salt->salt_len += 1 + 12 + 1 + 12;
10699 }
10700
10701 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);
10702 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);
10703
10704 hashes_cnt++;
10705 }
10706
10707 fclose (fp);
10708 }
10709 else if (hash_mode == 3000)
10710 {
10711 if (hash_len == 32)
10712 {
10713 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10714
10715 hash_t *lm_hash_left = NULL;
10716
10717 if (parser_status == PARSER_OK)
10718 {
10719 lm_hash_left = &hashes_buf[hashes_cnt];
10720
10721 hashes_cnt++;
10722 }
10723 else
10724 {
10725 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10726 }
10727
10728
10729 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10730
10731 hash_t *lm_hash_right = NULL;
10732
10733 if (parser_status == PARSER_OK)
10734 {
10735 lm_hash_right = &hashes_buf[hashes_cnt];
10736
10737 hashes_cnt++;
10738 }
10739 else
10740 {
10741 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10742 }
10743
10744 // show / left
10745
10746 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
10747 {
10748 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);
10749 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);
10750 }
10751 }
10752 else
10753 {
10754 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10755
10756 if (parser_status == PARSER_OK)
10757 {
10758 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10759 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10760 }
10761
10762 if (parser_status == PARSER_OK)
10763 {
10764 hashes_cnt++;
10765 }
10766 else
10767 {
10768 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10769 }
10770 }
10771 }
10772 else
10773 {
10774 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10775
10776 if (parser_status == PARSER_OK)
10777 {
10778 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10779 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10780 }
10781
10782 if (parser_status == PARSER_OK)
10783 {
10784 hashes_cnt++;
10785 }
10786 else
10787 {
10788 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10789 }
10790 }
10791 }
10792 }
10793 else if (hashlist_mode == HL_MODE_FILE)
10794 {
10795 char *hashfile = data.hashfile;
10796
10797 FILE *fp;
10798
10799 if ((fp = fopen (hashfile, "rb")) == NULL)
10800 {
10801 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10802
10803 return (-1);
10804 }
10805
10806 uint line_num = 0;
10807
10808 while (!feof (fp))
10809 {
10810 line_num++;
10811
10812 char line_buf[BUFSIZ];
10813
10814 int line_len = fgetl (fp, line_buf);
10815
10816 if (line_len == 0) continue;
10817
10818 char *hash_buf = NULL;
10819 int hash_len = 0;
10820
10821 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
10822
10823 if (username)
10824 {
10825 char *user_buf = NULL;
10826 int user_len = 0;
10827
10828 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
10829
10830 if (remove || show)
10831 {
10832 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
10833
10834 *user = (user_t *) malloc (sizeof (user_t));
10835
10836 user_t *user_ptr = *user;
10837
10838 if (user_buf != NULL)
10839 {
10840 user_ptr->user_name = mystrdup (user_buf);
10841 }
10842 else
10843 {
10844 user_ptr->user_name = mystrdup ("");
10845 }
10846
10847 user_ptr->user_len = user_len;
10848 }
10849 }
10850
10851 if (opts_type & OPTS_TYPE_HASH_COPY)
10852 {
10853 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10854
10855 hash_info_tmp->orighash = mystrdup (hash_buf);
10856 }
10857
10858 if (isSalted)
10859 {
10860 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
10861 }
10862
10863 if (hash_mode == 3000)
10864 {
10865 if (hash_len == 32)
10866 {
10867 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10868
10869 if (parser_status < PARSER_GLOBAL_ZERO)
10870 {
10871 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10872
10873 continue;
10874 }
10875
10876 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
10877
10878 hashes_cnt++;
10879
10880 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10881
10882 if (parser_status < PARSER_GLOBAL_ZERO)
10883 {
10884 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10885
10886 continue;
10887 }
10888
10889 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
10890
10891 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);
10892
10893 hashes_cnt++;
10894
10895 // show / left
10896
10897 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);
10898 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);
10899 }
10900 else
10901 {
10902 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10903
10904 if (parser_status < PARSER_GLOBAL_ZERO)
10905 {
10906 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10907
10908 continue;
10909 }
10910
10911 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);
10912
10913 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10914 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10915
10916 hashes_cnt++;
10917 }
10918 }
10919 else
10920 {
10921 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10922
10923 if (parser_status < PARSER_GLOBAL_ZERO)
10924 {
10925 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10926
10927 continue;
10928 }
10929
10930 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);
10931
10932 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10933 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10934
10935 hashes_cnt++;
10936 }
10937 }
10938
10939 fclose (fp);
10940
10941 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
10942
10943 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
10944 }
10945 }
10946 else
10947 {
10948 if (isSalted)
10949 {
10950 hashes_buf[0].salt->salt_len = 8;
10951
10952 // special salt handling
10953
10954 switch (hash_mode)
10955 {
10956 case 1500: hashes_buf[0].salt->salt_len = 2;
10957 break;
10958 case 1731: hashes_buf[0].salt->salt_len = 4;
10959 break;
10960 case 2410: hashes_buf[0].salt->salt_len = 4;
10961 break;
10962 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
10963 break;
10964 case 3100: hashes_buf[0].salt->salt_len = 1;
10965 break;
10966 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
10967 break;
10968 case 5800: hashes_buf[0].salt->salt_len = 16;
10969 break;
10970 case 6800: hashes_buf[0].salt->salt_len = 32;
10971 break;
10972 case 8400: hashes_buf[0].salt->salt_len = 40;
10973 break;
10974 case 8800: hashes_buf[0].salt->salt_len = 16;
10975 break;
10976 case 8900: hashes_buf[0].salt->salt_len = 16;
10977 hashes_buf[0].salt->scrypt_N = 1024;
10978 hashes_buf[0].salt->scrypt_r = 1;
10979 hashes_buf[0].salt->scrypt_p = 1;
10980 break;
10981 case 9100: hashes_buf[0].salt->salt_len = 16;
10982 break;
10983 case 9300: hashes_buf[0].salt->salt_len = 14;
10984 hashes_buf[0].salt->scrypt_N = 16384;
10985 hashes_buf[0].salt->scrypt_r = 1;
10986 hashes_buf[0].salt->scrypt_p = 1;
10987 break;
10988 case 9400: hashes_buf[0].salt->salt_len = 16;
10989 break;
10990 case 9500: hashes_buf[0].salt->salt_len = 16;
10991 break;
10992 case 9600: hashes_buf[0].salt->salt_len = 16;
10993 break;
10994 case 9700: hashes_buf[0].salt->salt_len = 16;
10995 break;
10996 case 9710: hashes_buf[0].salt->salt_len = 16;
10997 break;
10998 case 9720: hashes_buf[0].salt->salt_len = 16;
10999 break;
11000 case 9800: hashes_buf[0].salt->salt_len = 16;
11001 break;
11002 case 9810: hashes_buf[0].salt->salt_len = 16;
11003 break;
11004 case 9820: hashes_buf[0].salt->salt_len = 16;
11005 break;
11006 case 10300: hashes_buf[0].salt->salt_len = 12;
11007 break;
11008 case 11500: hashes_buf[0].salt->salt_len = 4;
11009 break;
11010 case 11600: hashes_buf[0].salt->salt_len = 4;
11011 break;
11012 case 12400: hashes_buf[0].salt->salt_len = 4;
11013 break;
11014 case 12500: hashes_buf[0].salt->salt_len = 8;
11015 break;
11016 case 12600: hashes_buf[0].salt->salt_len = 64;
11017 break;
11018 }
11019
11020 // special esalt handling
11021
11022 switch (hash_mode)
11023 {
11024 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11025 break;
11026 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11027 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11028 break;
11029 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11030 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11031 break;
11032 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11033 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11034 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11035 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11036 break;
11037 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11038 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11039 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11040 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11041 break;
11042 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11043 break;
11044 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11045 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11046 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11047 break;
11048 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11049 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11050 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11051 break;
11052 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11053 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11054 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11055 break;
11056 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11057 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11058 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11059 break;
11060 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11061 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11062 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11063 break;
11064 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11065 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11066 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11067 break;
11068 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11069 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11070 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11071 break;
11072 }
11073 }
11074
11075 // set hashfile
11076
11077 switch (hash_mode)
11078 {
11079 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11080 break;
11081 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11082 break;
11083 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11084 break;
11085 case 6211:
11086 case 6212:
11087 case 6213:
11088 case 6221:
11089 case 6222:
11090 case 6223:
11091 case 6231:
11092 case 6232:
11093 case 6233:
11094 case 6241:
11095 case 6242:
11096 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11097 break;
11098 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11099 break;
11100 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11101 break;
11102 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11103 break;
11104 }
11105
11106 // set default iterations
11107
11108 switch (hash_mode)
11109 {
11110 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11111 break;
11112 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11113 break;
11114 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11115 break;
11116 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11117 break;
11118 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11119 break;
11120 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11121 break;
11122 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11123 break;
11124 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11125 break;
11126 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11127 break;
11128 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11129 break;
11130 case 6211:
11131 case 6212:
11132 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11133 break;
11134 case 6221:
11135 case 6222:
11136 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11137 break;
11138 case 6231:
11139 case 6232:
11140 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11141 break;
11142 case 6241:
11143 case 6242:
11144 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11145 break;
11146 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11147 break;
11148 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11149 break;
11150 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11151 break;
11152 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11153 break;
11154 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11155 break;
11156 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11157 break;
11158 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11159 break;
11160 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11161 break;
11162 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11163 break;
11164 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11165 break;
11166 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11167 break;
11168 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11169 break;
11170 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11171 break;
11172 case 8900: hashes_buf[0].salt->salt_iter = 1;
11173 break;
11174 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11175 break;
11176 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11177 break;
11178 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11179 break;
11180 case 9300: hashes_buf[0].salt->salt_iter = 1;
11181 break;
11182 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11183 break;
11184 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11185 break;
11186 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11187 break;
11188 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11189 break;
11190 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11191 break;
11192 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11193 break;
11194 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11195 break;
11196 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11197 break;
11198 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11199 break;
11200 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11201 break;
11202 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11203 break;
11204 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11205 break;
11206 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11207 break;
11208 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11209 break;
11210 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11211 break;
11212 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11213 break;
11214 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11215 break;
11216 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11217 break;
11218 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11219 break;
11220 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11221 break;
11222 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11223 break;
11224 }
11225
11226 // set special tuning for benchmark-mode 1
11227
11228 if (benchmark_mode == 1)
11229 {
11230 kernel_loops *= 8;
11231 kernel_accel *= 4;
11232
11233 switch (hash_mode)
11234 {
11235 case 400: kernel_loops = ROUNDS_PHPASS;
11236 kernel_accel = 32;
11237 break;
11238 case 500: kernel_loops = ROUNDS_MD5CRYPT;
11239 kernel_accel = 32;
11240 break;
11241 case 501: kernel_loops = ROUNDS_MD5CRYPT;
11242 kernel_accel = 32;
11243 break;
11244 case 1600: kernel_loops = ROUNDS_MD5CRYPT;
11245 kernel_accel = 32;
11246 break;
11247 case 1800: kernel_loops = ROUNDS_SHA512CRYPT;
11248 kernel_accel = 16;
11249 break;
11250 case 2100: kernel_loops = ROUNDS_DCC2;
11251 kernel_accel = 16;
11252 break;
11253 case 2500: kernel_loops = ROUNDS_WPA2;
11254 kernel_accel = 32;
11255 break;
11256 case 3200: kernel_loops = ROUNDS_BCRYPT;
11257 kernel_accel = 8;
11258 break;
11259 case 5200: kernel_loops = ROUNDS_PSAFE3;
11260 kernel_accel = 16;
11261 break;
11262 case 5800: kernel_loops = ROUNDS_ANDROIDPIN;
11263 kernel_accel = 16;
11264 break;
11265 case 6211: kernel_loops = ROUNDS_TRUECRYPT_2K;
11266 kernel_accel = 64;
11267 break;
11268 case 6212: kernel_loops = ROUNDS_TRUECRYPT_2K;
11269 kernel_accel = 32;
11270 break;
11271 case 6213: kernel_loops = ROUNDS_TRUECRYPT_2K;
11272 kernel_accel = 32;
11273 break;
11274 case 6221: kernel_loops = ROUNDS_TRUECRYPT_1K;
11275 kernel_accel = 8;
11276 break;
11277 case 6222: kernel_loops = ROUNDS_TRUECRYPT_1K;
11278 kernel_accel = 8;
11279 break;
11280 case 6223: kernel_loops = ROUNDS_TRUECRYPT_1K;
11281 kernel_accel = 8;
11282 break;
11283 case 6231: kernel_loops = ROUNDS_TRUECRYPT_1K;
11284 kernel_accel = 8;
11285 break;
11286 case 6232: kernel_loops = ROUNDS_TRUECRYPT_1K;
11287 kernel_accel = 8;
11288 break;
11289 case 6233: kernel_loops = ROUNDS_TRUECRYPT_1K;
11290 kernel_accel = 8;
11291 break;
11292 case 6241: kernel_loops = ROUNDS_TRUECRYPT_1K;
11293 kernel_accel = 128;
11294 break;
11295 case 6242: kernel_loops = ROUNDS_TRUECRYPT_1K;
11296 kernel_accel = 64;
11297 break;
11298 case 6243: kernel_loops = ROUNDS_TRUECRYPT_1K;
11299 kernel_accel = 64;
11300 break;
11301 case 6300: kernel_loops = ROUNDS_MD5CRYPT;
11302 kernel_accel = 32;
11303 break;
11304 case 6700: kernel_loops = ROUNDS_SHA1AIX;
11305 kernel_accel = 128;
11306 break;
11307 case 6400: kernel_loops = ROUNDS_SHA256AIX;
11308 kernel_accel = 128;
11309 break;
11310 case 6500: kernel_loops = ROUNDS_SHA512AIX;
11311 kernel_accel = 32;
11312 break;
11313 case 6600: kernel_loops = ROUNDS_AGILEKEY;
11314 kernel_accel = 64;
11315 break;
11316 case 6800: kernel_loops = ROUNDS_LASTPASS;
11317 kernel_accel = 64;
11318 break;
11319 case 7100: kernel_loops = ROUNDS_SHA512OSX;
11320 kernel_accel = 8;
11321 break;
11322 case 7200: kernel_loops = ROUNDS_GRUB;
11323 kernel_accel = 16;
11324 break;
11325 case 7400: kernel_loops = ROUNDS_SHA256CRYPT;
11326 kernel_accel = 8;
11327 break;
11328 case 7900: kernel_loops = ROUNDS_DRUPAL7;
11329 kernel_accel = 8;
11330 break;
11331 case 8200: kernel_loops = ROUNDS_CLOUDKEY;
11332 kernel_accel = 8;
11333 break;
11334 case 8800: kernel_loops = ROUNDS_ANDROIDFDE;
11335 kernel_accel = 32;
11336 break;
11337 case 8900: kernel_loops = 1;
11338 kernel_accel = 64;
11339 break;
11340 case 9000: kernel_loops = ROUNDS_PSAFE2;
11341 kernel_accel = 16;
11342 break;
11343 case 9100: kernel_loops = ROUNDS_LOTUS8;
11344 kernel_accel = 64;
11345 break;
11346 case 9200: kernel_loops = ROUNDS_CISCO8;
11347 kernel_accel = 8;
11348 break;
11349 case 9300: kernel_loops = 1;
11350 kernel_accel = 4;
11351 break;
11352 case 9400: kernel_loops = ROUNDS_OFFICE2007;
11353 kernel_accel = 32;
11354 break;
11355 case 9500: kernel_loops = ROUNDS_OFFICE2010;
11356 kernel_accel = 32;
11357 break;
11358 case 9600: kernel_loops = ROUNDS_OFFICE2013;
11359 kernel_accel = 8;
11360 break;
11361 case 10000: kernel_loops = ROUNDS_DJANGOPBKDF2;
11362 kernel_accel = 8;
11363 break;
11364 case 10300: kernel_loops = ROUNDS_SAPH_SHA1;
11365 kernel_accel = 16;
11366 break;
11367 case 10500: kernel_loops = ROUNDS_PDF14;
11368 kernel_accel = 256;
11369 break;
11370 case 10700: kernel_loops = ROUNDS_PDF17L8;
11371 kernel_accel = 8;
11372 break;
11373 case 10900: kernel_loops = ROUNDS_PBKDF2_SHA256;
11374 kernel_accel = 8;
11375 break;
11376 case 11300: kernel_loops = ROUNDS_BITCOIN_WALLET;
11377 kernel_accel = 8;
11378 break;
11379 case 11600: kernel_loops = ROUNDS_SEVEN_ZIP;
11380 kernel_accel = 8;
11381 break;
11382 case 11900: kernel_loops = ROUNDS_PBKDF2_MD5;
11383 kernel_accel = 8;
11384 break;
11385 case 12000: kernel_loops = ROUNDS_PBKDF2_SHA1;
11386 kernel_accel = 8;
11387 break;
11388 case 12100: kernel_loops = ROUNDS_PBKDF2_SHA512;
11389 kernel_accel = 8;
11390 break;
11391 case 12200: kernel_loops = ROUNDS_ECRYPTFS;
11392 kernel_accel = 8;
11393 break;
11394 case 12300: kernel_loops = ROUNDS_ORACLET;
11395 kernel_accel = 8;
11396 break;
11397 case 12500: kernel_loops = ROUNDS_RAR3;
11398 kernel_accel = 32;
11399 break;
11400 case 12700: kernel_loops = ROUNDS_MYWALLET;
11401 kernel_accel = 512;
11402 break;
11403 case 12800: kernel_loops = ROUNDS_MS_DRSR;
11404 kernel_accel = 512;
11405 break;
11406 case 12900: kernel_loops = ROUNDS_ANDROIDFDE_SAMSUNG;
11407 kernel_accel = 8;
11408 break;
11409 case 13000: kernel_loops = ROUNDS_RAR5;
11410 kernel_accel = 8;
11411 break;
11412 }
11413
11414 // some algorithm collide too fast, make that impossible
11415
11416 switch (hash_mode)
11417 {
11418 case 11500: ((uint *) digests_buf)[1] = 1;
11419 break;
11420 }
11421
11422 if (kernel_loops > 1024) kernel_loops = 1024;
11423 if (kernel_accel > 256) kernel_accel = 256; // causes memory problems otherwise
11424 }
11425
11426 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
11427 {
11428 kernel_loops = 1024;
11429 }
11430
11431 if (hash_mode == 12500)
11432 {
11433 kernel_loops = ROUNDS_RAR3 / 16;
11434 }
11435
11436 data.kernel_accel = kernel_accel;
11437 data.kernel_loops = kernel_loops;
11438
11439 hashes_cnt = 1;
11440 }
11441
11442 if (show == 1 || left == 1)
11443 {
11444 for (uint i = 0; i < pot_cnt; i++)
11445 {
11446 pot_t *pot_ptr = &pot[i];
11447
11448 hash_t *hashes_buf = &pot_ptr->hash;
11449
11450 local_free (hashes_buf->digest);
11451
11452 if (isSalted)
11453 {
11454 local_free (hashes_buf->salt);
11455 }
11456 }
11457
11458 local_free (pot);
11459
11460 if (data.quiet == 0) log_info_nn ("");
11461
11462 return (0);
11463 }
11464
11465 if (keyspace == 0)
11466 {
11467 if (hashes_cnt == 0)
11468 {
11469 log_error ("ERROR: No hashes loaded");
11470
11471 return (-1);
11472 }
11473 }
11474
11475 /**
11476 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11477 */
11478
11479 if (data.outfile != NULL)
11480 {
11481 if (data.hashfile != NULL)
11482 {
11483 #ifdef _POSIX
11484 struct stat tmpstat_outfile;
11485 struct stat tmpstat_hashfile;
11486 #endif
11487
11488 #ifdef _WIN
11489 struct stat64 tmpstat_outfile;
11490 struct stat64 tmpstat_hashfile;
11491 #endif
11492
11493 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11494
11495 if (tmp_outfile_fp)
11496 {
11497 #ifdef _POSIX
11498 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11499 #endif
11500
11501 #ifdef _WIN
11502 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11503 #endif
11504
11505 fclose (tmp_outfile_fp);
11506 }
11507
11508 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11509
11510 if (tmp_hashfile_fp)
11511 {
11512 #ifdef _POSIX
11513 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11514 #endif
11515
11516 #ifdef _WIN
11517 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11518 #endif
11519
11520 fclose (tmp_hashfile_fp);
11521 }
11522
11523 if (tmp_outfile_fp && tmp_outfile_fp)
11524 {
11525 tmpstat_outfile.st_mode = 0;
11526 tmpstat_outfile.st_nlink = 0;
11527 tmpstat_outfile.st_uid = 0;
11528 tmpstat_outfile.st_gid = 0;
11529 tmpstat_outfile.st_rdev = 0;
11530 tmpstat_outfile.st_atime = 0;
11531
11532 tmpstat_hashfile.st_mode = 0;
11533 tmpstat_hashfile.st_nlink = 0;
11534 tmpstat_hashfile.st_uid = 0;
11535 tmpstat_hashfile.st_gid = 0;
11536 tmpstat_hashfile.st_rdev = 0;
11537 tmpstat_hashfile.st_atime = 0;
11538
11539 #ifdef _POSIX
11540 tmpstat_outfile.st_blksize = 0;
11541 tmpstat_outfile.st_blocks = 0;
11542
11543 tmpstat_hashfile.st_blksize = 0;
11544 tmpstat_hashfile.st_blocks = 0;
11545 #endif
11546
11547 #ifdef _POSIX
11548 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11549 {
11550 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11551
11552 return (-1);
11553 }
11554 #endif
11555
11556 #ifdef _WIN
11557 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11558 {
11559 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11560
11561 return (-1);
11562 }
11563 #endif
11564 }
11565 }
11566 }
11567
11568 /**
11569 * Remove duplicates
11570 */
11571
11572 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11573
11574 if (isSalted)
11575 {
11576 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11577 }
11578 else
11579 {
11580 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11581 }
11582
11583 uint hashes_cnt_orig = hashes_cnt;
11584
11585 hashes_cnt = 1;
11586
11587 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11588 {
11589 if (isSalted)
11590 {
11591 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11592 {
11593 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11594 }
11595 }
11596 else
11597 {
11598 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11599 }
11600
11601 if (hashes_pos > hashes_cnt)
11602 {
11603 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11604 }
11605
11606 hashes_cnt++;
11607 }
11608
11609 /**
11610 * Potfile removes
11611 */
11612
11613 uint potfile_remove_cracks = 0;
11614
11615 if (potfile_disable == 0)
11616 {
11617 hash_t hash_buf;
11618
11619 hash_buf.digest = mymalloc (dgst_size);
11620 hash_buf.salt = NULL;
11621 hash_buf.esalt = NULL;
11622 hash_buf.hash_info = NULL;
11623 hash_buf.cracked = 0;
11624
11625 if (isSalted)
11626 {
11627 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11628 }
11629
11630 if (esalt_size)
11631 {
11632 hash_buf.esalt = mymalloc (esalt_size);
11633 }
11634
11635 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11636
11637 // no solution for these special hash types (for instane because they use hashfile in output etc)
11638 if ((hash_mode != 5200) &&
11639 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11640 (hash_mode != 9000))
11641 {
11642 FILE *fp = fopen (potfile, "rb");
11643
11644 if (fp != NULL)
11645 {
11646 while (!feof (fp))
11647 {
11648 char line_buf[BUFSIZ];
11649
11650 memset (line_buf, 0, BUFSIZ);
11651
11652 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11653
11654 if (ptr == NULL) break;
11655
11656 int line_len = strlen (line_buf);
11657
11658 if (line_len == 0) continue;
11659
11660 int iter = MAX_CUT_TRIES;
11661
11662 for (int i = line_len - 1; i && iter; i--, line_len--)
11663 {
11664 if (line_buf[i] != ':') continue;
11665
11666 if (isSalted)
11667 {
11668 memset (hash_buf.salt, 0, sizeof (salt_t));
11669 }
11670
11671 hash_t *found = NULL;
11672
11673 if (hash_mode == 6800)
11674 {
11675 if (i < 48) // 48 = 12 * uint in salt_buf[]
11676 {
11677 // manipulate salt_buf
11678 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11679
11680 hash_buf.salt->salt_len = i;
11681
11682 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11683 }
11684 }
11685 else if (hash_mode == 2500)
11686 {
11687 if (i < 48) // 48 = 12 * uint in salt_buf[]
11688 {
11689 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11690 // manipulate salt_buf
11691
11692 // to be safe work with a copy (because of line_len loop, i etc)
11693
11694 char line_buf_cpy[BUFSIZ];
11695 memset (line_buf_cpy, 0, BUFSIZ);
11696
11697 memset (line_buf_cpy, 0, sizeof (line_buf_cpy));
11698
11699 memcpy (line_buf_cpy, line_buf, i);
11700
11701 char *mac2_pos = strrchr (line_buf_cpy, ':');
11702
11703 if (mac2_pos == NULL) continue;
11704
11705 mac2_pos[0] = 0;
11706 mac2_pos++;
11707
11708 if (strlen (mac2_pos) != 12) continue;
11709
11710 char *mac1_pos = strrchr (line_buf_cpy, ':');
11711
11712 if (mac1_pos == NULL) continue;
11713
11714 mac1_pos[0] = 0;
11715 mac1_pos++;
11716
11717 if (strlen (mac1_pos) != 12) continue;
11718
11719 uint essid_length = mac1_pos - line_buf_cpy - 1;
11720
11721 // here we need the ESSID
11722 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11723
11724 hash_buf.salt->salt_len = essid_length;
11725
11726 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11727
11728 if (found)
11729 {
11730 wpa_t *wpa = (wpa_t *) found->esalt;
11731
11732 uint pke[25];
11733
11734 char *pke_ptr = (char *) pke;
11735
11736 for (uint i = 0; i < 25; i++)
11737 {
11738 pke[i] = byte_swap_32 (wpa->pke[i]);
11739 }
11740
11741 unsigned char mac1[6];
11742 unsigned char mac2[6];
11743
11744 memcpy (mac1, pke_ptr + 23, 6);
11745 memcpy (mac2, pke_ptr + 29, 6);
11746
11747 // compare hex string(s) vs binary MAC address(es)
11748
11749 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11750 {
11751 if (mac1[i] != (unsigned char) hex_to_char (&mac1_pos[j]))
11752 {
11753 found = NULL;
11754 break;
11755 }
11756 }
11757
11758 // early skip ;)
11759 if (!found) continue;
11760
11761 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11762 {
11763 if (mac2[i] != (unsigned char) hex_to_char (&mac2_pos[j]))
11764 {
11765 found = NULL;
11766 break;
11767 }
11768 }
11769 }
11770 }
11771 }
11772 else
11773 {
11774 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11775
11776 if (parser_status == PARSER_OK)
11777 {
11778 if (isSalted)
11779 {
11780 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11781 }
11782 else
11783 {
11784 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11785 }
11786 }
11787 }
11788
11789 if (found == NULL) continue;
11790
11791 if (!found->cracked) potfile_remove_cracks++;
11792
11793 found->cracked = 1;
11794
11795 if (found) break;
11796
11797 iter--;
11798 }
11799 }
11800
11801 fclose (fp);
11802 }
11803 }
11804
11805 if (esalt_size)
11806 {
11807 local_free (hash_buf.esalt);
11808 }
11809
11810 if (isSalted)
11811 {
11812 local_free (hash_buf.salt);
11813 }
11814
11815 local_free (hash_buf.digest);
11816 }
11817
11818 /**
11819 * Now generate all the buffers required for later
11820 */
11821
11822 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11823
11824 salt_t *salts_buf_new = NULL;
11825 void *esalts_buf_new = NULL;
11826
11827 if (isSalted)
11828 {
11829 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11830
11831 if (esalt_size)
11832 {
11833 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
11834 }
11835 }
11836 else
11837 {
11838 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
11839 }
11840
11841 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
11842
11843 uint digests_cnt = hashes_cnt;
11844 uint digests_done = 0;
11845
11846 uint size_digests = digests_cnt * dgst_size;
11847 uint size_shown = digests_cnt * sizeof (uint);
11848
11849 uint *digests_shown = (uint *) mymalloc (size_shown);
11850 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
11851
11852 uint salts_cnt = 0;
11853 uint salts_done = 0;
11854
11855 hashinfo_t **hash_info = NULL;
11856
11857 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11858 {
11859 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
11860
11861 if (username && (remove || show))
11862 {
11863 uint user_pos;
11864
11865 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
11866 {
11867 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
11868
11869 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
11870 }
11871 }
11872 }
11873
11874 uint *salts_shown = (uint *) mymalloc (size_shown);
11875
11876 salt_t *salt_buf;
11877
11878 {
11879 // copied from inner loop
11880
11881 salt_buf = &salts_buf_new[salts_cnt];
11882
11883 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
11884
11885 if (esalt_size)
11886 {
11887 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
11888 }
11889
11890 salt_buf->digests_cnt = 0;
11891 salt_buf->digests_done = 0;
11892 salt_buf->digests_offset = 0;
11893
11894 salts_cnt++;
11895 }
11896
11897 if (hashes_buf[0].cracked == 1)
11898 {
11899 digests_shown[0] = 1;
11900
11901 digests_done++;
11902
11903 salt_buf->digests_done++;
11904 }
11905
11906 salt_buf->digests_cnt++;
11907
11908 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
11909
11910 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11911 {
11912 hash_info[0] = hashes_buf[0].hash_info;
11913 }
11914
11915 // copy from inner loop
11916
11917 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
11918 {
11919 if (isSalted)
11920 {
11921 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
11922 {
11923 salt_buf = &salts_buf_new[salts_cnt];
11924
11925 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
11926
11927 if (esalt_size)
11928 {
11929 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
11930 }
11931
11932 salt_buf->digests_cnt = 0;
11933 salt_buf->digests_done = 0;
11934 salt_buf->digests_offset = hashes_pos;
11935
11936 salts_cnt++;
11937 }
11938 }
11939
11940 if (hashes_buf[hashes_pos].cracked == 1)
11941 {
11942 digests_shown[hashes_pos] = 1;
11943
11944 digests_done++;
11945
11946 salt_buf->digests_done++;
11947 }
11948
11949 salt_buf->digests_cnt++;
11950
11951 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
11952
11953 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11954 {
11955 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
11956 }
11957 }
11958
11959 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
11960 {
11961 salt_t *salt_buf = &salts_buf_new[salt_pos];
11962
11963 if (salt_buf->digests_done == salt_buf->digests_cnt)
11964 {
11965 salts_shown[salt_pos] = 1;
11966
11967 salts_done++;
11968 }
11969
11970 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
11971 }
11972
11973 local_free (digests_buf);
11974 local_free (salts_buf);
11975 local_free (esalts_buf);
11976
11977 digests_buf = digests_buf_new;
11978 salts_buf = salts_buf_new;
11979 esalts_buf = esalts_buf_new;
11980
11981 local_free (hashes_buf);
11982
11983 /**
11984 * special modification not set from parser
11985 */
11986
11987 switch (hash_mode)
11988 {
11989 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
11990 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
11991 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
11992 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
11993 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
11994 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
11995 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
11996 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
11997 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
11998 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
11999 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12000 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12001 }
12002
12003 if (truecrypt_keyfiles)
12004 {
12005 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12006
12007 char *keyfiles = strdup (truecrypt_keyfiles);
12008
12009 char *keyfile = strtok (keyfiles, ",");
12010
12011 do
12012 {
12013 truecrypt_crc32 (keyfile, (unsigned char *) keyfile_buf);
12014
12015 } while ((keyfile = strtok (NULL, ",")) != NULL);
12016
12017 free (keyfiles);
12018 }
12019
12020 data.digests_cnt = digests_cnt;
12021 data.digests_done = digests_done;
12022 data.digests_buf = digests_buf;
12023 data.digests_shown = digests_shown;
12024 data.digests_shown_tmp = digests_shown_tmp;
12025
12026 data.salts_cnt = salts_cnt;
12027 data.salts_done = salts_done;
12028 data.salts_buf = salts_buf;
12029 data.salts_shown = salts_shown;
12030
12031 data.esalts_buf = esalts_buf;
12032 data.hash_info = hash_info;
12033
12034 /**
12035 * Automatic Optimizers
12036 */
12037
12038 if (salts_cnt == 1)
12039 opti_type |= OPTI_TYPE_SINGLE_SALT;
12040
12041 if (digests_cnt == 1)
12042 opti_type |= OPTI_TYPE_SINGLE_HASH;
12043
12044 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12045 opti_type |= OPTI_TYPE_NOT_ITERATED;
12046
12047 if (attack_mode == ATTACK_MODE_BF)
12048 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12049
12050 data.opti_type = opti_type;
12051
12052 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12053 {
12054 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12055 {
12056 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12057 {
12058 if (opts_type & OPTS_TYPE_ST_ADD80)
12059 {
12060 opts_type &= ~OPTS_TYPE_ST_ADD80;
12061 opts_type |= OPTS_TYPE_PT_ADD80;
12062 }
12063
12064 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12065 {
12066 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12067 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12068 }
12069
12070 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12071 {
12072 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12073 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12074 }
12075 }
12076 }
12077 }
12078
12079 /**
12080 * Some algorithm, like descrypt, can benefit from JIT compilation
12081 */
12082
12083 uint force_jit_compilation = 0;
12084
12085 if (hash_mode == 8900)
12086 {
12087 force_jit_compilation = 8900;
12088 }
12089 else if (hash_mode == 9300)
12090 {
12091 force_jit_compilation = 8900;
12092 }
12093 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12094 {
12095 force_jit_compilation = 1500;
12096 }
12097
12098 /**
12099 * generate bitmap tables
12100 */
12101
12102 const uint bitmap_shift1 = 5;
12103 const uint bitmap_shift2 = 13;
12104
12105 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12106
12107 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12108 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12109 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12110 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12111 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12112 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12113 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12114 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12115
12116 uint bitmap_bits;
12117 uint bitmap_nums;
12118 uint bitmap_mask;
12119 uint bitmap_size;
12120
12121 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12122 {
12123 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12124
12125 bitmap_nums = 1 << bitmap_bits;
12126
12127 bitmap_mask = bitmap_nums - 1;
12128
12129 bitmap_size = bitmap_nums * sizeof (uint);
12130
12131 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12132
12133 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;
12134 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;
12135
12136 break;
12137 }
12138
12139 bitmap_nums = 1 << bitmap_bits;
12140
12141 bitmap_mask = bitmap_nums - 1;
12142
12143 bitmap_size = bitmap_nums * sizeof (uint);
12144
12145 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);
12146 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);
12147
12148 /**
12149 * prepare quick rule
12150 */
12151
12152 data.rule_buf_l = rule_buf_l;
12153 data.rule_buf_r = rule_buf_r;
12154
12155 int rule_len_l = (int) strlen (rule_buf_l);
12156 int rule_len_r = (int) strlen (rule_buf_r);
12157
12158 data.rule_len_l = rule_len_l;
12159 data.rule_len_r = rule_len_r;
12160
12161 /**
12162 * load rules
12163 */
12164
12165 uint *all_kernel_rules_cnt = NULL;
12166
12167 kernel_rule_t **all_kernel_rules_buf = NULL;
12168
12169 if (rp_files_cnt)
12170 {
12171 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12172
12173 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12174 }
12175
12176 char rule_buf[BUFSIZ];
12177
12178 int rule_len = 0;
12179
12180 for (uint i = 0; i < rp_files_cnt; i++)
12181 {
12182 uint kernel_rules_avail = 0;
12183
12184 uint kernel_rules_cnt = 0;
12185
12186 kernel_rule_t *kernel_rules_buf = NULL;
12187
12188 char *rp_file = rp_files[i];
12189
12190 char in[BLOCK_SIZE];
12191 char out[BLOCK_SIZE];
12192
12193 FILE *fp = NULL;
12194
12195 uint rule_line = 0;
12196
12197 if ((fp = fopen (rp_file, "rb")) == NULL)
12198 {
12199 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12200
12201 return (-1);
12202 }
12203
12204 while (!feof (fp))
12205 {
12206 memset (rule_buf, 0, BUFSIZ);
12207
12208 rule_len = fgetl (fp, rule_buf);
12209
12210 rule_line++;
12211
12212 if (rule_len == 0) continue;
12213
12214 if (rule_buf[0] == '#') continue;
12215
12216 if (kernel_rules_avail == kernel_rules_cnt)
12217 {
12218 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12219
12220 kernel_rules_avail += INCR_RULES;
12221 }
12222
12223 memset (in, 0, BLOCK_SIZE);
12224 memset (out, 0, BLOCK_SIZE);
12225
12226 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12227
12228 if (result == -1)
12229 {
12230 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12231
12232 continue;
12233 }
12234
12235 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12236 {
12237 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12238
12239 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12240
12241 continue;
12242 }
12243
12244 /* its so slow
12245 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12246 {
12247 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12248
12249 continue;
12250 }
12251 */
12252
12253 kernel_rules_cnt++;
12254 }
12255
12256 fclose (fp);
12257
12258 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12259
12260 all_kernel_rules_buf[i] = kernel_rules_buf;
12261 }
12262
12263 /**
12264 * merge rules or automatic rule generator
12265 */
12266
12267 uint kernel_rules_cnt = 0;
12268
12269 kernel_rule_t *kernel_rules_buf = NULL;
12270
12271 if (attack_mode == ATTACK_MODE_STRAIGHT)
12272 {
12273 if (rp_files_cnt)
12274 {
12275 kernel_rules_cnt = 1;
12276
12277 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12278
12279 repeats[0] = kernel_rules_cnt;
12280
12281 for (uint i = 0; i < rp_files_cnt; i++)
12282 {
12283 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12284
12285 repeats[i + 1] = kernel_rules_cnt;
12286 }
12287
12288 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12289
12290 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12291
12292 for (uint i = 0; i < kernel_rules_cnt; i++)
12293 {
12294 uint out_pos = 0;
12295
12296 kernel_rule_t *out = &kernel_rules_buf[i];
12297
12298 for (uint j = 0; j < rp_files_cnt; j++)
12299 {
12300 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12301 uint in_pos;
12302
12303 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12304
12305 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12306 {
12307 if (out_pos == RULES_MAX - 1)
12308 {
12309 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12310
12311 break;
12312 }
12313
12314 out->cmds[out_pos] = in->cmds[in_pos];
12315 }
12316 }
12317 }
12318
12319 local_free (repeats);
12320 }
12321 else if (rp_gen)
12322 {
12323 uint kernel_rules_avail = 0;
12324
12325 while (kernel_rules_cnt < rp_gen)
12326 {
12327 if (kernel_rules_avail == kernel_rules_cnt)
12328 {
12329 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12330
12331 kernel_rules_avail += INCR_RULES;
12332 }
12333
12334 memset (rule_buf, 0, BLOCK_SIZE);
12335
12336 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12337
12338 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12339
12340 kernel_rules_cnt++;
12341 }
12342 }
12343 }
12344
12345 /**
12346 * generate NOP rules
12347 */
12348
12349 if (kernel_rules_cnt == 0)
12350 {
12351 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12352
12353 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12354
12355 kernel_rules_cnt++;
12356 }
12357
12358 data.kernel_rules_cnt = kernel_rules_cnt;
12359 data.kernel_rules_buf = kernel_rules_buf;
12360
12361 /**
12362 * OpenCL platforms: detect
12363 */
12364
12365 cl_platform_id CL_platforms[CL_PLATFORMS_MAX];
12366
12367 uint CL_platforms_cnt = 0;
12368
12369 hc_clGetPlatformIDs (CL_PLATFORMS_MAX, CL_platforms, &CL_platforms_cnt);
12370
12371 if (CL_platforms_cnt == 0)
12372 {
12373 log_error ("ERROR: No OpenCL compatible platform found");
12374
12375 return (-1);
12376 }
12377
12378 /**
12379 * OpenCL platforms: For each platform check if broken or unset features that we can not use, eg: temp_retain
12380 */
12381
12382 for (uint i = 0; i < CL_platforms_cnt; i++)
12383 {
12384 cl_platform_id CL_platform = CL_platforms[i];
12385
12386 char CL_platform_vendor[INFOSZ];
12387
12388 memset (CL_platform_vendor, 0, sizeof (CL_platform_vendor));
12389
12390 hc_clGetPlatformInfo (CL_platform, CL_PLATFORM_VENDOR, sizeof (CL_platform_vendor), CL_platform_vendor, NULL);
12391
12392 if (strcmp (CL_platform_vendor, CL_VENDOR_NV) == 0)
12393 {
12394 // make sure that we do not directly control the fan for NVidia
12395
12396 gpu_temp_retain = 0;
12397
12398 data.gpu_temp_retain = gpu_temp_retain;
12399 }
12400 else if (strcmp (CL_platform_vendor, CL_VENDOR_POCL) == 0)
12401 {
12402 if (force == 0)
12403 {
12404 log_info ("");
12405 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12406 log_info ("You are STRONGLY encouraged not to use it");
12407 log_info ("You can use --force to override this but do not post error reports if you do so");
12408 log_info ("");
12409
12410 return (-1);
12411 }
12412 }
12413 }
12414
12415 /**
12416 * OpenCL devices: push all devices from all platforms into the same device array
12417 */
12418
12419 uint devices_plf[DEVICES_MAX]; // device number on platform, required for hardware-management mapping
12420
12421 cl_device_id devices_all[DEVICES_MAX];
12422 cl_device_id devices[DEVICES_MAX];
12423
12424 uint devices_all_cnt = 0;
12425 uint devices_cnt = 0;
12426
12427 for (uint i = 0; i < CL_platforms_cnt; i++)
12428 {
12429 if ((opencl_platforms_filter & (1 << i)) == 0) continue;
12430
12431 cl_platform_id CL_platform = CL_platforms[i];
12432
12433 cl_device_id devices_platform[DEVICES_MAX];
12434
12435 cl_uint devices_platform_cnt = 0;
12436
12437 hc_clGetDeviceIDs (CL_platform, device_types_filter, DEVICES_MAX, devices_platform, &devices_platform_cnt);
12438
12439 for (uint j = 0; j < devices_platform_cnt; j++)
12440 {
12441 devices_all[devices_all_cnt] = devices_platform[j];
12442 devices_plf[devices_all_cnt] = j;
12443
12444 devices_all_cnt++;
12445 }
12446 }
12447
12448 /**
12449 * enable custom signal handler(s)
12450 */
12451
12452 if (benchmark == 0)
12453 {
12454 hc_signal (sigHandler_default);
12455 }
12456 else
12457 {
12458 hc_signal (sigHandler_benchmark);
12459 }
12460
12461 /**
12462 * devices mask and properties
12463 */
12464
12465 for (uint device_all_id = 0; device_all_id < devices_all_cnt; device_all_id++)
12466 {
12467 // skip the device, if the user did specify a list of GPUs to skip
12468
12469 if (opencl_devicemask)
12470 {
12471 uint device_all_id_mask = 1 << device_all_id;
12472
12473 if ((device_all_id_mask & opencl_devicemask) != device_all_id_mask)
12474 {
12475 if (quiet == 0 && algorithm_pos == 0) log_info ("Device #%d: skipped by user", device_all_id + 1);
12476
12477 continue;
12478 }
12479 }
12480
12481 const uint device_id = devices_cnt;
12482
12483 devices[device_id] = devices_all[device_all_id];
12484
12485 devices_plf[device_id] = devices_plf[device_all_id];
12486
12487 char device_name[INFOSZ];
12488
12489 memset (device_name, 0, sizeof (device_name));
12490
12491 cl_ulong global_mem_size;
12492 cl_ulong max_mem_alloc_size;
12493 cl_uint max_clock_frequency;
12494 cl_uint max_compute_units;
12495
12496 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_NAME, sizeof (device_name), &device_name, NULL);
12497 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (global_mem_size), &global_mem_size, NULL);
12498 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (max_mem_alloc_size), &max_mem_alloc_size, NULL);
12499 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (max_clock_frequency), &max_clock_frequency, NULL);
12500 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (max_compute_units), &max_compute_units, NULL);
12501
12502 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12503 {
12504 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12505 device_all_id + 1,
12506 device_name,
12507 (unsigned int) (max_mem_alloc_size / 1024 / 1024),
12508 (unsigned int) (global_mem_size / 1024 / 1024),
12509 (unsigned int) (max_clock_frequency),
12510 (unsigned int) max_compute_units);
12511 }
12512
12513 devices_cnt++;
12514 }
12515
12516 if (devices_cnt == 0)
12517 {
12518 log_error ("ERROR: No devices left that matches your specification.");
12519
12520 return (-1);
12521 }
12522
12523 data.devices_cnt = devices_cnt;
12524
12525 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12526 {
12527 log_info ("");
12528 }
12529
12530 /**
12531 * User-defined GPU temp handling
12532 */
12533
12534 if (gpu_temp_disable == 1)
12535 {
12536 gpu_temp_abort = 0;
12537 gpu_temp_retain = 0;
12538 }
12539
12540 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
12541 {
12542 if (gpu_temp_abort < gpu_temp_retain)
12543 {
12544 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
12545
12546 return (-1);
12547 }
12548 }
12549
12550 data.gpu_temp_disable = gpu_temp_disable;
12551 data.gpu_temp_abort = gpu_temp_abort;
12552 data.gpu_temp_retain = gpu_temp_retain;
12553
12554 /**
12555 * inform the user
12556 */
12557
12558 if (data.quiet == 0)
12559 {
12560 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
12561
12562 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);
12563
12564 if (attack_mode == ATTACK_MODE_STRAIGHT)
12565 {
12566 log_info ("Rules: %u", kernel_rules_cnt);
12567 }
12568
12569 if (opti_type)
12570 {
12571 log_info ("Applicable Optimizers:");
12572
12573 for (uint i = 0; i < 32; i++)
12574 {
12575 const uint opti_bit = 1 << i;
12576
12577 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
12578 }
12579 }
12580
12581 /**
12582 * Watchdog and Temperature balance
12583 */
12584
12585 if (gpu_temp_abort == 0)
12586 {
12587 log_info ("Watchdog: Temperature abort trigger disabled");
12588 }
12589 else
12590 {
12591 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
12592 }
12593
12594 if (gpu_temp_retain == 0)
12595 {
12596 log_info ("Watchdog: Temperature retain trigger disabled");
12597 }
12598 else
12599 {
12600 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
12601 }
12602 }
12603
12604 if (data.quiet == 0) log_info ("");
12605
12606 /**
12607 * devices init
12608 */
12609
12610 int *temp_retain_fanspeed_value = (int *) mycalloc (devices_cnt, sizeof (int));
12611
12612 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (devices_cnt, sizeof (ADLOD6MemClockState));
12613
12614 int *od_power_control_status = (int *) mycalloc (devices_cnt, sizeof (int));
12615
12616 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (devices_cnt, sizeof (hc_device_param_t));
12617
12618 data.devices_param = devices_param;
12619
12620 for (uint device_id = 0; device_id < devices_cnt; device_id++)
12621 {
12622 hc_device_param_t *device_param = &data.devices_param[device_id];
12623
12624 cl_device_id device = devices[device_id];
12625
12626 device_param->device = device;
12627
12628 cl_device_type device_type = 0;
12629
12630 hc_clGetDeviceInfo (device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12631
12632 device_param->device_type = device_type;
12633
12634 cl_uint max_compute_units = 0;
12635
12636 hc_clGetDeviceInfo (device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (max_compute_units), &max_compute_units, NULL);
12637
12638 device_param->device_processors = max_compute_units;
12639
12640 cl_ulong max_mem_alloc_size = 0;
12641
12642 hc_clGetDeviceInfo (device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (max_mem_alloc_size), &max_mem_alloc_size, NULL);
12643
12644 device_param->device_maxmem_alloc = max_mem_alloc_size;
12645
12646 cl_uint vendor_id = 0;
12647
12648 hc_clGetDeviceInfo (device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12649
12650 device_param->vendor_id = vendor_id;
12651
12652 char tmp[INFOSZ], t1[64];
12653
12654 memset (tmp, 0, sizeof (tmp));
12655
12656 hc_clGetDeviceInfo (device, CL_DEVICE_NAME, sizeof (tmp), &tmp, NULL);
12657
12658 device_param->device_name = mystrdup (tmp);
12659
12660 memset (tmp, 0, sizeof (tmp));
12661
12662 hc_clGetDeviceInfo (device, CL_DEVICE_VERSION, sizeof (tmp), &tmp, NULL);
12663
12664 if (strstr (tmp, "pocl"))
12665 {
12666 // pocl returns the real AMD vendor_id id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12667 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12668
12669 cl_uint vendor_id = 0xffff;
12670
12671 device_param->vendor_id = vendor_id;
12672 }
12673
12674 memset (t1, 0, sizeof (t1));
12675
12676 sscanf (tmp, "%*16s %*16s %*16s (%[^)]16s)", t1);
12677
12678 device_param->device_version = mystrdup (t1);
12679
12680 memset (tmp, 0, sizeof (tmp));
12681
12682 hc_clGetDeviceInfo (device, CL_DRIVER_VERSION, sizeof (tmp), &tmp, NULL);
12683
12684 device_param->driver_version = mystrdup (tmp);
12685
12686 // create some filename that is easier to read on cached folder
12687
12688 snprintf (tmp, sizeof (tmp) - 1, "%u-%s-%s-%s-%d", device_param->vendor_id, device_param->device_name, device_param->device_version, device_param->driver_version, COMPTIME);
12689
12690 uint device_name_digest[4];
12691
12692 device_name_digest[0] = 0;
12693 device_name_digest[1] = 0;
12694 device_name_digest[2] = 0;
12695 device_name_digest[3] = 0;
12696
12697 md5_64 ((uint *) tmp, device_name_digest);
12698
12699 sprintf (tmp, "%08x", device_name_digest[0]);
12700
12701 device_param->device_name_chksum = mystrdup (tmp);
12702
12703 if (device_type & CL_DEVICE_TYPE_CPU)
12704 {
12705 cl_uint device_processor_cores = 1;
12706
12707 device_param->device_processor_cores = device_processor_cores;
12708 }
12709
12710 if (device_type & CL_DEVICE_TYPE_GPU)
12711 {
12712 if (vendor_id == VENDOR_ID_AMD)
12713 {
12714 cl_uint device_processor_cores = 0;
12715
12716 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12717
12718 hc_clGetDeviceInfo (device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12719
12720 device_param->device_processor_cores = device_processor_cores;
12721 }
12722 else if (vendor_id == VENDOR_ID_NV)
12723 {
12724 cl_uint kernel_exec_timeout = 0;
12725
12726 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12727
12728 hc_clGetDeviceInfo (device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12729
12730 device_param->kernel_exec_timeout = kernel_exec_timeout;
12731
12732 cl_uint device_processor_cores = 0;
12733
12734 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12735
12736 hc_clGetDeviceInfo (device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12737
12738 device_param->device_processor_cores = device_processor_cores;
12739
12740 cl_uint sm_minor = 0;
12741 cl_uint sm_major = 0;
12742
12743 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12744 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12745
12746 hc_clGetDeviceInfo (device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12747 hc_clGetDeviceInfo (device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12748
12749 device_param->sm_minor = sm_minor;
12750 device_param->sm_major = sm_major;
12751 }
12752 else
12753 {
12754 cl_uint device_processor_cores = 1;
12755
12756 device_param->device_processor_cores = device_processor_cores;
12757 }
12758 }
12759
12760 /**
12761 * common driver check
12762 */
12763
12764 if (device_type & CL_DEVICE_TYPE_GPU)
12765 {
12766 if (vendor_id == VENDOR_ID_NV)
12767 {
12768 if (device_param->kernel_exec_timeout != 0)
12769 {
12770 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);
12771 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12772 }
12773 }
12774 else if (vendor_id == VENDOR_ID_AMD)
12775 {
12776 int catalyst_check = (force == 1) ? 0 : 1;
12777
12778 int catalyst_warn = 0;
12779
12780 int catalyst_broken = 0;
12781
12782 if (catalyst_check == 1)
12783 {
12784 catalyst_warn = 1;
12785
12786 // v14.9 and higher
12787 if ((atoi (device_param->device_version) >= 1573)
12788 && (atoi (device_param->driver_version) >= 1573))
12789 {
12790 catalyst_warn = 0;
12791 }
12792
12793 catalyst_check = 0;
12794 }
12795
12796 if (catalyst_broken == 1)
12797 {
12798 log_error ("");
12799 log_error ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12800 log_error ("It will pass over cracked hashes and does not report them as cracked");
12801 log_error ("You are STRONGLY encouraged not to use it");
12802 log_error ("You can use --force to override this but do not post error reports if you do so");
12803
12804 return (-1);
12805 }
12806
12807 if (catalyst_warn == 1)
12808 {
12809 log_error ("");
12810 log_error ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12811 log_error ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12812 log_error ("See oclHashcat's homepage for official supported catalyst drivers");
12813 #ifdef _WIN
12814 log_error ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12815 #endif
12816 log_error ("You can use --force to override this but do not post error reports if you do so");
12817
12818 return (-1);
12819 }
12820 }
12821 }
12822 }
12823
12824 /**
12825 * HM devices: init
12826 */
12827
12828 hm_attrs_t hm_adapters_nv[DEVICES_MAX];
12829 hm_attrs_t hm_adapters_amd[DEVICES_MAX];
12830
12831 memset (hm_adapters_nv, 0, sizeof (hm_adapters_nv));
12832 memset (hm_adapters_amd, 0, sizeof (hm_adapters_amd));
12833
12834 if (gpu_temp_disable == 0)
12835 {
12836 HM_LIB hm_dll_nv = hm_init (VENDOR_ID_NV);
12837
12838 data.hm_dll_nv = hm_dll_nv;
12839
12840 if (hm_dll_nv)
12841 {
12842 #ifdef LINUX
12843 if (hc_NVML_nvmlInit (hm_dll_nv) == NVML_SUCCESS)
12844 {
12845 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX];
12846
12847 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12848
12849 int tmp_out = 0;
12850
12851 for (int i = 0; i < tmp_in; i++)
12852 {
12853 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12854 }
12855
12856 for (int i = 0; i < tmp_out; i++)
12857 {
12858 unsigned int speed;
12859
12860 if (hc_NVML_nvmlDeviceGetFanSpeed (hm_dll_nv, 1, hm_adapters_nv[i].adapter_index.nv, &speed) != NVML_ERROR_NOT_SUPPORTED) hm_adapters_nv[i].fan_supported = 1;
12861 }
12862 }
12863 #endif
12864
12865 #ifdef WIN
12866 if (NvAPI_Initialize () == NVAPI_OK)
12867 {
12868 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX];
12869
12870 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12871
12872 int tmp_out = 0;
12873
12874 for (int i = 0; i < tmp_in; i++)
12875 {
12876 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12877 }
12878
12879 for (int i = 0; i < tmp_out; i++)
12880 {
12881 NvU32 speed;
12882
12883 if (NvAPI_GPU_GetTachReading (hm_adapters_nv[i].adapter_index.nv, &speed) != NVAPI_NOT_SUPPORTED) hm_adapters_nv[i].fan_supported = 1;
12884 }
12885 }
12886 #endif
12887 }
12888
12889 HM_LIB hm_dll_amd = hm_init (VENDOR_ID_AMD);
12890
12891 data.hm_dll_amd = hm_dll_amd;
12892
12893 if (hm_dll_amd)
12894 {
12895 if (hc_ADL_Main_Control_Create (hm_dll_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
12896 {
12897 // total number of adapters
12898
12899 int hm_adapters_num;
12900
12901 if (get_adapters_num_amd (hm_dll_amd, &hm_adapters_num) != 0) return (-1);
12902
12903 // adapter info
12904
12905 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (hm_dll_amd, hm_adapters_num);
12906
12907 if (lpAdapterInfo == NULL) return (-1);
12908
12909 // get a list (of ids of) valid/usable adapters
12910
12911 int num_adl_adapters = 0;
12912
12913 uint32_t *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
12914
12915 if (num_adl_adapters > 0)
12916 {
12917 hc_thread_mutex_lock (mux_adl);
12918
12919 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
12920
12921 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12922
12923 hm_get_overdrive_version (hm_dll_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12924 hm_check_fanspeed_control (hm_dll_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12925
12926 hc_thread_mutex_unlock (mux_adl);
12927 }
12928
12929 myfree (valid_adl_device_list);
12930 myfree (lpAdapterInfo);
12931 }
12932 }
12933 }
12934
12935 /**
12936 * HM devices: copy
12937 */
12938
12939 if (gpu_temp_disable == 0)
12940 {
12941 for (uint device_id = 0; device_id < devices_cnt; device_id++)
12942 {
12943 hc_device_param_t *device_param = &data.devices_param[device_id];
12944
12945 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
12946
12947 cl_uint device_id_on_platform = devices_plf[device_id];
12948
12949 if (device_param->vendor_id == VENDOR_ID_NV)
12950 {
12951 memcpy (&data.hm_device[device_id], &hm_adapters_nv[device_id_on_platform], sizeof (hm_attrs_t));
12952 }
12953
12954 if (device_param->vendor_id == VENDOR_ID_AMD)
12955 {
12956 memcpy (&data.hm_device[device_id], &hm_adapters_amd[device_id_on_platform], sizeof (hm_attrs_t));
12957 }
12958 }
12959 }
12960
12961 /*
12962 * Temporary fix:
12963 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
12964 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
12965 * were not working @ full speed (setting hc_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
12966 * Driver / ADL bug?
12967 */
12968
12969 if (powertune_enable == 1)
12970 {
12971 hc_thread_mutex_lock (mux_adl);
12972
12973 for (uint device_id = 0; device_id < devices_cnt; device_id++)
12974 {
12975 if (data.hm_device[device_id].od_version == 6)
12976 {
12977 // set powertune value only
12978
12979 int powertune_supported = 0;
12980
12981 int ADL_rc = 0;
12982
12983 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
12984 {
12985 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
12986
12987 return (-1);
12988 }
12989
12990 if (powertune_supported != 0)
12991 {
12992 // powertune set
12993 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
12994
12995 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
12996 {
12997 log_error ("ERROR: Failed to get current ADL PowerControl settings");
12998
12999 return (-1);
13000 }
13001
13002 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13003 {
13004 log_error ("ERROR: Failed to set new ADL PowerControl values");
13005
13006 return (-1);
13007 }
13008 }
13009 }
13010 }
13011
13012 hc_thread_mutex_unlock (mux_adl);
13013 }
13014
13015 uint kernel_blocks_all = 0;
13016
13017 for (uint device_id = 0; device_id < devices_cnt; device_id++)
13018 {
13019 /**
13020 * host buffer
13021 */
13022
13023 hc_device_param_t *device_param = &data.devices_param[device_id];
13024
13025 /**
13026 * device properties
13027 */
13028
13029 char *device_name_chksum = device_param->device_name_chksum;
13030
13031 uint device_processors = device_param->device_processors;
13032
13033 uint device_processor_cores = device_param->device_processor_cores;
13034
13035 cl_device_type device_type = device_param->device_type;
13036
13037 /**
13038 * create context for each device
13039 */
13040
13041 device_param->context = hc_clCreateContext (NULL, 1, &device_param->device, NULL, NULL);
13042
13043 /**
13044 * create command-queue
13045 */
13046
13047 // not support with NV
13048 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13049
13050 device_param->command_queue = hc_clCreateCommandQueue (device_param->context, device_param->device, 0);
13051
13052 /**
13053 * create input buffers on device
13054 */
13055
13056 uint kernel_threads = KERNEL_THREADS;
13057
13058 // bcrypt
13059 if (hash_mode == 3200) kernel_threads = 8;
13060 if (hash_mode == 9000) kernel_threads = 8;
13061
13062 if (device_type & CL_DEVICE_TYPE_CPU)
13063 {
13064 // CPU still need lots of workitems, don't know why...
13065 // for testing phase, lets start with this
13066
13067 kernel_accel = 1;
13068 }
13069
13070 uint kernel_power = device_processors * kernel_threads * kernel_accel;
13071 uint kernel_blocks = kernel_power;
13072
13073 device_param->kernel_threads = kernel_threads;
13074 device_param->kernel_power_user = kernel_power;
13075 device_param->kernel_blocks_user = kernel_blocks;
13076
13077 kernel_blocks_all += kernel_blocks;
13078
13079 uint size_pws = kernel_power * sizeof (pw_t);
13080
13081 uint size_tmps = 4;
13082
13083 switch (hash_mode)
13084 {
13085 case 400: size_tmps = kernel_blocks * sizeof (phpass_tmp_t); break;
13086 case 500: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13087 case 501: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13088 case 1600: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13089 case 1800: size_tmps = kernel_blocks * sizeof (sha512crypt_tmp_t); break;
13090 case 2100: size_tmps = kernel_blocks * sizeof (dcc2_tmp_t); break;
13091 case 2500: size_tmps = kernel_blocks * sizeof (wpa_tmp_t); break;
13092 case 3200: size_tmps = kernel_blocks * sizeof (bcrypt_tmp_t); break;
13093 case 5200: size_tmps = kernel_blocks * sizeof (pwsafe3_tmp_t); break;
13094 case 5800: size_tmps = kernel_blocks * sizeof (androidpin_tmp_t); break;
13095 case 6211:
13096 case 6212:
13097 case 6213: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13098 case 6221:
13099 case 6222:
13100 case 6223: size_tmps = kernel_blocks * sizeof (tc64_tmp_t); break;
13101 case 6231:
13102 case 6232:
13103 case 6233: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13104 case 6241:
13105 case 6242:
13106 case 6243: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13107 case 6300: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13108 case 6400: size_tmps = kernel_blocks * sizeof (sha256aix_tmp_t); break;
13109 case 6500: size_tmps = kernel_blocks * sizeof (sha512aix_tmp_t); break;
13110 case 6600: size_tmps = kernel_blocks * sizeof (agilekey_tmp_t); break;
13111 case 6700: size_tmps = kernel_blocks * sizeof (sha1aix_tmp_t); break;
13112 case 6800: size_tmps = kernel_blocks * sizeof (lastpass_tmp_t); break;
13113 case 7100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13114 case 7200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13115 case 7400: size_tmps = kernel_blocks * sizeof (sha256crypt_tmp_t); break;
13116 case 7900: size_tmps = kernel_blocks * sizeof (drupal7_tmp_t); break;
13117 case 8200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13118 case 8800: size_tmps = kernel_blocks * sizeof (androidfde_tmp_t); break;
13119 case 8900: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13120 case 9000: size_tmps = kernel_blocks * sizeof (pwsafe2_tmp_t); break;
13121 case 9100: size_tmps = kernel_blocks * sizeof (lotus8_tmp_t); break;
13122 case 9200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13123 case 9300: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13124 case 9400: size_tmps = kernel_blocks * sizeof (office2007_tmp_t); break;
13125 case 9500: size_tmps = kernel_blocks * sizeof (office2010_tmp_t); break;
13126 case 9600: size_tmps = kernel_blocks * sizeof (office2013_tmp_t); break;
13127 case 10000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13128 case 10200: size_tmps = kernel_blocks * sizeof (cram_md5_t); break;
13129 case 10300: size_tmps = kernel_blocks * sizeof (saph_sha1_tmp_t); break;
13130 case 10500: size_tmps = kernel_blocks * sizeof (pdf14_tmp_t); break;
13131 case 10700: size_tmps = kernel_blocks * sizeof (pdf17l8_tmp_t); break;
13132 case 10900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13133 case 11300: size_tmps = kernel_blocks * sizeof (bitcoin_wallet_tmp_t); break;
13134 case 11600: size_tmps = kernel_blocks * sizeof (seven_zip_tmp_t); break;
13135 case 11900: size_tmps = kernel_blocks * sizeof (pbkdf2_md5_tmp_t); break;
13136 case 12000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha1_tmp_t); break;
13137 case 12100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13138 case 12200: size_tmps = kernel_blocks * sizeof (ecryptfs_tmp_t); break;
13139 case 12300: size_tmps = kernel_blocks * sizeof (oraclet_tmp_t); break;
13140 case 12400: size_tmps = kernel_blocks * sizeof (bsdicrypt_tmp_t); break;
13141 case 12500: size_tmps = kernel_blocks * sizeof (rar3_tmp_t); break;
13142 case 12700: size_tmps = kernel_blocks * sizeof (mywallet_tmp_t); break;
13143 case 12800: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13144 case 12900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13145 case 13000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13146 };
13147
13148 uint size_hooks = 4;
13149
13150 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13151 {
13152 // insert correct hook size
13153 }
13154
13155 // we can optimize some stuff here...
13156
13157 device_param->size_pws = size_pws;
13158 device_param->size_tmps = size_tmps;
13159 device_param->size_hooks = size_hooks;
13160
13161 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13162 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13163
13164 device_param->size_root_css = size_root_css;
13165 device_param->size_markov_css = size_markov_css;
13166
13167 uint size_results = KERNEL_THREADS * sizeof (uint);
13168
13169 device_param->size_results = size_results;
13170
13171 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13172 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13173
13174 uint size_plains = digests_cnt * sizeof (plain_t);
13175 uint size_salts = salts_cnt * sizeof (salt_t);
13176 uint size_esalts = salts_cnt * esalt_size;
13177
13178 device_param->size_plains = size_plains;
13179 device_param->size_digests = size_digests;
13180 device_param->size_shown = size_shown;
13181 device_param->size_salts = size_salts;
13182
13183 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13184 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13185 uint size_tm = 32 * sizeof (bs_word_t);
13186
13187 uint64_t size_scryptV = 1;
13188
13189 if ((hash_mode == 8900) || (hash_mode == 9300))
13190 {
13191 uint tmto_start = 0;
13192 uint tmto_stop = 10;
13193
13194 if (scrypt_tmto)
13195 {
13196 tmto_start = scrypt_tmto;
13197 }
13198 else
13199 {
13200 // in case the user did not specify the tmto manually
13201 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13202 // but set the lower end only in case the user has a device with too less memory
13203
13204 if (hash_mode == 8900)
13205 {
13206 if (device_param->vendor_id == VENDOR_ID_AMD)
13207 {
13208 tmto_start = 1;
13209 }
13210 else if (device_param->vendor_id == VENDOR_ID_NV)
13211 {
13212 tmto_start = 3;
13213 }
13214 }
13215 else if (hash_mode == 9300)
13216 {
13217 if (device_param->vendor_id == VENDOR_ID_AMD)
13218 {
13219 tmto_start = 3;
13220 }
13221 else if (device_param->vendor_id == VENDOR_ID_NV)
13222 {
13223 tmto_start = 5;
13224 }
13225 }
13226 }
13227
13228 if (quiet == 0) log_info ("");
13229
13230 uint shader_per_mp = 1;
13231
13232 if (device_param->vendor_id == VENDOR_ID_AMD)
13233 {
13234 shader_per_mp = 8;
13235 }
13236 else if (device_param->vendor_id == VENDOR_ID_NV)
13237 {
13238 shader_per_mp = 32;
13239 }
13240
13241 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13242 {
13243 // TODO: in theory the following calculation needs to be done per salt, not global
13244 // we assume all hashes have the same scrypt settings
13245
13246 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13247
13248 size_scryptV /= 1 << tmto;
13249
13250 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13251
13252 if (size_scryptV > device_param->device_maxmem_alloc)
13253 {
13254 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13255
13256 continue;
13257 }
13258
13259 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13260 {
13261 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13262 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13263 }
13264
13265 break;
13266 }
13267
13268 if (data.salts_buf[0].scrypt_phy == 0)
13269 {
13270 log_error ("ERROR: can't allocate enough device memory");
13271
13272 return -1;
13273 }
13274
13275 if (quiet == 0) log_info ("");
13276 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13277 }
13278
13279 /**
13280 * default building options
13281 */
13282
13283 char build_opts[1024];
13284
13285 // we don't have sm_* on vendors not NV but it doesn't matter
13286
13287 sprintf (build_opts, "-I%s/ -DVENDOR_ID=%d -DCUDA_ARCH=%d", shared_dir, device_param->vendor_id, (device_param->sm_major * 100) + device_param->sm_minor);
13288
13289 /**
13290 * a0 kernel, required for some fast hashes to make weak_hash_check work
13291 */
13292
13293 const uint add_flag = OPTS_TYPE_PT_ADD01
13294 | OPTS_TYPE_PT_ADD02
13295 | OPTS_TYPE_PT_ADD80
13296 | OPTS_TYPE_PT_ADDBITS14
13297 | OPTS_TYPE_PT_ADDBITS15
13298 | OPTS_TYPE_ST_ADD01
13299 | OPTS_TYPE_ST_ADD02
13300 | OPTS_TYPE_ST_ADD80
13301 | OPTS_TYPE_ST_ADDBITS14
13302 | OPTS_TYPE_ST_ADDBITS15;
13303
13304 if ((weak_hash_threshold) && (attack_exec == ATTACK_EXEC_INSIDE_KERNEL) && (opts_type & add_flag))
13305 {
13306 /**
13307 * kernel source filename
13308 */
13309
13310 char source_file[256];
13311
13312 memset (source_file, 0, sizeof (source_file));
13313
13314 generate_source_kernel_filename (attack_exec, ATTACK_KERN_STRAIGHT, kern_type, shared_dir, source_file);
13315
13316 struct stat sst;
13317
13318 if (stat (source_file, &sst) == -1)
13319 {
13320 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13321
13322 return -1;
13323 }
13324
13325 /**
13326 * kernel cached filename
13327 */
13328
13329 char cached_file[256];
13330
13331 memset (cached_file, 0, sizeof (cached_file));
13332
13333 generate_cached_kernel_filename (attack_exec, ATTACK_KERN_STRAIGHT, kern_type, profile_dir, device_name_chksum, cached_file);
13334
13335 int cached = 1;
13336
13337 struct stat cst;
13338
13339 if (stat (cached_file, &cst) == -1)
13340 {
13341 cached = 0;
13342 }
13343
13344 /**
13345 * kernel compile or load
13346 */
13347
13348 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13349
13350 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13351
13352 if (force_jit_compilation == 0)
13353 {
13354 if (cached == 0)
13355 {
13356 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13357
13358 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13359
13360 device_param->program_weak = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13361
13362 hc_clBuildProgram (device_param->program_weak, 1, &device_param->device, build_opts, NULL, NULL);
13363
13364 size_t binary_size;
13365
13366 clGetProgramInfo (device_param->program_weak, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13367
13368 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13369
13370 clGetProgramInfo (device_param->program_weak, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13371
13372 writeProgramBin (cached_file, binary, binary_size);
13373
13374 local_free (binary);
13375 }
13376 else
13377 {
13378 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13379
13380 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13381
13382 device_param->program_weak = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13383
13384 hc_clBuildProgram (device_param->program_weak, 1, &device_param->device, build_opts, NULL, NULL);
13385 }
13386 }
13387 else
13388 {
13389 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13390
13391 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13392
13393 device_param->program_weak = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13394
13395 if (force_jit_compilation == 1500)
13396 {
13397 sprintf (build_opts, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13398 }
13399 else if (force_jit_compilation == 8900)
13400 {
13401 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);
13402 }
13403
13404 hc_clBuildProgram (device_param->program_weak, 1, &device_param->device, build_opts, NULL, NULL);
13405 }
13406
13407 local_free (kernel_lengths);
13408 local_free (kernel_sources[0]);
13409 local_free (kernel_sources);
13410
13411 // this is mostly for debug
13412
13413 size_t ret_val_size = 0;
13414
13415 clGetProgramBuildInfo (device_param->program_weak, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13416
13417 if (ret_val_size > 2)
13418 {
13419 char *build_log = (char *) mymalloc (ret_val_size + 1);
13420
13421 memset (build_log, 0, ret_val_size + 1);
13422
13423 clGetProgramBuildInfo (device_param->program_weak, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13424
13425 puts (build_log);
13426
13427 myfree (build_log);
13428 }
13429 }
13430
13431 /**
13432 * main kernel
13433 */
13434
13435 {
13436 /**
13437 * kernel source filename
13438 */
13439
13440 char source_file[256];
13441
13442 memset (source_file, 0, sizeof (source_file));
13443
13444 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13445
13446 struct stat sst;
13447
13448 if (stat (source_file, &sst) == -1)
13449 {
13450 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13451
13452 return -1;
13453 }
13454
13455 /**
13456 * kernel cached filename
13457 */
13458
13459 char cached_file[256];
13460
13461 memset (cached_file, 0, sizeof (cached_file));
13462
13463 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13464
13465 int cached = 1;
13466
13467 struct stat cst;
13468
13469 if (stat (cached_file, &cst) == -1)
13470 {
13471 cached = 0;
13472 }
13473
13474 /**
13475 * kernel compile or load
13476 */
13477
13478 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13479
13480 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13481
13482 if (force_jit_compilation == 0)
13483 {
13484 if (cached == 0)
13485 {
13486 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13487
13488 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13489
13490 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13491
13492 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13493
13494 size_t binary_size;
13495
13496 clGetProgramInfo (device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13497
13498 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13499
13500 clGetProgramInfo (device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13501
13502 writeProgramBin (cached_file, binary, binary_size);
13503
13504 local_free (binary);
13505 }
13506 else
13507 {
13508 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13509
13510 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13511
13512 device_param->program = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13513
13514 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13515 }
13516 }
13517 else
13518 {
13519 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13520
13521 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13522
13523 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13524
13525 if (force_jit_compilation == 1500)
13526 {
13527 sprintf (build_opts, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13528 }
13529 else if (force_jit_compilation == 8900)
13530 {
13531 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);
13532 }
13533
13534 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13535 }
13536
13537 local_free (kernel_lengths);
13538 local_free (kernel_sources[0]);
13539 local_free (kernel_sources);
13540
13541 // this is mostly for debug
13542
13543 size_t ret_val_size = 0;
13544
13545 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13546
13547 if (ret_val_size > 2)
13548 {
13549 char *build_log = (char *) mymalloc (ret_val_size + 1);
13550
13551 memset (build_log, 0, ret_val_size + 1);
13552
13553 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13554
13555 puts (build_log);
13556
13557 myfree (build_log);
13558 }
13559 }
13560
13561 /**
13562 * word generator kernel
13563 */
13564
13565 if (attack_mode != ATTACK_MODE_STRAIGHT)
13566 {
13567 /**
13568 * kernel mp source filename
13569 */
13570
13571 char source_file[256];
13572
13573 memset (source_file, 0, sizeof (source_file));
13574
13575 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
13576
13577 struct stat sst;
13578
13579 if (stat (source_file, &sst) == -1)
13580 {
13581 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13582
13583 return -1;
13584 }
13585
13586 /**
13587 * kernel mp cached filename
13588 */
13589
13590 char cached_file[256];
13591
13592 memset (cached_file, 0, sizeof (cached_file));
13593
13594 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
13595
13596 int cached = 1;
13597
13598 struct stat cst;
13599
13600 if (stat (cached_file, &cst) == -1)
13601 {
13602 cached = 0;
13603 }
13604
13605 /**
13606 * kernel compile or load
13607 */
13608
13609 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13610
13611 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13612
13613 if (cached == 0)
13614 {
13615 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13616
13617 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13618
13619 device_param->program_mp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13620
13621 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13622
13623 size_t binary_size;
13624
13625 clGetProgramInfo (device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13626
13627 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13628
13629 clGetProgramInfo (device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13630
13631 writeProgramBin (cached_file, binary, binary_size);
13632
13633 local_free (binary);
13634 }
13635 else
13636 {
13637 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13638
13639 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13640
13641 device_param->program_mp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13642
13643 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13644 }
13645
13646 local_free (kernel_lengths);
13647 local_free (kernel_sources[0]);
13648 local_free (kernel_sources);
13649
13650 // this is mostly for debug
13651
13652 size_t ret_val_size = 0;
13653
13654 clGetProgramBuildInfo (device_param->program_mp, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13655
13656 if (ret_val_size > 2)
13657 {
13658 char *build_log = (char *) mymalloc (ret_val_size + 1);
13659
13660 memset (build_log, 0, ret_val_size + 1);
13661
13662 clGetProgramBuildInfo (device_param->program_mp, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13663
13664 puts (build_log);
13665
13666 myfree (build_log);
13667 }
13668 }
13669
13670 /**
13671 * amplifier kernel
13672 */
13673
13674 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13675 {
13676
13677 }
13678 else
13679 {
13680 /**
13681 * kernel amp source filename
13682 */
13683
13684 char source_file[256];
13685
13686 memset (source_file, 0, sizeof (source_file));
13687
13688 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
13689
13690 struct stat sst;
13691
13692 if (stat (source_file, &sst) == -1)
13693 {
13694 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13695
13696 return -1;
13697 }
13698
13699 /**
13700 * kernel amp cached filename
13701 */
13702
13703 char cached_file[256];
13704
13705 memset (cached_file, 0, sizeof (cached_file));
13706
13707 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
13708
13709 int cached = 1;
13710
13711 struct stat cst;
13712
13713 if (stat (cached_file, &cst) == -1)
13714 {
13715 cached = 0;
13716 }
13717
13718 /**
13719 * kernel compile or load
13720 */
13721
13722 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13723
13724 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13725
13726 if (cached == 0)
13727 {
13728 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13729
13730 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13731
13732 device_param->program_amp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13733
13734 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13735
13736 size_t binary_size;
13737
13738 clGetProgramInfo (device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13739
13740 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13741
13742 clGetProgramInfo (device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13743
13744 writeProgramBin (cached_file, binary, binary_size);
13745
13746 local_free (binary);
13747 }
13748 else
13749 {
13750 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13751
13752 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13753
13754 device_param->program_amp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13755
13756 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13757 }
13758
13759 local_free (kernel_lengths);
13760 local_free (kernel_sources[0]);
13761 local_free (kernel_sources);
13762
13763 // this is mostly for debug
13764
13765 size_t ret_val_size = 0;
13766
13767 clGetProgramBuildInfo (device_param->program_amp, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13768
13769 if (ret_val_size > 2)
13770 {
13771 char *build_log = (char *) mymalloc (ret_val_size + 1);
13772
13773 memset (build_log, 0, ret_val_size + 1);
13774
13775 clGetProgramBuildInfo (device_param->program_amp, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13776
13777 puts (build_log);
13778
13779 myfree (build_log);
13780 }
13781 }
13782
13783 /**
13784 * global buffers
13785 */
13786
13787 device_param->d_pws_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13788 device_param->d_pws_amp_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13789 device_param->d_rules_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL); // we need this for weak-hash-check even if the user has choosen for ex: -a 3
13790 device_param->d_tmps = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
13791 device_param->d_hooks = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
13792 device_param->d_bitmap_s1_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13793 device_param->d_bitmap_s1_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13794 device_param->d_bitmap_s1_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13795 device_param->d_bitmap_s1_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13796 device_param->d_bitmap_s2_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13797 device_param->d_bitmap_s2_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13798 device_param->d_bitmap_s2_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13799 device_param->d_bitmap_s2_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13800 device_param->d_plain_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
13801 device_param->d_digests_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
13802 device_param->d_digests_shown = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
13803 device_param->d_salt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
13804 device_param->d_result = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
13805 device_param->d_scryptV_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
13806
13807 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_a, CL_TRUE, 0, bitmap_size, bitmap_s1_a, 0, NULL, NULL);
13808 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_b, CL_TRUE, 0, bitmap_size, bitmap_s1_b, 0, NULL, NULL);
13809 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_c, CL_TRUE, 0, bitmap_size, bitmap_s1_c, 0, NULL, NULL);
13810 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_d, CL_TRUE, 0, bitmap_size, bitmap_s1_d, 0, NULL, NULL);
13811 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_a, CL_TRUE, 0, bitmap_size, bitmap_s2_a, 0, NULL, NULL);
13812 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_b, CL_TRUE, 0, bitmap_size, bitmap_s2_b, 0, NULL, NULL);
13813 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_c, CL_TRUE, 0, bitmap_size, bitmap_s2_c, 0, NULL, NULL);
13814 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_d, CL_TRUE, 0, bitmap_size, bitmap_s2_d, 0, NULL, NULL);
13815 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
13816 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
13817 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
13818
13819 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
13820 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
13821 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
13822 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
13823 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
13824 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
13825 run_kernel_bzero (device_param, device_param->d_result, size_results);
13826
13827 /**
13828 * special buffers
13829 */
13830
13831 if (attack_kern == ATTACK_KERN_STRAIGHT)
13832 {
13833 device_param->d_rules = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
13834
13835 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
13836 }
13837 else if (attack_kern == ATTACK_KERN_COMBI)
13838 {
13839 device_param->d_combs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13840 device_param->d_combs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13841 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13842 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13843
13844 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
13845 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
13846 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13847 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13848 }
13849 else if (attack_kern == ATTACK_KERN_BF)
13850 {
13851 device_param->d_bfs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13852 device_param->d_bfs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13853 device_param->d_tm_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
13854 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13855 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13856
13857 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
13858 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
13859 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
13860 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13861 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13862 }
13863
13864 if (size_esalts)
13865 {
13866 device_param->d_esalt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
13867
13868 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
13869 }
13870
13871 /**
13872 * main host data
13873 */
13874
13875 uint *result = (uint *) mymalloc (size_results);
13876
13877 memset (result, 0, size_results);
13878
13879 device_param->result = result;
13880
13881 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
13882
13883 memset (pws_buf, 0, size_pws);
13884
13885 device_param->pws_buf = pws_buf;
13886
13887 pw_cache_t *pw_caches = (pw_cache_t *) mycalloc (64, sizeof (pw_cache_t));
13888
13889 for (int i = 0; i < 64; i++)
13890 {
13891 pw_caches[i].pw_buf.pw_len = i;
13892 pw_caches[i].cnt = 0;
13893 }
13894
13895 device_param->pw_caches = pw_caches;
13896
13897 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
13898
13899 device_param->combs_buf = combs_buf;
13900
13901 void *hooks_buf = mymalloc (size_hooks);
13902
13903 device_param->hooks_buf = hooks_buf;
13904
13905 device_param->pw_transpose = pw_transpose_to_hi1;
13906 device_param->pw_add = pw_add_to_hc1;
13907
13908 /**
13909 * kernel args
13910 */
13911
13912 device_param->kernel_params_buf32[21] = bitmap_mask;
13913 device_param->kernel_params_buf32[22] = bitmap_shift1;
13914 device_param->kernel_params_buf32[23] = bitmap_shift2;
13915 device_param->kernel_params_buf32[24] = 0; // salt_pos
13916 device_param->kernel_params_buf32[25] = 0; // loop_pos
13917 device_param->kernel_params_buf32[26] = 0; // loop_cnt
13918 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
13919 device_param->kernel_params_buf32[28] = 0; // digests_cnt
13920 device_param->kernel_params_buf32[29] = 0; // digests_offset
13921 device_param->kernel_params_buf32[30] = 0; // combs_mode
13922 device_param->kernel_params_buf32[31] = 0; // gid_max
13923
13924 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13925 ? &device_param->d_pws_buf
13926 : &device_param->d_pws_amp_buf;
13927 device_param->kernel_params[ 1] = &device_param->d_rules_c;
13928 device_param->kernel_params[ 2] = &device_param->d_combs_c;
13929 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
13930 device_param->kernel_params[ 4] = &device_param->d_tmps;
13931 device_param->kernel_params[ 5] = &device_param->d_hooks;
13932 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
13933 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
13934 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
13935 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
13936 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
13937 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
13938 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
13939 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
13940 device_param->kernel_params[14] = &device_param->d_plain_bufs;
13941 device_param->kernel_params[15] = &device_param->d_digests_buf;
13942 device_param->kernel_params[16] = &device_param->d_digests_shown;
13943 device_param->kernel_params[17] = &device_param->d_salt_bufs;
13944 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
13945 device_param->kernel_params[19] = &device_param->d_result;
13946 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
13947 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
13948 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
13949 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
13950 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
13951 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
13952 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
13953 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
13954 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
13955 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
13956 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
13957 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
13958
13959 device_param->kernel_params_mp_buf64[3] = 0;
13960 device_param->kernel_params_mp_buf32[4] = 0;
13961 device_param->kernel_params_mp_buf32[5] = 0;
13962 device_param->kernel_params_mp_buf32[6] = 0;
13963 device_param->kernel_params_mp_buf32[7] = 0;
13964 device_param->kernel_params_mp_buf32[8] = 0;
13965
13966 device_param->kernel_params_mp[0] = NULL;
13967 device_param->kernel_params_mp[1] = NULL;
13968 device_param->kernel_params_mp[2] = NULL;
13969 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
13970 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
13971 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
13972 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
13973 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
13974 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
13975
13976 device_param->kernel_params_mp_l_buf64[3] = 0;
13977 device_param->kernel_params_mp_l_buf32[4] = 0;
13978 device_param->kernel_params_mp_l_buf32[5] = 0;
13979 device_param->kernel_params_mp_l_buf32[6] = 0;
13980 device_param->kernel_params_mp_l_buf32[7] = 0;
13981 device_param->kernel_params_mp_l_buf32[8] = 0;
13982 device_param->kernel_params_mp_l_buf32[9] = 0;
13983
13984 device_param->kernel_params_mp_l[0] = NULL;
13985 device_param->kernel_params_mp_l[1] = NULL;
13986 device_param->kernel_params_mp_l[2] = NULL;
13987 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
13988 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
13989 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
13990 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
13991 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
13992 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
13993 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
13994
13995 device_param->kernel_params_mp_r_buf64[3] = 0;
13996 device_param->kernel_params_mp_r_buf32[4] = 0;
13997 device_param->kernel_params_mp_r_buf32[5] = 0;
13998 device_param->kernel_params_mp_r_buf32[6] = 0;
13999 device_param->kernel_params_mp_r_buf32[7] = 0;
14000 device_param->kernel_params_mp_r_buf32[8] = 0;
14001
14002 device_param->kernel_params_mp_r[0] = NULL;
14003 device_param->kernel_params_mp_r[1] = NULL;
14004 device_param->kernel_params_mp_r[2] = NULL;
14005 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14006 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14007 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14008 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14009 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14010 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14011
14012 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14013 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14014
14015 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14016 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14017 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14018 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14019 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14020 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14021 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14022
14023 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
14024
14025 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14026 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14027
14028 /**
14029 * kernel name
14030 */
14031
14032 char kernel_name[64];
14033
14034 memset (kernel_name, 0, sizeof (kernel_name));
14035
14036 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14037 {
14038 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14039 {
14040 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14041
14042 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
14043
14044 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14045
14046 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
14047
14048 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14049
14050 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
14051 }
14052 else
14053 {
14054 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14055
14056 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
14057
14058 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14059
14060 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
14061
14062 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14063
14064 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
14065 }
14066
14067 if (weak_hash_threshold)
14068 {
14069 if (opts_type & add_flag)
14070 {
14071 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14072 {
14073 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14074
14075 device_param->kernel_weak = hc_clCreateKernel (device_param->program_weak, kernel_name);
14076 }
14077 else
14078 {
14079 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14080
14081 device_param->kernel_weak = hc_clCreateKernel (device_param->program_weak, kernel_name);
14082 }
14083 }
14084 else
14085 {
14086 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14087 {
14088 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14089
14090 device_param->kernel_weak = hc_clCreateKernel (device_param->program, kernel_name);
14091 }
14092 else
14093 {
14094 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14095
14096 device_param->kernel_weak = hc_clCreateKernel (device_param->program, kernel_name);
14097 }
14098 }
14099 }
14100
14101 if (data.attack_mode == ATTACK_MODE_BF)
14102 {
14103 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14104 {
14105 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
14106
14107 device_param->kernel_tb = hc_clCreateKernel (device_param->program, kernel_name);
14108
14109 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14110
14111 device_param->kernel_tm = hc_clCreateKernel (device_param->program, kernel_name);
14112 }
14113 }
14114 }
14115 else
14116 {
14117 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14118
14119 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
14120
14121 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14122
14123 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
14124
14125 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14126
14127 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
14128
14129 if (opts_type & OPTS_TYPE_HOOK12)
14130 {
14131 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14132
14133 device_param->kernel12 = hc_clCreateKernel (device_param->program, kernel_name);
14134 }
14135
14136 if (opts_type & OPTS_TYPE_HOOK23)
14137 {
14138 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14139
14140 device_param->kernel23 = hc_clCreateKernel (device_param->program, kernel_name);
14141 }
14142 }
14143
14144 for (uint i = 0; i <= 20; i++)
14145 {
14146 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14147 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14148 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14149
14150 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14151 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14152
14153 if (weak_hash_threshold)
14154 {
14155 hc_clSetKernelArg (device_param->kernel_weak, i, sizeof (cl_mem), device_param->kernel_params[i]);
14156 }
14157 }
14158
14159 for (uint i = 21; i <= 31; i++)
14160 {
14161 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14162 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14163 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14164
14165 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14166 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14167
14168 if (weak_hash_threshold)
14169 {
14170 hc_clSetKernelArg (device_param->kernel_weak, i, sizeof (cl_uint), device_param->kernel_params[i]);
14171 }
14172 }
14173
14174 if (attack_mode == ATTACK_MODE_BF)
14175 {
14176 device_param->kernel_mp_l = hc_clCreateKernel (device_param->program_mp, "l_markov");
14177 device_param->kernel_mp_r = hc_clCreateKernel (device_param->program_mp, "r_markov");
14178
14179 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14180 {
14181 hc_clSetKernelArg (device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
14182
14183 hc_clSetKernelArg (device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14184 hc_clSetKernelArg (device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14185 }
14186 }
14187 else if (attack_mode == ATTACK_MODE_HYBRID1)
14188 {
14189 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
14190 }
14191 else if (attack_mode == ATTACK_MODE_HYBRID2)
14192 {
14193 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
14194 }
14195
14196 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14197 {
14198 // nothing to do
14199 }
14200 else
14201 {
14202 device_param->kernel_amp = hc_clCreateKernel (device_param->program_amp, "amp");
14203 }
14204
14205 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14206 {
14207 // nothing to do
14208 }
14209 else
14210 {
14211 for (uint i = 0; i < 5; i++)
14212 {
14213 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14214 }
14215
14216 for (uint i = 5; i < 7; i++)
14217 {
14218 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14219 }
14220 }
14221
14222 /**
14223 * Store initial fanspeed if gpu_temp_retain is enabled
14224 */
14225
14226 int gpu_temp_retain_set = 0;
14227
14228 if (gpu_temp_disable == 0)
14229 {
14230 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14231 {
14232 hc_thread_mutex_lock (mux_adl);
14233
14234 if (data.hm_device[device_id].fan_supported == 1)
14235 {
14236 if (gpu_temp_retain_chgd == 0)
14237 {
14238 uint cur_temp = 0;
14239 uint default_temp = 0;
14240
14241 int ADL_rc = hc_ADL_Overdrive6_TargetTemperatureData_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, (int *) &cur_temp, (int *) &default_temp);
14242
14243 if (ADL_rc == ADL_OK)
14244 {
14245 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14246
14247 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14248
14249 // special case with multi gpu setups: always use minimum retain
14250
14251 if (gpu_temp_retain_set == 0)
14252 {
14253 gpu_temp_retain = gpu_temp_retain_target;
14254 gpu_temp_retain_set = 1;
14255 }
14256 else
14257 {
14258 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14259 }
14260
14261 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14262 }
14263 }
14264
14265 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14266
14267 temp_retain_fanspeed_value[device_id] = fan_speed;
14268
14269 if (fan_speed == -1)
14270 {
14271 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14272
14273 temp_retain_fanspeed_value[device_id] = 0;
14274 }
14275 }
14276
14277 hc_thread_mutex_unlock (mux_adl);
14278 }
14279 }
14280
14281 /**
14282 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14283 */
14284
14285 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14286 {
14287 hc_thread_mutex_lock (mux_adl);
14288
14289 if (data.hm_device[device_id].od_version == 6)
14290 {
14291 int ADL_rc;
14292
14293 // check powertune capabilities first, if not available then skip device
14294
14295 int powertune_supported = 0;
14296
14297 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14298 {
14299 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14300
14301 return (-1);
14302 }
14303
14304 if (powertune_supported != 0)
14305 {
14306 // powercontrol settings
14307
14308 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14309
14310 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14311 {
14312 ADL_rc = hc_ADL_Overdrive_PowerControl_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14313 }
14314
14315 if (ADL_rc != ADL_OK)
14316 {
14317 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14318
14319 return (-1);
14320 }
14321
14322 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14323 {
14324 log_error ("ERROR: Failed to set new ADL PowerControl values");
14325
14326 return (-1);
14327 }
14328
14329 // clocks
14330
14331 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14332
14333 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14334
14335 if ((ADL_rc = hc_ADL_Overdrive_StateInfo_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_GETSTATEINFO_CUSTOM_PERFORMANCE, &od_clock_mem_status[device_id])) != ADL_OK)
14336 {
14337 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14338
14339 return (-1);
14340 }
14341
14342 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14343
14344 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14345
14346 if ((ADL_rc = hc_ADL_Overdrive_Capabilities_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14347 {
14348 log_error ("ERROR: Failed to get ADL device capabilities");
14349
14350 return (-1);
14351 }
14352
14353 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14354 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14355
14356 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14357 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14358
14359 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14360 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14361
14362 // warning if profile has to low max values
14363
14364 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14365 {
14366 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14367 }
14368
14369 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14370 {
14371 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14372 }
14373
14374 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14375
14376 performance_state->iNumberOfPerformanceLevels = 2;
14377
14378 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14379 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14380 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14381 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14382
14383 if ((ADL_rc = hc_ADL_Overdrive_State_Set (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
14384 {
14385 log_info ("ERROR: Failed to set ADL performance state");
14386
14387 return (-1);
14388 }
14389
14390 local_free (performance_state);
14391 }
14392 }
14393
14394 hc_thread_mutex_unlock (mux_adl);
14395 }
14396 }
14397
14398 data.kernel_blocks_all = kernel_blocks_all;
14399
14400 if (data.quiet == 0) log_info ("");
14401
14402 /**
14403 * Inform user which algorithm is checked and at which workload setting
14404 */
14405
14406 if (benchmark == 1)
14407 {
14408 quiet = 0;
14409
14410 data.quiet = quiet;
14411
14412 char *hash_type = strhashtype (data.hash_mode); // not a bug
14413
14414 log_info ("Hashtype: %s", hash_type);
14415 log_info ("Workload: %u loops, %u accel", kernel_loops, kernel_accel);
14416 log_info ("");
14417 }
14418
14419 /**
14420 * keep track of the progress
14421 */
14422
14423 data.words_progress_done = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
14424 data.words_progress_rejected = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
14425 data.words_progress_restored = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
14426
14427 /**
14428 * open filehandles
14429 */
14430
14431 #if _WIN
14432 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14433 {
14434 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14435
14436 return (-1);
14437 }
14438
14439 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14440 {
14441 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14442
14443 return (-1);
14444 }
14445
14446 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14447 {
14448 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14449
14450 return (-1);
14451 }
14452 #endif
14453
14454 /**
14455 * dictionary pad
14456 */
14457
14458 segment_size *= (1024 * 1024);
14459
14460 data.segment_size = segment_size;
14461
14462 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14463
14464 wl_data->buf = (char *) mymalloc (segment_size);
14465 wl_data->avail = segment_size;
14466 wl_data->incr = segment_size;
14467 wl_data->cnt = 0;
14468 wl_data->pos = 0;
14469
14470 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14471
14472 data.wordlist_mode = wordlist_mode;
14473
14474 cs_t *css_buf = NULL;
14475 uint css_cnt = 0;
14476 uint dictcnt = 0;
14477 uint maskcnt = 1;
14478 char **masks = NULL;
14479 char **dictfiles = NULL;
14480
14481 uint mask_from_file = 0;
14482
14483 if (attack_mode == ATTACK_MODE_STRAIGHT)
14484 {
14485 if (wordlist_mode == WL_MODE_FILE)
14486 {
14487 int wls_left = myargc - (optind + 1);
14488
14489 for (int i = 0; i < wls_left; i++)
14490 {
14491 char *l0_filename = myargv[optind + 1 + i];
14492
14493 struct stat l0_stat;
14494
14495 if (stat (l0_filename, &l0_stat) == -1)
14496 {
14497 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14498
14499 return (-1);
14500 }
14501
14502 uint is_dir = S_ISDIR (l0_stat.st_mode);
14503
14504 if (is_dir == 0)
14505 {
14506 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14507
14508 dictcnt++;
14509
14510 dictfiles[dictcnt - 1] = l0_filename;
14511 }
14512 else
14513 {
14514 // do not allow --keyspace w/ a directory
14515
14516 if (keyspace == 1)
14517 {
14518 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14519
14520 return (-1);
14521 }
14522
14523 char **dictionary_files = NULL;
14524
14525 dictionary_files = scan_directory (l0_filename);
14526
14527 if (dictionary_files != NULL)
14528 {
14529 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14530
14531 for (int d = 0; dictionary_files[d] != NULL; d++)
14532 {
14533 char *l1_filename = dictionary_files[d];
14534
14535 struct stat l1_stat;
14536
14537 if (stat (l1_filename, &l1_stat) == -1)
14538 {
14539 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14540
14541 return (-1);
14542 }
14543
14544 if (S_ISREG (l1_stat.st_mode))
14545 {
14546 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14547
14548 dictcnt++;
14549
14550 dictfiles[dictcnt - 1] = strdup (l1_filename);
14551 }
14552 }
14553 }
14554
14555 local_free (dictionary_files);
14556 }
14557 }
14558
14559 if (dictcnt < 1)
14560 {
14561 log_error ("ERROR: No usable dictionary file found.");
14562
14563 return (-1);
14564 }
14565 }
14566 else if (wordlist_mode == WL_MODE_STDIN)
14567 {
14568 dictcnt = 1;
14569 }
14570 }
14571 else if (attack_mode == ATTACK_MODE_COMBI)
14572 {
14573 // display
14574
14575 char *dictfile1 = myargv[optind + 1 + 0];
14576 char *dictfile2 = myargv[optind + 1 + 1];
14577
14578 // find the bigger dictionary and use as base
14579
14580 FILE *fp1;
14581 FILE *fp2;
14582
14583 struct stat tmp_stat;
14584
14585 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14586 {
14587 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14588
14589 return (-1);
14590 }
14591
14592 if (stat (dictfile1, &tmp_stat) == -1)
14593 {
14594 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14595
14596 fclose (fp1);
14597
14598 return (-1);
14599 }
14600
14601 if (S_ISDIR (tmp_stat.st_mode))
14602 {
14603 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14604
14605 fclose (fp1);
14606
14607 return (-1);
14608 }
14609
14610 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14611 {
14612 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14613
14614 fclose (fp1);
14615
14616 return (-1);
14617 }
14618
14619 if (stat (dictfile2, &tmp_stat) == -1)
14620 {
14621 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14622
14623 fclose (fp1);
14624 fclose (fp2);
14625
14626 return (-1);
14627 }
14628
14629 if (S_ISDIR (tmp_stat.st_mode))
14630 {
14631 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14632
14633 fclose (fp1);
14634 fclose (fp2);
14635
14636 return (-1);
14637 }
14638
14639 data.combs_cnt = 1;
14640
14641 data.quiet = 1;
14642
14643 const uint64_t words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14644
14645 data.quiet = quiet;
14646
14647 if (words1_cnt == 0)
14648 {
14649 log_error ("ERROR: %s: empty file", dictfile1);
14650
14651 fclose (fp1);
14652 fclose (fp2);
14653
14654 return (-1);
14655 }
14656
14657 data.combs_cnt = 1;
14658
14659 data.quiet = 1;
14660
14661 const uint64_t words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14662
14663 data.quiet = quiet;
14664
14665 if (words2_cnt == 0)
14666 {
14667 log_error ("ERROR: %s: empty file", dictfile2);
14668
14669 fclose (fp1);
14670 fclose (fp2);
14671
14672 return (-1);
14673 }
14674
14675 fclose (fp1);
14676 fclose (fp2);
14677
14678 data.dictfile = dictfile1;
14679 data.dictfile2 = dictfile2;
14680
14681 if (words1_cnt >= words2_cnt)
14682 {
14683 data.combs_cnt = words2_cnt;
14684 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14685
14686 dictfiles = &data.dictfile;
14687
14688 dictcnt = 1;
14689 }
14690 else
14691 {
14692 data.combs_cnt = words1_cnt;
14693 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14694
14695 dictfiles = &data.dictfile2;
14696
14697 dictcnt = 1;
14698
14699 // we also have to switch wordlist related rules!
14700
14701 char *tmpc = data.rule_buf_l;
14702
14703 data.rule_buf_l = data.rule_buf_r;
14704 data.rule_buf_r = tmpc;
14705
14706 int tmpi = data.rule_len_l;
14707
14708 data.rule_len_l = data.rule_len_r;
14709 data.rule_len_r = tmpi;
14710 }
14711 }
14712 else if (attack_mode == ATTACK_MODE_BF)
14713 {
14714 char *mask = NULL;
14715
14716 maskcnt = 0;
14717
14718 if (benchmark == 0)
14719 {
14720 mask = myargv[optind + 1];
14721
14722 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
14723
14724 if ((optind + 2) <= myargc)
14725 {
14726 struct stat file_stat;
14727
14728 if (stat (mask, &file_stat) == -1)
14729 {
14730 maskcnt = 1;
14731
14732 masks[maskcnt - 1] = mystrdup (mask);
14733 }
14734 else
14735 {
14736 int wls_left = myargc - (optind + 1);
14737
14738 uint masks_avail = INCR_MASKS;
14739
14740 for (int i = 0; i < wls_left; i++)
14741 {
14742 if (i != 0)
14743 {
14744 mask = myargv[optind + 1 + i];
14745
14746 if (stat (mask, &file_stat) == -1)
14747 {
14748 log_error ("ERROR: %s: %s", mask, strerror (errno));
14749
14750 return (-1);
14751 }
14752 }
14753
14754 uint is_file = S_ISREG (file_stat.st_mode);
14755
14756 if (is_file == 1)
14757 {
14758 FILE *mask_fp;
14759
14760 if ((mask_fp = fopen (mask, "r")) == NULL)
14761 {
14762 log_error ("ERROR: %s: %s", mask, strerror (errno));
14763
14764 return (-1);
14765 }
14766
14767 char line_buf[BUFSIZ];
14768
14769 while (!feof (mask_fp))
14770 {
14771 memset (line_buf, 0, BUFSIZ);
14772
14773 int line_len = fgetl (mask_fp, line_buf);
14774
14775 if (line_len == 0) continue;
14776
14777 if (line_buf[0] == '#') continue;
14778
14779 if (masks_avail == maskcnt)
14780 {
14781 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14782
14783 masks_avail += INCR_MASKS;
14784 }
14785
14786 masks[maskcnt] = mystrdup (line_buf);
14787
14788 maskcnt++;
14789 }
14790
14791 fclose (mask_fp);
14792 }
14793 else
14794 {
14795 log_error ("ERROR: %s: unsupported file-type", mask);
14796
14797 return (-1);
14798 }
14799 }
14800
14801 mask_from_file = 1;
14802 }
14803 }
14804 else
14805 {
14806 custom_charset_1 = (char *) "?l?d?u";
14807 custom_charset_2 = (char *) "?l?d";
14808 custom_charset_3 = (char *) "?l?d*!$@_";
14809
14810 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
14811 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
14812 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
14813
14814 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
14815
14816 wordlist_mode = WL_MODE_MASK;
14817
14818 data.wordlist_mode = wordlist_mode;
14819
14820 increment = 1;
14821
14822 maskcnt = 1;
14823 }
14824 }
14825 else
14826 {
14827 /**
14828 * generate full masks and charsets
14829 */
14830
14831 masks = (char **) mymalloc (sizeof (char *));
14832
14833 switch (hash_mode)
14834 {
14835 case 1731: pw_min = 5;
14836 pw_max = 5;
14837 mask = mystrdup ("?b?b?b?b?b");
14838 break;
14839 case 12500: pw_min = 5;
14840 pw_max = 5;
14841 mask = mystrdup ("?b?b?b?b?b");
14842 break;
14843 default: pw_min = 7;
14844 pw_max = 7;
14845 mask = mystrdup ("?b?b?b?b?b?b?b");
14846 break;
14847 }
14848
14849 maskcnt = 1;
14850
14851 masks[maskcnt - 1] = mystrdup (mask);
14852
14853 wordlist_mode = WL_MODE_MASK;
14854
14855 data.wordlist_mode = wordlist_mode;
14856
14857 increment = 1;
14858 }
14859
14860 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
14861
14862 if (increment)
14863 {
14864 if (increment_min > pw_min) pw_min = increment_min;
14865
14866 if (increment_max < pw_max) pw_max = increment_max;
14867 }
14868 }
14869 else if (attack_mode == ATTACK_MODE_HYBRID1)
14870 {
14871 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14872
14873 // display
14874
14875 char *mask = myargv[myargc - 1];
14876
14877 maskcnt = 0;
14878
14879 masks = (char **) mymalloc (1 * sizeof (char *));
14880
14881 // mod
14882
14883 struct stat file_stat;
14884
14885 if (stat (mask, &file_stat) == -1)
14886 {
14887 maskcnt = 1;
14888
14889 masks[maskcnt - 1] = mystrdup (mask);
14890 }
14891 else
14892 {
14893 uint is_file = S_ISREG (file_stat.st_mode);
14894
14895 if (is_file == 1)
14896 {
14897 FILE *mask_fp;
14898
14899 if ((mask_fp = fopen (mask, "r")) == NULL)
14900 {
14901 log_error ("ERROR: %s: %s", mask, strerror (errno));
14902
14903 return (-1);
14904 }
14905
14906 char line_buf[BUFSIZ];
14907
14908 uint masks_avail = 1;
14909
14910 while (!feof (mask_fp))
14911 {
14912 memset (line_buf, 0, BUFSIZ);
14913
14914 int line_len = fgetl (mask_fp, line_buf);
14915
14916 if (line_len == 0) continue;
14917
14918 if (line_buf[0] == '#') continue;
14919
14920 if (masks_avail == maskcnt)
14921 {
14922 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14923
14924 masks_avail += INCR_MASKS;
14925 }
14926
14927 masks[maskcnt] = mystrdup (line_buf);
14928
14929 maskcnt++;
14930 }
14931
14932 fclose (mask_fp);
14933
14934 mask_from_file = 1;
14935 }
14936 else
14937 {
14938 maskcnt = 1;
14939
14940 masks[maskcnt - 1] = mystrdup (mask);
14941 }
14942 }
14943
14944 // base
14945
14946 int wls_left = myargc - (optind + 2);
14947
14948 for (int i = 0; i < wls_left; i++)
14949 {
14950 char *filename = myargv[optind + 1 + i];
14951
14952 struct stat file_stat;
14953
14954 if (stat (filename, &file_stat) == -1)
14955 {
14956 log_error ("ERROR: %s: %s", filename, strerror (errno));
14957
14958 return (-1);
14959 }
14960
14961 uint is_dir = S_ISDIR (file_stat.st_mode);
14962
14963 if (is_dir == 0)
14964 {
14965 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14966
14967 dictcnt++;
14968
14969 dictfiles[dictcnt - 1] = filename;
14970 }
14971 else
14972 {
14973 // do not allow --keyspace w/ a directory
14974
14975 if (keyspace == 1)
14976 {
14977 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14978
14979 return (-1);
14980 }
14981
14982 char **dictionary_files = NULL;
14983
14984 dictionary_files = scan_directory (filename);
14985
14986 if (dictionary_files != NULL)
14987 {
14988 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14989
14990 for (int d = 0; dictionary_files[d] != NULL; d++)
14991 {
14992 char *l1_filename = dictionary_files[d];
14993
14994 struct stat l1_stat;
14995
14996 if (stat (l1_filename, &l1_stat) == -1)
14997 {
14998 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14999
15000 return (-1);
15001 }
15002
15003 if (S_ISREG (l1_stat.st_mode))
15004 {
15005 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15006
15007 dictcnt++;
15008
15009 dictfiles[dictcnt - 1] = strdup (l1_filename);
15010 }
15011 }
15012 }
15013
15014 local_free (dictionary_files);
15015 }
15016 }
15017
15018 if (dictcnt < 1)
15019 {
15020 log_error ("ERROR: No usable dictionary file found.");
15021
15022 return (-1);
15023 }
15024
15025 if (increment)
15026 {
15027 maskcnt = 0;
15028
15029 uint mask_min = increment_min; // we can't reject smaller masks here
15030 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15031
15032 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15033 {
15034 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15035
15036 if (cur_mask == NULL) break;
15037
15038 masks[maskcnt] = cur_mask;
15039
15040 maskcnt++;
15041
15042 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15043 }
15044 }
15045 }
15046 else if (attack_mode == ATTACK_MODE_HYBRID2)
15047 {
15048 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15049
15050 // display
15051
15052 char *mask = myargv[optind + 1 + 0];
15053
15054 maskcnt = 0;
15055
15056 masks = (char **) mymalloc (1 * sizeof (char *));
15057
15058 // mod
15059
15060 struct stat file_stat;
15061
15062 if (stat (mask, &file_stat) == -1)
15063 {
15064 maskcnt = 1;
15065
15066 masks[maskcnt - 1] = mystrdup (mask);
15067 }
15068 else
15069 {
15070 uint is_file = S_ISREG (file_stat.st_mode);
15071
15072 if (is_file == 1)
15073 {
15074 FILE *mask_fp;
15075
15076 if ((mask_fp = fopen (mask, "r")) == NULL)
15077 {
15078 log_error ("ERROR: %s: %s", mask, strerror (errno));
15079
15080 return (-1);
15081 }
15082
15083 char line_buf[BUFSIZ];
15084
15085 uint masks_avail = 1;
15086
15087 while (!feof (mask_fp))
15088 {
15089 memset (line_buf, 0, BUFSIZ);
15090
15091 int line_len = fgetl (mask_fp, line_buf);
15092
15093 if (line_len == 0) continue;
15094
15095 if (line_buf[0] == '#') continue;
15096
15097 if (masks_avail == maskcnt)
15098 {
15099 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15100
15101 masks_avail += INCR_MASKS;
15102 }
15103
15104 masks[maskcnt] = mystrdup (line_buf);
15105
15106 maskcnt++;
15107 }
15108
15109 fclose (mask_fp);
15110
15111 mask_from_file = 1;
15112 }
15113 else
15114 {
15115 maskcnt = 1;
15116
15117 masks[maskcnt - 1] = mystrdup (mask);
15118 }
15119 }
15120
15121 // base
15122
15123 int wls_left = myargc - (optind + 2);
15124
15125 for (int i = 0; i < wls_left; i++)
15126 {
15127 char *filename = myargv[optind + 2 + i];
15128
15129 struct stat file_stat;
15130
15131 if (stat (filename, &file_stat) == -1)
15132 {
15133 log_error ("ERROR: %s: %s", filename, strerror (errno));
15134
15135 return (-1);
15136 }
15137
15138 uint is_dir = S_ISDIR (file_stat.st_mode);
15139
15140 if (is_dir == 0)
15141 {
15142 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15143
15144 dictcnt++;
15145
15146 dictfiles[dictcnt - 1] = filename;
15147 }
15148 else
15149 {
15150 // do not allow --keyspace w/ a directory
15151
15152 if (keyspace == 1)
15153 {
15154 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15155
15156 return (-1);
15157 }
15158
15159 char **dictionary_files = NULL;
15160
15161 dictionary_files = scan_directory (filename);
15162
15163 if (dictionary_files != NULL)
15164 {
15165 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15166
15167 for (int d = 0; dictionary_files[d] != NULL; d++)
15168 {
15169 char *l1_filename = dictionary_files[d];
15170
15171 struct stat l1_stat;
15172
15173 if (stat (l1_filename, &l1_stat) == -1)
15174 {
15175 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15176
15177 return (-1);
15178 }
15179
15180 if (S_ISREG (l1_stat.st_mode))
15181 {
15182 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15183
15184 dictcnt++;
15185
15186 dictfiles[dictcnt - 1] = strdup (l1_filename);
15187 }
15188 }
15189 }
15190
15191 local_free (dictionary_files);
15192 }
15193 }
15194
15195 if (dictcnt < 1)
15196 {
15197 log_error ("ERROR: No usable dictionary file found.");
15198
15199 return (-1);
15200 }
15201
15202 if (increment)
15203 {
15204 maskcnt = 0;
15205
15206 uint mask_min = increment_min; // we can't reject smaller masks here
15207 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15208
15209 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15210 {
15211 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15212
15213 if (cur_mask == NULL) break;
15214
15215 masks[maskcnt] = cur_mask;
15216
15217 maskcnt++;
15218
15219 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15220 }
15221 }
15222 }
15223
15224 data.pw_min = pw_min;
15225 data.pw_max = pw_max;
15226
15227 /**
15228 * weak hash check
15229 */
15230
15231 if (weak_hash_threshold >= salts_cnt)
15232 {
15233 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15234
15235 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15236 {
15237 weak_hash_check (&data.devices_param[0], salt_pos, kernel_loops);
15238 }
15239 }
15240
15241 // Display hack, guarantee that there is at least one \r before real start
15242
15243 if (data.quiet == 0) log_info_nn ("");
15244
15245 /**
15246 * status and monitor threads
15247 */
15248
15249 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15250
15251 hc_thread_t i_thread = 0;
15252
15253 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15254 {
15255 hc_thread_create (i_thread, thread_keypress, &benchmark);
15256 }
15257
15258 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15259
15260 uint ni_threads_cnt = 0;
15261
15262 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15263
15264 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15265
15266 ni_threads_cnt++;
15267
15268 /**
15269 * Outfile remove
15270 */
15271
15272 if (keyspace == 0)
15273 {
15274 if (outfile_check_timer != 0)
15275 {
15276 if (data.outfile_check_directory != NULL)
15277 {
15278 if ((hash_mode != 5200) &&
15279 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15280 (hash_mode != 9000))
15281 {
15282 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15283
15284 ni_threads_cnt++;
15285 }
15286 else
15287 {
15288 outfile_check_timer = 0;
15289 }
15290 }
15291 else
15292 {
15293 outfile_check_timer = 0;
15294 }
15295 }
15296 }
15297
15298 /**
15299 * Inform the user if we got some hashes remove because of the pot file remove feature
15300 */
15301
15302 if (data.quiet == 0)
15303 {
15304 if (potfile_remove_cracks > 0)
15305 {
15306 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15307 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15308 }
15309 }
15310
15311 data.outfile_check_timer = outfile_check_timer;
15312
15313 /**
15314 * main loop
15315 */
15316
15317 char **induction_dictionaries = NULL;
15318
15319 int induction_dictionaries_cnt = 0;
15320
15321 hcstat_table_t *root_table_buf = NULL;
15322 hcstat_table_t *markov_table_buf = NULL;
15323
15324 uint initial_restore_done = 0;
15325
15326 data.maskcnt = maskcnt;
15327
15328 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15329 {
15330 if (data.devices_status == STATUS_CRACKED) break;
15331
15332 data.devices_status = STATUS_INIT;
15333
15334 if (maskpos > rd->maskpos)
15335 {
15336 rd->dictpos = 0;
15337 }
15338
15339 rd->maskpos = maskpos;
15340 data.maskpos = maskpos;
15341
15342 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15343 {
15344 char *mask = masks[maskpos];
15345
15346 if (mask_from_file == 1)
15347 {
15348 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15349
15350 char *str_ptr;
15351 uint str_pos;
15352
15353 uint mask_offset = 0;
15354
15355 uint separator_cnt;
15356
15357 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15358 {
15359 str_ptr = strstr (mask + mask_offset, ",");
15360
15361 if (str_ptr == NULL) break;
15362
15363 str_pos = str_ptr - mask;
15364
15365 // escaped separator, i.e. "\,"
15366
15367 if (str_pos > 0)
15368 {
15369 if (mask[str_pos - 1] == '\\')
15370 {
15371 separator_cnt --;
15372
15373 mask_offset = str_pos + 1;
15374
15375 continue;
15376 }
15377 }
15378
15379 // reset the offset
15380
15381 mask_offset = 0;
15382
15383 mask[str_pos] = '\0';
15384
15385 switch (separator_cnt)
15386 {
15387 case 0:
15388 mp_reset_usr (mp_usr, 0);
15389
15390 custom_charset_1 = mask;
15391 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15392 break;
15393
15394 case 1:
15395 mp_reset_usr (mp_usr, 1);
15396
15397 custom_charset_2 = mask;
15398 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15399 break;
15400
15401 case 2:
15402 mp_reset_usr (mp_usr, 2);
15403
15404 custom_charset_3 = mask;
15405 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15406 break;
15407
15408 case 3:
15409 mp_reset_usr (mp_usr, 3);
15410
15411 custom_charset_4 = mask;
15412 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15413 break;
15414 }
15415
15416 mask = mask + str_pos + 1;
15417 }
15418 }
15419
15420 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15421 {
15422 if (maskpos > 0)
15423 {
15424 local_free (css_buf);
15425 local_free (data.root_css_buf);
15426 local_free (data.markov_css_buf);
15427
15428 local_free (masks[maskpos - 1]);
15429 }
15430
15431 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15432
15433 data.mask = mask;
15434 data.css_cnt = css_cnt;
15435 data.css_buf = css_buf;
15436
15437 uint uniq_tbls[SP_PW_MAX][CHARSIZ];
15438
15439 memset (uniq_tbls, 0, sizeof (uniq_tbls));
15440
15441 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15442
15443 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15444 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15445
15446 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15447
15448 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15449
15450 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15451 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15452
15453 data.root_css_buf = root_css_buf;
15454 data.markov_css_buf = markov_css_buf;
15455
15456 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15457
15458 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15459
15460 local_free (root_table_buf);
15461 local_free (markov_table_buf);
15462
15463 // args
15464
15465 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15466 {
15467 hc_device_param_t *device_param = &data.devices_param[device_id];
15468
15469 device_param->kernel_params_mp[0] = &device_param->d_combs;
15470 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15471 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15472
15473 device_param->kernel_params_mp_buf64[3] = 0;
15474 device_param->kernel_params_mp_buf32[4] = css_cnt;
15475 device_param->kernel_params_mp_buf32[5] = 0;
15476 device_param->kernel_params_mp_buf32[6] = 0;
15477 device_param->kernel_params_mp_buf32[7] = 0;
15478
15479 if (attack_mode == ATTACK_MODE_HYBRID1)
15480 {
15481 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15482 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15483 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15484 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15485 }
15486 else if (attack_mode == ATTACK_MODE_HYBRID2)
15487 {
15488 device_param->kernel_params_mp_buf32[5] = 0;
15489 device_param->kernel_params_mp_buf32[6] = 0;
15490 device_param->kernel_params_mp_buf32[7] = 0;
15491 }
15492
15493 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp[i]);
15494 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp[i]);
15495 for (uint i = 4; i < 8; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp[i]);
15496
15497 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);
15498 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);
15499 }
15500 }
15501 else if (attack_mode == ATTACK_MODE_BF)
15502 {
15503 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15504
15505 if (increment)
15506 {
15507 for (uint i = 0; i < dictcnt; i++)
15508 {
15509 local_free (dictfiles[i]);
15510 }
15511
15512 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15513 {
15514 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15515
15516 if (l1_filename == NULL) break;
15517
15518 dictcnt++;
15519
15520 dictfiles[dictcnt - 1] = l1_filename;
15521 }
15522 }
15523 else
15524 {
15525 dictcnt++;
15526
15527 dictfiles[dictcnt - 1] = mask;
15528 }
15529
15530 if (dictcnt == 0)
15531 {
15532 log_error ("ERROR: Mask is too small");
15533
15534 return (-1);
15535 }
15536 }
15537 }
15538
15539 free (induction_dictionaries);
15540
15541 // induction_dictionaries_cnt = 0; // implied
15542
15543 if (attack_mode != ATTACK_MODE_BF)
15544 {
15545 if (keyspace == 0)
15546 {
15547 induction_dictionaries = scan_directory (induction_directory);
15548
15549 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15550 }
15551 }
15552
15553 if (induction_dictionaries_cnt)
15554 {
15555 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15556 }
15557
15558 /**
15559 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15560 */
15561 if (keyspace == 1)
15562 {
15563 if ((maskcnt > 1) || (dictcnt > 1))
15564 {
15565 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15566
15567 return (-1);
15568 }
15569 }
15570
15571 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15572 {
15573 char *subid = logfile_generate_subid ();
15574
15575 data.subid = subid;
15576
15577 logfile_sub_msg ("START");
15578
15579 data.devices_status = STATUS_INIT;
15580
15581 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (uint64_t));
15582 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (uint64_t));
15583 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (uint64_t));
15584
15585 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15586
15587 data.cpt_pos = 0;
15588
15589 data.cpt_start = time (NULL);
15590
15591 data.cpt_total = 0;
15592
15593 if (data.restore == 0)
15594 {
15595 rd->words_cur = skip;
15596
15597 skip = 0;
15598
15599 data.skip = 0;
15600 }
15601
15602 data.ms_paused = 0;
15603
15604 data.words_cur = rd->words_cur;
15605
15606 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15607 {
15608 hc_device_param_t *device_param = &data.devices_param[device_id];
15609
15610 device_param->speed_pos = 0;
15611
15612 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (uint64_t));
15613 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15614 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15615
15616 device_param->kernel_power = device_param->kernel_power_user;
15617 device_param->kernel_blocks = device_param->kernel_blocks_user;
15618
15619 device_param->outerloop_pos = 0;
15620 device_param->outerloop_left = 0;
15621 device_param->innerloop_pos = 0;
15622 device_param->innerloop_left = 0;
15623
15624 // some more resets:
15625
15626 memset (device_param->pw_caches, 0, 64 * sizeof (pw_cache_t));
15627
15628 memset (device_param->pws_buf, 0, device_param->size_pws);
15629
15630 device_param->pw_cnt = 0;
15631 device_param->pws_cnt = 0;
15632
15633 device_param->words_off = 0;
15634 device_param->words_done = 0;
15635 }
15636
15637 data.kernel_blocks_div = 0;
15638
15639 // figure out some workload
15640
15641 if (attack_mode == ATTACK_MODE_STRAIGHT)
15642 {
15643 if (data.wordlist_mode == WL_MODE_FILE)
15644 {
15645 char *dictfile = NULL;
15646
15647 if (induction_dictionaries_cnt)
15648 {
15649 dictfile = induction_dictionaries[0];
15650 }
15651 else
15652 {
15653 dictfile = dictfiles[dictpos];
15654 }
15655
15656 data.dictfile = dictfile;
15657
15658 logfile_sub_string (dictfile);
15659
15660 for (uint i = 0; i < rp_files_cnt; i++)
15661 {
15662 logfile_sub_var_string ("rulefile", rp_files[i]);
15663 }
15664
15665 FILE *fd2 = fopen (dictfile, "rb");
15666
15667 if (fd2 == NULL)
15668 {
15669 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15670
15671 return (-1);
15672 }
15673
15674 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15675
15676 fclose (fd2);
15677
15678 if (data.words_cnt == 0)
15679 {
15680 if (data.devices_status == STATUS_CRACKED) break;
15681 if (data.devices_status == STATUS_ABORTED) break;
15682
15683 dictpos++;
15684
15685 continue;
15686 }
15687 }
15688 }
15689 else if (attack_mode == ATTACK_MODE_COMBI)
15690 {
15691 char *dictfile = data.dictfile;
15692 char *dictfile2 = data.dictfile2;
15693
15694 logfile_sub_string (dictfile);
15695 logfile_sub_string (dictfile2);
15696
15697 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
15698 {
15699 FILE *fd2 = fopen (dictfile, "rb");
15700
15701 if (fd2 == NULL)
15702 {
15703 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15704
15705 return (-1);
15706 }
15707
15708 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15709
15710 fclose (fd2);
15711 }
15712 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
15713 {
15714 FILE *fd2 = fopen (dictfile2, "rb");
15715
15716 if (fd2 == NULL)
15717 {
15718 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15719
15720 return (-1);
15721 }
15722
15723 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
15724
15725 fclose (fd2);
15726 }
15727
15728 if (data.words_cnt == 0)
15729 {
15730 if (data.devices_status == STATUS_CRACKED) break;
15731 if (data.devices_status == STATUS_ABORTED) break;
15732
15733 dictpos++;
15734
15735 continue;
15736 }
15737 }
15738 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15739 {
15740 char *dictfile = NULL;
15741
15742 if (induction_dictionaries_cnt)
15743 {
15744 dictfile = induction_dictionaries[0];
15745 }
15746 else
15747 {
15748 dictfile = dictfiles[dictpos];
15749 }
15750
15751 data.dictfile = dictfile;
15752
15753 char *mask = data.mask;
15754
15755 logfile_sub_string (dictfile);
15756 logfile_sub_string (mask);
15757
15758 FILE *fd2 = fopen (dictfile, "rb");
15759
15760 if (fd2 == NULL)
15761 {
15762 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15763
15764 return (-1);
15765 }
15766
15767 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15768
15769 fclose (fd2);
15770
15771 if (data.words_cnt == 0)
15772 {
15773 if (data.devices_status == STATUS_CRACKED) break;
15774 if (data.devices_status == STATUS_ABORTED) break;
15775
15776 dictpos++;
15777
15778 continue;
15779 }
15780 }
15781 else if (attack_mode == ATTACK_MODE_BF)
15782 {
15783 local_free (css_buf);
15784 local_free (data.root_css_buf);
15785 local_free (data.markov_css_buf);
15786
15787 char *mask = dictfiles[dictpos];
15788
15789 logfile_sub_string (mask);
15790
15791 // base
15792
15793 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15794
15795 if (opts_type & OPTS_TYPE_PT_UNICODE)
15796 {
15797 uint css_cnt_unicode = css_cnt * 2;
15798
15799 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
15800
15801 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
15802 {
15803 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
15804
15805 css_buf_unicode[j + 1].cs_buf[0] = 0;
15806 css_buf_unicode[j + 1].cs_len = 1;
15807 }
15808
15809 free (css_buf);
15810
15811 css_buf = css_buf_unicode;
15812 css_cnt = css_cnt_unicode;
15813 }
15814
15815 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
15816
15817 uint mask_min = pw_min;
15818 uint mask_max = pw_max;
15819
15820 if (opts_type & OPTS_TYPE_PT_UNICODE)
15821 {
15822 mask_min *= 2;
15823 mask_max *= 2;
15824 }
15825
15826 if ((css_cnt < mask_min) || (css_cnt > mask_max))
15827 {
15828 if (css_cnt < mask_min)
15829 {
15830 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
15831 }
15832
15833 if (css_cnt > mask_max)
15834 {
15835 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
15836 }
15837
15838 // skip to next mask
15839
15840 dictpos++;
15841
15842 rd->dictpos = dictpos;
15843
15844 logfile_sub_msg ("STOP");
15845
15846 continue;
15847 }
15848
15849 uint save_css_cnt = css_cnt;
15850
15851 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15852 {
15853 if (opti_type & OPTI_TYPE_APPENDED_SALT)
15854 {
15855 uint salt_len = (uint) data.salts_buf[0].salt_len;
15856 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
15857
15858 uint css_cnt_salt = css_cnt + salt_len;
15859
15860 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
15861
15862 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
15863
15864 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
15865 {
15866 css_buf_salt[j].cs_buf[0] = salt_buf[i];
15867 css_buf_salt[j].cs_len = 1;
15868 }
15869
15870 free (css_buf);
15871
15872 css_buf = css_buf_salt;
15873 css_cnt = css_cnt_salt;
15874 }
15875 }
15876
15877 data.mask = mask;
15878 data.css_cnt = css_cnt;
15879 data.css_buf = css_buf;
15880
15881 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
15882
15883 uint uniq_tbls[SP_PW_MAX][CHARSIZ];
15884
15885 memset (uniq_tbls, 0, sizeof (uniq_tbls));
15886
15887 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15888
15889 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15890 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15891
15892 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15893
15894 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15895
15896 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15897 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15898
15899 data.root_css_buf = root_css_buf;
15900 data.markov_css_buf = markov_css_buf;
15901
15902 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15903
15904 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15905
15906 local_free (root_table_buf);
15907 local_free (markov_table_buf);
15908
15909 // copy + args
15910
15911 uint css_cnt_l = css_cnt;
15912 uint css_cnt_r;
15913
15914 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15915 {
15916 if (save_css_cnt < 6)
15917 {
15918 css_cnt_r = 1;
15919 }
15920 else if (save_css_cnt == 6)
15921 {
15922 css_cnt_r = 2;
15923 }
15924 else
15925 {
15926 if (opts_type & OPTS_TYPE_PT_UNICODE)
15927 {
15928 if (save_css_cnt == 8 || save_css_cnt == 10)
15929 {
15930 css_cnt_r = 2;
15931 }
15932 else
15933 {
15934 css_cnt_r = 4;
15935 }
15936 }
15937 else
15938 {
15939 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
15940 {
15941 css_cnt_r = 3;
15942 }
15943 else
15944 {
15945 css_cnt_r = 4;
15946 }
15947 }
15948 }
15949 }
15950 else
15951 {
15952 css_cnt_r = 1;
15953
15954 /* unfinished code?
15955 int sum = css_buf[css_cnt_r - 1].cs_len;
15956
15957 for (uint i = 1; i < 4 && i < css_cnt; i++)
15958 {
15959 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
15960
15961 css_cnt_r++;
15962
15963 sum *= css_buf[css_cnt_r - 1].cs_len;
15964 }
15965 */
15966 }
15967
15968 css_cnt_l -= css_cnt_r;
15969
15970 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
15971
15972 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15973 {
15974 hc_device_param_t *device_param = &data.devices_param[device_id];
15975
15976 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
15977 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
15978 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
15979
15980 device_param->kernel_params_mp_l_buf64[3] = 0;
15981 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
15982 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
15983 device_param->kernel_params_mp_l_buf32[6] = 0;
15984 device_param->kernel_params_mp_l_buf32[7] = 0;
15985 device_param->kernel_params_mp_l_buf32[8] = 0;
15986
15987 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
15988 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
15989 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
15990 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
15991
15992 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
15993 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
15994 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
15995
15996 device_param->kernel_params_mp_r_buf64[3] = 0;
15997 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
15998 device_param->kernel_params_mp_r_buf32[5] = 0;
15999 device_param->kernel_params_mp_r_buf32[6] = 0;
16000 device_param->kernel_params_mp_r_buf32[7] = 0;
16001
16002 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]);
16003 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]);
16004 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]);
16005
16006 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]);
16007 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]);
16008 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]);
16009
16010 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);
16011 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);
16012 }
16013 }
16014
16015 uint64_t words_base = data.words_cnt;
16016
16017 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16018 {
16019 if (data.kernel_rules_cnt)
16020 {
16021 words_base /= data.kernel_rules_cnt;
16022 }
16023 }
16024 else if (data.attack_kern == ATTACK_KERN_COMBI)
16025 {
16026 if (data.combs_cnt)
16027 {
16028 words_base /= data.combs_cnt;
16029 }
16030 }
16031 else if (data.attack_kern == ATTACK_KERN_BF)
16032 {
16033 if (data.bfs_cnt)
16034 {
16035 words_base /= data.bfs_cnt;
16036 }
16037 }
16038
16039 data.words_base = words_base;
16040
16041 if (keyspace == 1)
16042 {
16043 log_info ("%llu", (unsigned long long int) words_base);
16044
16045 return (0);
16046 }
16047
16048 if (data.words_cur > data.words_base)
16049 {
16050 log_error ("ERROR: restore value greater keyspace");
16051
16052 return (-1);
16053 }
16054
16055 if (data.words_cur)
16056 {
16057 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16058 {
16059 for (uint i = 0; i < data.salts_cnt; i++)
16060 {
16061 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16062 }
16063 }
16064 else if (data.attack_kern == ATTACK_KERN_COMBI)
16065 {
16066 for (uint i = 0; i < data.salts_cnt; i++)
16067 {
16068 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16069 }
16070 }
16071 else if (data.attack_kern == ATTACK_KERN_BF)
16072 {
16073 for (uint i = 0; i < data.salts_cnt; i++)
16074 {
16075 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16076 }
16077 }
16078 }
16079
16080 /*
16081 * Inform user about possible slow speeds
16082 */
16083
16084 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16085 {
16086 if (data.words_base < kernel_blocks_all)
16087 {
16088 if (quiet == 0)
16089 {
16090 log_info ("");
16091 log_info ("ATTENTION!");
16092 log_info (" The wordlist or mask you are using is too small.");
16093 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16094 log_info (" The cracking speed will drop.");
16095 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16096 log_info ("");
16097 }
16098 }
16099 }
16100
16101 /*
16102 * Update loopback file
16103 */
16104
16105 if (loopback == 1)
16106 {
16107 time_t now;
16108
16109 time (&now);
16110
16111 uint random_num = get_random_num (0, 9999);
16112
16113 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16114
16115 data.loopback_file = loopback_file;
16116 }
16117
16118 /*
16119 * Update dictionary statistic
16120 */
16121
16122 if (keyspace == 0)
16123 {
16124 dictstat_fp = fopen (dictstat, "wb");
16125
16126 if (dictstat_fp)
16127 {
16128 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16129
16130 fclose (dictstat_fp);
16131 }
16132 }
16133
16134 data.devices_status = STATUS_RUNNING;
16135
16136 if (initial_restore_done == 0)
16137 {
16138 if (data.restore_disable == 0) cycle_restore ();
16139
16140 initial_restore_done = 1;
16141 }
16142
16143 hc_timer_set (&data.timer_running);
16144
16145 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16146 {
16147 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16148 {
16149 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16150 if (quiet == 0) fflush (stdout);
16151 }
16152 }
16153 else if (wordlist_mode == WL_MODE_STDIN)
16154 {
16155 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16156 if (data.quiet == 0) log_info ("");
16157 }
16158
16159 time_t runtime_start;
16160
16161 time (&runtime_start);
16162
16163 data.runtime_start = runtime_start;
16164
16165 /**
16166 * create cracker threads
16167 */
16168
16169 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (devices_cnt, sizeof (hc_thread_t));
16170
16171 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16172 {
16173 hc_device_param_t *device_param = &devices_param[device_id];
16174
16175 device_param->device_id = device_id;
16176
16177 if (wordlist_mode == WL_MODE_STDIN)
16178 {
16179 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16180 }
16181 else
16182 {
16183 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16184 }
16185 }
16186
16187 // wait for crack threads to exit
16188
16189 hc_thread_wait (devices_cnt, c_threads);
16190
16191 local_free (c_threads);
16192
16193 data.restore = 0;
16194
16195 // finalize task
16196
16197 logfile_sub_var_uint ("status-after-work", data.devices_status);
16198
16199 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16200
16201 if (data.devices_status == STATUS_CRACKED) break;
16202 if (data.devices_status == STATUS_ABORTED) break;
16203
16204 if (data.devices_status == STATUS_BYPASS)
16205 {
16206 data.devices_status = STATUS_RUNNING;
16207 }
16208
16209 if (induction_dictionaries_cnt)
16210 {
16211 unlink (induction_dictionaries[0]);
16212 }
16213
16214 free (induction_dictionaries);
16215
16216 if (attack_mode != ATTACK_MODE_BF)
16217 {
16218 induction_dictionaries = scan_directory (induction_directory);
16219
16220 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16221 }
16222
16223 if (benchmark == 0)
16224 {
16225 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16226 {
16227 if (quiet == 0) clear_prompt ();
16228
16229 if (quiet == 0) log_info ("");
16230
16231 if (status == 1)
16232 {
16233 status_display ();
16234 }
16235 else
16236 {
16237 if (quiet == 0) status_display ();
16238 }
16239
16240 if (quiet == 0) log_info ("");
16241 }
16242 }
16243
16244 if (attack_mode == ATTACK_MODE_BF)
16245 {
16246 dictpos++;
16247
16248 rd->dictpos = dictpos;
16249 }
16250 else
16251 {
16252 if (induction_dictionaries_cnt)
16253 {
16254 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16255 }
16256 else
16257 {
16258 dictpos++;
16259
16260 rd->dictpos = dictpos;
16261 }
16262 }
16263
16264 time_t runtime_stop;
16265
16266 time (&runtime_stop);
16267
16268 data.runtime_stop = runtime_stop;
16269
16270 logfile_sub_uint (runtime_start);
16271 logfile_sub_uint (runtime_stop);
16272
16273 logfile_sub_msg ("STOP");
16274
16275 global_free (subid);
16276 }
16277
16278 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16279
16280 if (data.devices_status == STATUS_CRACKED) break;
16281 if (data.devices_status == STATUS_ABORTED) break;
16282 if (data.devices_status == STATUS_QUIT) break;
16283
16284 if (data.devices_status == STATUS_BYPASS)
16285 {
16286 data.devices_status = STATUS_RUNNING;
16287 }
16288 }
16289
16290 // 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
16291
16292 if (attack_mode == ATTACK_MODE_STRAIGHT)
16293 {
16294 if (data.wordlist_mode == WL_MODE_FILE)
16295 {
16296 if (data.dictfile == NULL)
16297 {
16298 if (dictfiles != NULL)
16299 {
16300 data.dictfile = dictfiles[0];
16301
16302 hc_timer_set (&data.timer_running);
16303 }
16304 }
16305 }
16306 }
16307 // NOTE: combi is okay because it is already set beforehand
16308 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16309 {
16310 if (data.dictfile == NULL)
16311 {
16312 if (dictfiles != NULL)
16313 {
16314 hc_timer_set (&data.timer_running);
16315
16316 data.dictfile = dictfiles[0];
16317 }
16318 }
16319 }
16320 else if (attack_mode == ATTACK_MODE_BF)
16321 {
16322 if (data.mask == NULL)
16323 {
16324 hc_timer_set (&data.timer_running);
16325
16326 data.mask = masks[0];
16327 }
16328 }
16329
16330 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16331 {
16332 data.devices_status = STATUS_EXHAUSTED;
16333 }
16334
16335 // if cracked / aborted remove last induction dictionary
16336
16337 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16338 {
16339 struct stat induct_stat;
16340
16341 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16342 {
16343 unlink (induction_dictionaries[file_pos]);
16344 }
16345 }
16346
16347 // wait for non-interactive threads
16348
16349 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16350 {
16351 hc_thread_wait (1, &ni_threads[thread_idx]);
16352 }
16353
16354 local_free (ni_threads);
16355
16356 // wait for interactive threads
16357
16358 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16359 {
16360 hc_thread_wait (1, &i_thread);
16361 }
16362
16363 // we dont need restore file anymore
16364 if (data.restore_disable == 0)
16365 {
16366 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16367 {
16368 unlink (eff_restore_file);
16369 unlink (new_restore_file);
16370 }
16371 else
16372 {
16373 cycle_restore ();
16374 }
16375 }
16376
16377 // finally save left hashes
16378
16379 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16380 {
16381 save_hash ();
16382 }
16383
16384 /**
16385 * Clean up
16386 */
16387
16388 if (benchmark == 1)
16389 {
16390 status_benchmark ();
16391
16392 log_info ("");
16393 }
16394 else
16395 {
16396 if (quiet == 0) clear_prompt ();
16397
16398 if (quiet == 0) log_info ("");
16399
16400 if (status == 1)
16401 {
16402 status_display ();
16403 }
16404 else
16405 {
16406 if (quiet == 0) status_display ();
16407 }
16408
16409 if (quiet == 0) log_info ("");
16410 }
16411
16412 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16413 {
16414 hc_device_param_t *device_param = &data.devices_param[device_id];
16415
16416 local_free (device_param->result);
16417
16418 local_free (device_param->pw_caches);
16419
16420 local_free (device_param->combs_buf);
16421
16422 local_free (device_param->hooks_buf);
16423
16424 local_free (device_param->device_name);
16425
16426 local_free (device_param->device_name_chksum);
16427
16428 local_free (device_param->device_version);
16429
16430 local_free (device_param->driver_version);
16431
16432 if (device_param->pws_buf) myfree (device_param->pws_buf);
16433 if (device_param->d_pws_buf) hc_clReleaseMemObject (device_param->d_pws_buf);
16434 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (device_param->d_pws_amp_buf);
16435 if (device_param->d_rules) hc_clReleaseMemObject (device_param->d_rules);
16436 if (device_param->d_rules_c) hc_clReleaseMemObject (device_param->d_rules_c);
16437 if (device_param->d_combs) hc_clReleaseMemObject (device_param->d_combs);
16438 if (device_param->d_combs_c) hc_clReleaseMemObject (device_param->d_combs_c);
16439 if (device_param->d_bfs) hc_clReleaseMemObject (device_param->d_bfs);
16440 if (device_param->d_bfs_c) hc_clReleaseMemObject (device_param->d_bfs_c);
16441 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (device_param->d_bitmap_s1_a);
16442 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (device_param->d_bitmap_s1_b);
16443 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (device_param->d_bitmap_s1_c);
16444 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (device_param->d_bitmap_s1_d);
16445 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (device_param->d_bitmap_s2_a);
16446 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (device_param->d_bitmap_s2_b);
16447 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (device_param->d_bitmap_s2_c);
16448 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (device_param->d_bitmap_s2_d);
16449 if (device_param->d_plain_bufs) hc_clReleaseMemObject (device_param->d_plain_bufs);
16450 if (device_param->d_digests_buf) hc_clReleaseMemObject (device_param->d_digests_buf);
16451 if (device_param->d_digests_shown) hc_clReleaseMemObject (device_param->d_digests_shown);
16452 if (device_param->d_salt_bufs) hc_clReleaseMemObject (device_param->d_salt_bufs);
16453 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (device_param->d_esalt_bufs);
16454 if (device_param->d_tmps) hc_clReleaseMemObject (device_param->d_tmps);
16455 if (device_param->d_hooks) hc_clReleaseMemObject (device_param->d_hooks);
16456 if (device_param->d_result) hc_clReleaseMemObject (device_param->d_result);
16457 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (device_param->d_scryptV_buf);
16458 if (device_param->d_root_css_buf) hc_clReleaseMemObject (device_param->d_root_css_buf);
16459 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (device_param->d_markov_css_buf);
16460 if (device_param->d_tm_c) hc_clReleaseMemObject (device_param->d_tm_c);
16461
16462 if (device_param->kernel1) hc_clReleaseKernel (device_param->kernel1);
16463 if (device_param->kernel12) hc_clReleaseKernel (device_param->kernel12);
16464 if (device_param->kernel2) hc_clReleaseKernel (device_param->kernel2);
16465 if (device_param->kernel23) hc_clReleaseKernel (device_param->kernel23);
16466 if (device_param->kernel3) hc_clReleaseKernel (device_param->kernel3);
16467 if (device_param->kernel_mp) hc_clReleaseKernel (device_param->kernel_mp);
16468 if (device_param->kernel_mp_l) hc_clReleaseKernel (device_param->kernel_mp_l);
16469 if (device_param->kernel_mp_r) hc_clReleaseKernel (device_param->kernel_mp_r);
16470 if (device_param->kernel_tb) hc_clReleaseKernel (device_param->kernel_tb);
16471 if (device_param->kernel_tm) hc_clReleaseKernel (device_param->kernel_tm);
16472 if (device_param->kernel_amp) hc_clReleaseKernel (device_param->kernel_amp);
16473 if (device_param->kernel_weak) hc_clReleaseKernel (device_param->kernel_weak);
16474
16475 if (device_param->program) hc_clReleaseProgram (device_param->program);
16476 if (device_param->program_mp) hc_clReleaseProgram (device_param->program_mp);
16477 if (device_param->program_amp) hc_clReleaseProgram (device_param->program_amp);
16478 if (device_param->program_weak) hc_clReleaseProgram (device_param->program_weak);
16479
16480 if (device_param->command_queue) hc_clReleaseCommandQueue (device_param->command_queue);
16481 if (device_param->context) hc_clReleaseContext (device_param->context);
16482 }
16483
16484 // reset default fan speed
16485
16486 if (gpu_temp_disable == 0)
16487 {
16488 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16489 {
16490 hc_thread_mutex_lock (mux_adl);
16491
16492 for (uint i = 0; i < data.devices_cnt; i++)
16493 {
16494 if (data.hm_device[i].fan_supported == 1)
16495 {
16496 int fanspeed = temp_retain_fanspeed_value[i];
16497
16498 if (fanspeed == -1) continue;
16499
16500 int rc = hm_set_fanspeed_with_device_id_amd (i, fanspeed);
16501
16502 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", i);
16503 }
16504 }
16505
16506 hc_thread_mutex_unlock (mux_adl);
16507 }
16508 }
16509
16510 // reset power tuning
16511
16512 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16513 {
16514 hc_thread_mutex_lock (mux_adl);
16515
16516 for (uint i = 0; i < data.devices_cnt; i++)
16517 {
16518 if (data.hm_device[i].od_version == 6)
16519 {
16520 // check powertune capabilities first, if not available then skip device
16521
16522 int powertune_supported = 0;
16523
16524 if ((hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll_amd, data.hm_device[i].adapter_index.amd, &powertune_supported)) != ADL_OK)
16525 {
16526 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16527
16528 return (-1);
16529 }
16530
16531 if (powertune_supported != 0)
16532 {
16533 // powercontrol settings
16534
16535 if ((hc_ADL_Overdrive_PowerControl_Set (data.hm_dll_amd, data.hm_device[i].adapter_index.amd, od_power_control_status[i])) != ADL_OK)
16536 {
16537 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16538
16539 return (-1);
16540 }
16541
16542 // clocks
16543
16544 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16545
16546 performance_state->iNumberOfPerformanceLevels = 2;
16547
16548 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[i].state.aLevels[0].iEngineClock;
16549 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[i].state.aLevels[1].iEngineClock;
16550 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[i].state.aLevels[0].iMemoryClock;
16551 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[i].state.aLevels[1].iMemoryClock;
16552
16553 if ((hc_ADL_Overdrive_State_Set (data.hm_dll_amd, data.hm_device[i].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
16554 {
16555 log_info ("ERROR: Failed to restore ADL performance state");
16556
16557 return (-1);
16558 }
16559
16560 local_free (performance_state);
16561 }
16562 }
16563 }
16564
16565 hc_thread_mutex_unlock (mux_adl);
16566 }
16567
16568 if (gpu_temp_disable == 0)
16569 {
16570 #ifdef LINUX
16571 if (data.hm_dll_nv)
16572 {
16573 hc_NVML_nvmlShutdown (data.hm_dll_nv);
16574
16575 hm_close (data.hm_dll_nv);
16576 }
16577 #endif
16578
16579 #ifdef WIN
16580 NvAPI_Unload ();
16581 #endif
16582
16583 if (data.hm_dll_amd)
16584 {
16585 hc_ADL_Main_Control_Destroy (data.hm_dll_amd);
16586
16587 hm_close (data.hm_dll_amd);
16588 }
16589 }
16590
16591 // free memory
16592
16593 local_free (masks);
16594
16595 local_free (dictstat_base);
16596
16597 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16598 {
16599 pot_t *pot_ptr = &pot[pot_pos];
16600
16601 hash_t *hash = &pot_ptr->hash;
16602
16603 local_free (hash->digest);
16604
16605 if (isSalted)
16606 {
16607 local_free (hash->salt);
16608 }
16609 }
16610
16611 local_free (pot);
16612
16613 local_free (all_kernel_rules_cnt);
16614 local_free (all_kernel_rules_buf);
16615
16616 local_free (wl_data->buf);
16617 local_free (wl_data);
16618
16619 local_free (bitmap_s1_a);
16620 local_free (bitmap_s1_b);
16621 local_free (bitmap_s1_c);
16622 local_free (bitmap_s1_d);
16623 local_free (bitmap_s2_a);
16624 local_free (bitmap_s2_b);
16625 local_free (bitmap_s2_c);
16626 local_free (bitmap_s2_d);
16627
16628 local_free (temp_retain_fanspeed_value);
16629 local_free (od_clock_mem_status);
16630 local_free (od_power_control_status);
16631
16632 global_free (devices_param);
16633
16634 global_free (kernel_rules_buf);
16635
16636 global_free (root_css_buf);
16637 global_free (markov_css_buf);
16638
16639 global_free (digests_buf);
16640 global_free (digests_shown);
16641 global_free (digests_shown_tmp);
16642
16643 global_free (salts_buf);
16644 global_free (salts_shown);
16645
16646 global_free (esalts_buf);
16647
16648 global_free (words_progress_done);
16649 global_free (words_progress_rejected);
16650 global_free (words_progress_restored);
16651
16652 if (pot_fp) fclose (pot_fp);
16653
16654 if (data.devices_status == STATUS_QUIT) break;
16655 }
16656
16657 // destroy others mutex
16658
16659 hc_thread_mutex_delete (mux_dispatcher);
16660 hc_thread_mutex_delete (mux_counter);
16661 hc_thread_mutex_delete (mux_display);
16662 hc_thread_mutex_delete (mux_adl);
16663
16664 // free memory
16665
16666 local_free (eff_restore_file);
16667 local_free (new_restore_file);
16668
16669 local_free (rd);
16670
16671 // loopback
16672
16673 local_free (loopback_file);
16674
16675 if (loopback == 1) unlink (loopback_file);
16676
16677 // induction directory
16678
16679 if (induction_dir == NULL)
16680 {
16681 if (attack_mode != ATTACK_MODE_BF)
16682 {
16683 if (rmdir (induction_directory) == -1)
16684 {
16685 if (errno == ENOENT)
16686 {
16687 // good, we can ignore
16688 }
16689 else if (errno == ENOTEMPTY)
16690 {
16691 // good, we can ignore
16692 }
16693 else
16694 {
16695 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
16696
16697 return (-1);
16698 }
16699 }
16700
16701 local_free (induction_directory);
16702 }
16703 }
16704
16705 // outfile-check directory
16706
16707 if (outfile_check_dir == NULL)
16708 {
16709 if (rmdir (outfile_check_directory) == -1)
16710 {
16711 if (errno == ENOENT)
16712 {
16713 // good, we can ignore
16714 }
16715 else if (errno == ENOTEMPTY)
16716 {
16717 // good, we can ignore
16718 }
16719 else
16720 {
16721 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
16722
16723 return (-1);
16724 }
16725 }
16726
16727 local_free (outfile_check_directory);
16728 }
16729
16730 time_t proc_stop;
16731
16732 time (&proc_stop);
16733
16734 logfile_top_uint (proc_start);
16735 logfile_top_uint (proc_stop);
16736
16737 logfile_top_msg ("STOP");
16738
16739 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
16740 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
16741
16742 if (data.devices_status == STATUS_ABORTED) return 2;
16743 if (data.devices_status == STATUS_QUIT) return 2;
16744 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
16745 if (data.devices_status == STATUS_EXHAUSTED) return 1;
16746 if (data.devices_status == STATUS_CRACKED) return 0;
16747
16748 return -1;
16749 }
Hashcat additions to support pwdhash