projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Fix -m 1500 in combination with new weak-hash-check
[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 we need to 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 }
12401
12402 /**
12403 * OpenCL devices: push all devices from all platforms into the same device array
12404 */
12405
12406 uint devices_plf[DEVICES_MAX]; // device number on platform, required for hardware-management mapping
12407
12408 cl_device_id devices_all[DEVICES_MAX];
12409 cl_device_id devices[DEVICES_MAX];
12410
12411 uint devices_all_cnt = 0;
12412 uint devices_cnt = 0;
12413
12414 for (uint i = 0; i < CL_platforms_cnt; i++)
12415 {
12416 if ((opencl_platforms_filter & (1 << i)) == 0) continue;
12417
12418 cl_platform_id CL_platform = CL_platforms[i];
12419
12420 cl_device_id devices_platform[DEVICES_MAX];
12421
12422 cl_uint devices_platform_cnt = 0;
12423
12424 hc_clGetDeviceIDs (CL_platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, devices_platform, &devices_platform_cnt);
12425
12426 for (uint j = 0; j < devices_platform_cnt; j++)
12427 {
12428 devices_all[devices_all_cnt] = devices_platform[j];
12429 devices_plf[devices_all_cnt] = j;
12430
12431 devices_all_cnt++;
12432 }
12433 }
12434
12435 /**
12436 * enable custom signal handler(s)
12437 */
12438
12439 if (benchmark == 0)
12440 {
12441 hc_signal (sigHandler_default);
12442 }
12443 else
12444 {
12445 hc_signal (sigHandler_benchmark);
12446 }
12447
12448 /**
12449 * devices mask and properties
12450 */
12451
12452 uint quiet_sav = quiet;
12453
12454 quiet = 0;
12455
12456 for (uint device_all_id = 0; device_all_id < devices_all_cnt; device_all_id++)
12457 {
12458 // skip the device, if the user did specify a list of GPUs to skip
12459
12460 if (opencl_devicemask)
12461 {
12462 uint device_all_id_mask = 1 << device_all_id;
12463
12464 if ((device_all_id_mask & opencl_devicemask) != device_all_id_mask)
12465 {
12466 if (quiet == 0 && algorithm_pos == 0) log_info ("Device #%d: skipped", device_all_id + 1);
12467
12468 continue;
12469 }
12470 }
12471
12472 const uint device_id = devices_cnt;
12473
12474 devices[device_id] = devices_all[device_all_id];
12475
12476 devices_plf[device_id] = devices_plf[device_all_id];
12477
12478 cl_device_type device_type = 0;
12479
12480 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12481
12482 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12483
12484 if ((device_type & device_types_filter) == 0)
12485 {
12486 if (quiet == 0 && algorithm_pos == 0) log_info ("Device #%d: skipped", device_all_id + 1);
12487
12488 continue;
12489 }
12490
12491 char device_name[INFOSZ];
12492 char device_version[INFOSZ];
12493
12494 memset (device_name, 0, sizeof (device_name));
12495 memset (device_version, 0, sizeof (device_version));
12496
12497 cl_ulong global_mem_size;
12498 cl_ulong max_mem_alloc_size;
12499 cl_uint max_clock_frequency;
12500 cl_uint max_compute_units;
12501
12502 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_NAME, sizeof (device_name), &device_name, NULL);
12503 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (global_mem_size), &global_mem_size, NULL);
12504 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (max_mem_alloc_size), &max_mem_alloc_size, NULL);
12505 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (max_clock_frequency), &max_clock_frequency, NULL);
12506 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (max_compute_units), &max_compute_units, NULL);
12507 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_VERSION, sizeof (device_version), &device_version, NULL);
12508
12509 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12510 {
12511 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12512 device_all_id + 1,
12513 device_name,
12514 (unsigned int) (max_mem_alloc_size / 1024 / 1024),
12515 (unsigned int) (global_mem_size / 1024 / 1024),
12516 (unsigned int) (max_clock_frequency),
12517 (unsigned int) max_compute_units);
12518 }
12519
12520 if (strstr (device_version, "pocl"))
12521 {
12522 if (force == 0)
12523 {
12524 log_info ("");
12525 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12526 log_info ("You are STRONGLY encouraged not to use it");
12527 log_info ("You can use --force to override this but do not post error reports if you do so");
12528 log_info ("");
12529
12530 return (-1);
12531 }
12532 }
12533
12534 devices_cnt++;
12535 }
12536
12537 quiet = quiet_sav;
12538
12539 if (devices_cnt == 0)
12540 {
12541 log_error ("ERROR: No devices left that matches your specification.");
12542
12543 return (-1);
12544 }
12545
12546 data.devices_cnt = devices_cnt;
12547
12548 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12549 {
12550 log_info ("");
12551 }
12552
12553 /**
12554 * User-defined GPU temp handling
12555 */
12556
12557 if (gpu_temp_disable == 1)
12558 {
12559 gpu_temp_abort = 0;
12560 gpu_temp_retain = 0;
12561 }
12562
12563 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
12564 {
12565 if (gpu_temp_abort < gpu_temp_retain)
12566 {
12567 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
12568
12569 return (-1);
12570 }
12571 }
12572
12573 data.gpu_temp_disable = gpu_temp_disable;
12574 data.gpu_temp_abort = gpu_temp_abort;
12575 data.gpu_temp_retain = gpu_temp_retain;
12576
12577 /**
12578 * inform the user
12579 */
12580
12581 if (data.quiet == 0)
12582 {
12583 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
12584
12585 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);
12586
12587 if (attack_mode == ATTACK_MODE_STRAIGHT)
12588 {
12589 log_info ("Rules: %u", kernel_rules_cnt);
12590 }
12591
12592 if (opti_type)
12593 {
12594 log_info ("Applicable Optimizers:");
12595
12596 for (uint i = 0; i < 32; i++)
12597 {
12598 const uint opti_bit = 1 << i;
12599
12600 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
12601 }
12602 }
12603
12604 /**
12605 * Watchdog and Temperature balance
12606 */
12607
12608 if (gpu_temp_abort == 0)
12609 {
12610 log_info ("Watchdog: Temperature abort trigger disabled");
12611 }
12612 else
12613 {
12614 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
12615 }
12616
12617 if (gpu_temp_retain == 0)
12618 {
12619 log_info ("Watchdog: Temperature retain trigger disabled");
12620 }
12621 else
12622 {
12623 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
12624 }
12625 }
12626
12627 if (data.quiet == 0) log_info ("");
12628
12629 /**
12630 * devices init
12631 */
12632
12633 int *temp_retain_fanspeed_value = (int *) mycalloc (devices_cnt, sizeof (int));
12634
12635 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (devices_cnt, sizeof (ADLOD6MemClockState));
12636
12637 int *od_power_control_status = (int *) mycalloc (devices_cnt, sizeof (int));
12638
12639 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (devices_cnt, sizeof (hc_device_param_t));
12640
12641 data.devices_param = devices_param;
12642
12643 for (uint device_id = 0; device_id < devices_cnt; device_id++)
12644 {
12645 hc_device_param_t *device_param = &data.devices_param[device_id];
12646
12647 cl_device_id device = devices[device_id];
12648
12649 device_param->device = device;
12650
12651 cl_device_type device_type = 0;
12652
12653 hc_clGetDeviceInfo (device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12654
12655 device_param->device_type = device_type;
12656
12657 cl_uint max_compute_units = 0;
12658
12659 hc_clGetDeviceInfo (device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (max_compute_units), &max_compute_units, NULL);
12660
12661 device_param->device_processors = max_compute_units;
12662
12663 cl_ulong max_mem_alloc_size = 0;
12664
12665 hc_clGetDeviceInfo (device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (max_mem_alloc_size), &max_mem_alloc_size, NULL);
12666
12667 device_param->device_maxmem_alloc = max_mem_alloc_size;
12668
12669 cl_uint vendor_id = 0;
12670
12671 hc_clGetDeviceInfo (device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12672
12673 device_param->vendor_id = vendor_id;
12674
12675 char tmp[INFOSZ], t1[64];
12676
12677 memset (tmp, 0, sizeof (tmp));
12678
12679 hc_clGetDeviceInfo (device, CL_DEVICE_NAME, sizeof (tmp), &tmp, NULL);
12680
12681 device_param->device_name = mystrdup (tmp);
12682
12683 memset (tmp, 0, sizeof (tmp));
12684
12685 hc_clGetDeviceInfo (device, CL_DEVICE_VERSION, sizeof (tmp), &tmp, NULL);
12686
12687 if (strstr (tmp, "pocl"))
12688 {
12689 // 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
12690 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12691
12692 cl_uint vendor_id = 0xffff;
12693
12694 device_param->vendor_id = vendor_id;
12695 }
12696
12697 memset (t1, 0, sizeof (t1));
12698
12699 sscanf (tmp, "%*16s %*16s %*16s (%[^)]16s)", t1);
12700
12701 device_param->device_version = mystrdup (t1);
12702
12703 memset (tmp, 0, sizeof (tmp));
12704
12705 hc_clGetDeviceInfo (device, CL_DRIVER_VERSION, sizeof (tmp), &tmp, NULL);
12706
12707 device_param->driver_version = mystrdup (tmp);
12708
12709 // create some filename that is easier to read on cached folder
12710
12711 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);
12712
12713 uint device_name_digest[4];
12714
12715 device_name_digest[0] = 0;
12716 device_name_digest[1] = 0;
12717 device_name_digest[2] = 0;
12718 device_name_digest[3] = 0;
12719
12720 md5_64 ((uint *) tmp, device_name_digest);
12721
12722 sprintf (tmp, "%08x", device_name_digest[0]);
12723
12724 device_param->device_name_chksum = mystrdup (tmp);
12725
12726 if (device_type & CL_DEVICE_TYPE_CPU)
12727 {
12728 cl_uint device_processor_cores = 1;
12729
12730 device_param->device_processor_cores = device_processor_cores;
12731 }
12732
12733 if (device_type & CL_DEVICE_TYPE_GPU)
12734 {
12735 if (vendor_id == VENDOR_ID_AMD)
12736 {
12737 cl_uint device_processor_cores = 0;
12738
12739 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12740
12741 hc_clGetDeviceInfo (device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12742
12743 device_param->device_processor_cores = device_processor_cores;
12744 }
12745 else if (vendor_id == VENDOR_ID_NV)
12746 {
12747 cl_uint kernel_exec_timeout = 0;
12748
12749 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12750
12751 hc_clGetDeviceInfo (device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12752
12753 device_param->kernel_exec_timeout = kernel_exec_timeout;
12754
12755 cl_uint device_processor_cores = 0;
12756
12757 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12758
12759 hc_clGetDeviceInfo (device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12760
12761 device_param->device_processor_cores = device_processor_cores;
12762
12763 cl_uint sm_minor = 0;
12764 cl_uint sm_major = 0;
12765
12766 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12767 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12768
12769 hc_clGetDeviceInfo (device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12770 hc_clGetDeviceInfo (device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12771
12772 device_param->sm_minor = sm_minor;
12773 device_param->sm_major = sm_major;
12774 }
12775 else
12776 {
12777 cl_uint device_processor_cores = 1;
12778
12779 device_param->device_processor_cores = device_processor_cores;
12780 }
12781 }
12782
12783 /**
12784 * common driver check
12785 */
12786
12787 if (device_type & CL_DEVICE_TYPE_GPU)
12788 {
12789 if (vendor_id == VENDOR_ID_NV)
12790 {
12791 if (device_param->kernel_exec_timeout != 0)
12792 {
12793 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);
12794 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12795 }
12796 }
12797 else if (vendor_id == VENDOR_ID_AMD)
12798 {
12799 int catalyst_check = (force == 1) ? 0 : 1;
12800
12801 int catalyst_warn = 0;
12802
12803 int catalyst_broken = 0;
12804
12805 if (catalyst_check == 1)
12806 {
12807 catalyst_warn = 1;
12808
12809 // v14.9 and higher
12810 if ((atoi (device_param->device_version) >= 1573)
12811 && (atoi (device_param->driver_version) >= 1573))
12812 {
12813 catalyst_warn = 0;
12814 }
12815
12816 catalyst_check = 0;
12817 }
12818
12819 if (catalyst_broken == 1)
12820 {
12821 log_error ("");
12822 log_error ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12823 log_error ("It will pass over cracked hashes and does not report them as cracked");
12824 log_error ("You are STRONGLY encouraged not to use it");
12825 log_error ("You can use --force to override this but do not post error reports if you do so");
12826
12827 return (-1);
12828 }
12829
12830 if (catalyst_warn == 1)
12831 {
12832 log_error ("");
12833 log_error ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12834 log_error ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12835 log_error ("See oclHashcat's homepage for official supported catalyst drivers");
12836 #ifdef _WIN
12837 log_error ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12838 #endif
12839 log_error ("You can use --force to override this but do not post error reports if you do so");
12840
12841 return (-1);
12842 }
12843 }
12844 }
12845 }
12846
12847 /**
12848 * HM devices: init
12849 */
12850
12851 hm_attrs_t hm_adapters_nv[DEVICES_MAX];
12852 hm_attrs_t hm_adapters_amd[DEVICES_MAX];
12853
12854 memset (hm_adapters_nv, 0, sizeof (hm_adapters_nv));
12855 memset (hm_adapters_amd, 0, sizeof (hm_adapters_amd));
12856
12857 if (gpu_temp_disable == 0)
12858 {
12859 #ifdef WIN
12860 if (NvAPI_Initialize () == NVAPI_OK)
12861 {
12862 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX];
12863
12864 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12865
12866 int tmp_out = 0;
12867
12868 for (int i = 0; i < tmp_in; i++)
12869 {
12870 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12871 }
12872
12873 for (int i = 0; i < tmp_out; i++)
12874 {
12875 NvU32 speed;
12876
12877 if (NvAPI_GPU_GetTachReading (hm_adapters_nv[i].adapter_index.nv, &speed) != NVAPI_NOT_SUPPORTED) hm_adapters_nv[i].fan_supported = 1;
12878 }
12879 }
12880 #endif
12881
12882 #ifdef LINUX
12883 HM_LIB hm_dll_nv = hm_init (VENDOR_ID_NV);
12884
12885 data.hm_dll_nv = hm_dll_nv;
12886
12887 if (hm_dll_nv)
12888 {
12889 if (hc_NVML_nvmlInit (hm_dll_nv) == NVML_SUCCESS)
12890 {
12891 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX];
12892
12893 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12894
12895 int tmp_out = 0;
12896
12897 for (int i = 0; i < tmp_in; i++)
12898 {
12899 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12900 }
12901
12902 for (int i = 0; i < tmp_out; i++)
12903 {
12904 unsigned int speed;
12905
12906 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;
12907 }
12908 }
12909 }
12910 #endif
12911
12912 HM_LIB hm_dll_amd = hm_init (VENDOR_ID_AMD);
12913
12914 data.hm_dll_amd = hm_dll_amd;
12915
12916 if (hm_dll_amd)
12917 {
12918 if (hc_ADL_Main_Control_Create (hm_dll_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
12919 {
12920 // total number of adapters
12921
12922 int hm_adapters_num;
12923
12924 if (get_adapters_num_amd (hm_dll_amd, &hm_adapters_num) != 0) return (-1);
12925
12926 // adapter info
12927
12928 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (hm_dll_amd, hm_adapters_num);
12929
12930 if (lpAdapterInfo == NULL) return (-1);
12931
12932 // get a list (of ids of) valid/usable adapters
12933
12934 int num_adl_adapters = 0;
12935
12936 uint32_t *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
12937
12938 if (num_adl_adapters > 0)
12939 {
12940 hc_thread_mutex_lock (mux_adl);
12941
12942 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
12943
12944 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12945
12946 hm_get_overdrive_version (hm_dll_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12947 hm_check_fanspeed_control (hm_dll_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12948
12949 hc_thread_mutex_unlock (mux_adl);
12950 }
12951
12952 myfree (valid_adl_device_list);
12953 myfree (lpAdapterInfo);
12954 }
12955 }
12956 }
12957
12958 /**
12959 * HM devices: copy
12960 */
12961
12962 if (gpu_temp_disable == 0)
12963 {
12964 for (uint device_id = 0; device_id < devices_cnt; device_id++)
12965 {
12966 hc_device_param_t *device_param = &data.devices_param[device_id];
12967
12968 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
12969
12970 cl_uint device_id_on_platform = devices_plf[device_id];
12971
12972 if (device_param->vendor_id == VENDOR_ID_NV)
12973 {
12974 memcpy (&data.hm_device[device_id], &hm_adapters_nv[device_id_on_platform], sizeof (hm_attrs_t));
12975 }
12976
12977 if (device_param->vendor_id == VENDOR_ID_AMD)
12978 {
12979 memcpy (&data.hm_device[device_id], &hm_adapters_amd[device_id_on_platform], sizeof (hm_attrs_t));
12980 }
12981 }
12982 }
12983
12984 /*
12985 * Temporary fix:
12986 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
12987 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
12988 * were not working @ full speed (setting hc_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
12989 * Driver / ADL bug?
12990 */
12991
12992 if (powertune_enable == 1)
12993 {
12994 hc_thread_mutex_lock (mux_adl);
12995
12996 for (uint device_id = 0; device_id < devices_cnt; device_id++)
12997 {
12998 if (data.hm_device[device_id].od_version == 6)
12999 {
13000 // set powertune value only
13001
13002 int powertune_supported = 0;
13003
13004 int ADL_rc = 0;
13005
13006 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13007 {
13008 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13009
13010 return (-1);
13011 }
13012
13013 if (powertune_supported != 0)
13014 {
13015 // powertune set
13016 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13017
13018 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13019 {
13020 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13021
13022 return (-1);
13023 }
13024
13025 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13026 {
13027 log_error ("ERROR: Failed to set new ADL PowerControl values");
13028
13029 return (-1);
13030 }
13031 }
13032 }
13033 }
13034
13035 hc_thread_mutex_unlock (mux_adl);
13036 }
13037
13038 uint kernel_blocks_all = 0;
13039
13040 for (uint device_id = 0; device_id < devices_cnt; device_id++)
13041 {
13042 /**
13043 * host buffer
13044 */
13045
13046 hc_device_param_t *device_param = &data.devices_param[device_id];
13047
13048 /**
13049 * device properties
13050 */
13051
13052 char *device_name_chksum = device_param->device_name_chksum;
13053
13054 uint device_processors = device_param->device_processors;
13055
13056 uint device_processor_cores = device_param->device_processor_cores;
13057
13058 cl_device_type device_type = device_param->device_type;
13059
13060 /**
13061 * create context for each device
13062 */
13063
13064 device_param->context = hc_clCreateContext (NULL, 1, &device_param->device, NULL, NULL);
13065
13066 /**
13067 * create command-queue
13068 */
13069
13070 // not support with NV
13071 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13072
13073 device_param->command_queue = hc_clCreateCommandQueue (device_param->context, device_param->device, 0);
13074
13075 /**
13076 * create input buffers on device
13077 */
13078
13079 uint kernel_threads = KERNEL_THREADS;
13080
13081 // bcrypt
13082 if (hash_mode == 3200) kernel_threads = 8;
13083 if (hash_mode == 9000) kernel_threads = 8;
13084
13085 if (device_type & CL_DEVICE_TYPE_CPU)
13086 {
13087 // CPU still need lots of workitems, don't know why...
13088 // for testing phase, lets start with this
13089
13090 kernel_accel = 1;
13091 }
13092
13093 uint kernel_power = device_processors * kernel_threads * kernel_accel;
13094 uint kernel_blocks = kernel_power;
13095
13096 device_param->kernel_threads = kernel_threads;
13097 device_param->kernel_power_user = kernel_power;
13098 device_param->kernel_blocks_user = kernel_blocks;
13099
13100 kernel_blocks_all += kernel_blocks;
13101
13102 uint size_pws = kernel_power * sizeof (pw_t);
13103
13104 uint size_tmps = 4;
13105
13106 switch (hash_mode)
13107 {
13108 case 400: size_tmps = kernel_blocks * sizeof (phpass_tmp_t); break;
13109 case 500: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13110 case 501: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13111 case 1600: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13112 case 1800: size_tmps = kernel_blocks * sizeof (sha512crypt_tmp_t); break;
13113 case 2100: size_tmps = kernel_blocks * sizeof (dcc2_tmp_t); break;
13114 case 2500: size_tmps = kernel_blocks * sizeof (wpa_tmp_t); break;
13115 case 3200: size_tmps = kernel_blocks * sizeof (bcrypt_tmp_t); break;
13116 case 5200: size_tmps = kernel_blocks * sizeof (pwsafe3_tmp_t); break;
13117 case 5800: size_tmps = kernel_blocks * sizeof (androidpin_tmp_t); break;
13118 case 6211:
13119 case 6212:
13120 case 6213: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13121 case 6221:
13122 case 6222:
13123 case 6223: size_tmps = kernel_blocks * sizeof (tc64_tmp_t); break;
13124 case 6231:
13125 case 6232:
13126 case 6233: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13127 case 6241:
13128 case 6242:
13129 case 6243: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13130 case 6300: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13131 case 6400: size_tmps = kernel_blocks * sizeof (sha256aix_tmp_t); break;
13132 case 6500: size_tmps = kernel_blocks * sizeof (sha512aix_tmp_t); break;
13133 case 6600: size_tmps = kernel_blocks * sizeof (agilekey_tmp_t); break;
13134 case 6700: size_tmps = kernel_blocks * sizeof (sha1aix_tmp_t); break;
13135 case 6800: size_tmps = kernel_blocks * sizeof (lastpass_tmp_t); break;
13136 case 7100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13137 case 7200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13138 case 7400: size_tmps = kernel_blocks * sizeof (sha256crypt_tmp_t); break;
13139 case 7900: size_tmps = kernel_blocks * sizeof (drupal7_tmp_t); break;
13140 case 8200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13141 case 8800: size_tmps = kernel_blocks * sizeof (androidfde_tmp_t); break;
13142 case 8900: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13143 case 9000: size_tmps = kernel_blocks * sizeof (pwsafe2_tmp_t); break;
13144 case 9100: size_tmps = kernel_blocks * sizeof (lotus8_tmp_t); break;
13145 case 9200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13146 case 9300: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13147 case 9400: size_tmps = kernel_blocks * sizeof (office2007_tmp_t); break;
13148 case 9500: size_tmps = kernel_blocks * sizeof (office2010_tmp_t); break;
13149 case 9600: size_tmps = kernel_blocks * sizeof (office2013_tmp_t); break;
13150 case 10000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13151 case 10200: size_tmps = kernel_blocks * sizeof (cram_md5_t); break;
13152 case 10300: size_tmps = kernel_blocks * sizeof (saph_sha1_tmp_t); break;
13153 case 10500: size_tmps = kernel_blocks * sizeof (pdf14_tmp_t); break;
13154 case 10700: size_tmps = kernel_blocks * sizeof (pdf17l8_tmp_t); break;
13155 case 10900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13156 case 11300: size_tmps = kernel_blocks * sizeof (bitcoin_wallet_tmp_t); break;
13157 case 11600: size_tmps = kernel_blocks * sizeof (seven_zip_tmp_t); break;
13158 case 11900: size_tmps = kernel_blocks * sizeof (pbkdf2_md5_tmp_t); break;
13159 case 12000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha1_tmp_t); break;
13160 case 12100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13161 case 12200: size_tmps = kernel_blocks * sizeof (ecryptfs_tmp_t); break;
13162 case 12300: size_tmps = kernel_blocks * sizeof (oraclet_tmp_t); break;
13163 case 12400: size_tmps = kernel_blocks * sizeof (bsdicrypt_tmp_t); break;
13164 case 12500: size_tmps = kernel_blocks * sizeof (rar3_tmp_t); break;
13165 case 12700: size_tmps = kernel_blocks * sizeof (mywallet_tmp_t); break;
13166 case 12800: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13167 case 12900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13168 case 13000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13169 };
13170
13171 uint size_hooks = 4;
13172
13173 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13174 {
13175 // insert correct hook size
13176 }
13177
13178 // we can optimize some stuff here...
13179
13180 device_param->size_pws = size_pws;
13181 device_param->size_tmps = size_tmps;
13182 device_param->size_hooks = size_hooks;
13183
13184 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13185 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13186
13187 device_param->size_root_css = size_root_css;
13188 device_param->size_markov_css = size_markov_css;
13189
13190 uint size_results = KERNEL_THREADS * sizeof (uint);
13191
13192 device_param->size_results = size_results;
13193
13194 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13195 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13196
13197 uint size_plains = digests_cnt * sizeof (plain_t);
13198 uint size_salts = salts_cnt * sizeof (salt_t);
13199 uint size_esalts = salts_cnt * esalt_size;
13200
13201 device_param->size_plains = size_plains;
13202 device_param->size_digests = size_digests;
13203 device_param->size_shown = size_shown;
13204 device_param->size_salts = size_salts;
13205
13206 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13207 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13208 uint size_tm = 32 * sizeof (bs_word_t);
13209
13210 uint64_t size_scryptV = 1;
13211
13212 if ((hash_mode == 8900) || (hash_mode == 9300))
13213 {
13214 uint tmto_start = 0;
13215 uint tmto_stop = 10;
13216
13217 if (scrypt_tmto)
13218 {
13219 tmto_start = scrypt_tmto;
13220 }
13221 else
13222 {
13223 // in case the user did not specify the tmto manually
13224 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13225 // but set the lower end only in case the user has a device with too less memory
13226
13227 if (hash_mode == 8900)
13228 {
13229 if (device_param->vendor_id == VENDOR_ID_AMD)
13230 {
13231 tmto_start = 1;
13232 }
13233 else if (device_param->vendor_id == VENDOR_ID_NV)
13234 {
13235 tmto_start = 3;
13236 }
13237 }
13238 else if (hash_mode == 9300)
13239 {
13240 if (device_param->vendor_id == VENDOR_ID_AMD)
13241 {
13242 tmto_start = 3;
13243 }
13244 else if (device_param->vendor_id == VENDOR_ID_NV)
13245 {
13246 tmto_start = 5;
13247 }
13248 }
13249 }
13250
13251 if (quiet == 0) log_info ("");
13252
13253 uint shader_per_mp = 1;
13254
13255 if (device_param->vendor_id == VENDOR_ID_AMD)
13256 {
13257 shader_per_mp = 8;
13258 }
13259 else if (device_param->vendor_id == VENDOR_ID_NV)
13260 {
13261 shader_per_mp = 32;
13262 }
13263
13264 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13265 {
13266 // TODO: in theory the following calculation needs to be done per salt, not global
13267 // we assume all hashes have the same scrypt settings
13268
13269 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13270
13271 size_scryptV /= 1 << tmto;
13272
13273 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13274
13275 if (size_scryptV > device_param->device_maxmem_alloc)
13276 {
13277 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13278
13279 continue;
13280 }
13281
13282 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13283 {
13284 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13285 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13286 }
13287
13288 break;
13289 }
13290
13291 if (data.salts_buf[0].scrypt_phy == 0)
13292 {
13293 log_error ("ERROR: can't allocate enough device memory");
13294
13295 return -1;
13296 }
13297
13298 if (quiet == 0) log_info ("");
13299 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13300 }
13301
13302 /**
13303 * default building options
13304 */
13305
13306 char build_opts[1024];
13307
13308 // we don't have sm_* on vendors not NV but it doesn't matter
13309
13310 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);
13311
13312 /**
13313 * a0 kernel, required for some fast hashes to make weak_hash_check work
13314 */
13315
13316 const uint add_flag = OPTS_TYPE_PT_ADD01
13317 | OPTS_TYPE_PT_ADD02
13318 | OPTS_TYPE_PT_ADD80
13319 | OPTS_TYPE_PT_ADDBITS14
13320 | OPTS_TYPE_PT_ADDBITS15
13321 | OPTS_TYPE_ST_ADD01
13322 | OPTS_TYPE_ST_ADD02
13323 | OPTS_TYPE_ST_ADD80
13324 | OPTS_TYPE_ST_ADDBITS14
13325 | OPTS_TYPE_ST_ADDBITS15
13326 | OPTS_TYPE_PT_BITSLICE;
13327
13328 if ((weak_hash_threshold) && (attack_exec == ATTACK_EXEC_INSIDE_KERNEL) && (opts_type & add_flag))
13329 {
13330 /**
13331 * kernel source filename
13332 */
13333
13334 char source_file[256];
13335
13336 memset (source_file, 0, sizeof (source_file));
13337
13338 generate_source_kernel_filename (attack_exec, ATTACK_KERN_STRAIGHT, kern_type, shared_dir, source_file);
13339
13340 struct stat sst;
13341
13342 if (stat (source_file, &sst) == -1)
13343 {
13344 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13345
13346 return -1;
13347 }
13348
13349 /**
13350 * kernel cached filename
13351 */
13352
13353 char cached_file[256];
13354
13355 memset (cached_file, 0, sizeof (cached_file));
13356
13357 generate_cached_kernel_filename (attack_exec, ATTACK_KERN_STRAIGHT, kern_type, profile_dir, device_name_chksum, cached_file);
13358
13359 int cached = 1;
13360
13361 struct stat cst;
13362
13363 if (stat (cached_file, &cst) == -1)
13364 {
13365 cached = 0;
13366 }
13367
13368 /**
13369 * kernel compile or load
13370 */
13371
13372 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13373
13374 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13375
13376 if (force_jit_compilation == 0)
13377 {
13378 if (cached == 0)
13379 {
13380 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13381
13382 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13383
13384 device_param->program_weak = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13385
13386 hc_clBuildProgram (device_param->program_weak, 1, &device_param->device, build_opts, NULL, NULL);
13387
13388 size_t binary_size;
13389
13390 clGetProgramInfo (device_param->program_weak, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13391
13392 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13393
13394 clGetProgramInfo (device_param->program_weak, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13395
13396 writeProgramBin (cached_file, binary, binary_size);
13397
13398 local_free (binary);
13399 }
13400 else
13401 {
13402 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13403
13404 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13405
13406 device_param->program_weak = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13407
13408 hc_clBuildProgram (device_param->program_weak, 1, &device_param->device, build_opts, NULL, NULL);
13409 }
13410 }
13411 else
13412 {
13413 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13414
13415 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13416
13417 device_param->program_weak = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13418
13419 if (force_jit_compilation == 1500)
13420 {
13421 sprintf (build_opts, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13422 }
13423 else if (force_jit_compilation == 8900)
13424 {
13425 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);
13426 }
13427
13428 hc_clBuildProgram (device_param->program_weak, 1, &device_param->device, build_opts, NULL, NULL);
13429 }
13430
13431 local_free (kernel_lengths);
13432 local_free (kernel_sources[0]);
13433 local_free (kernel_sources);
13434
13435 // this is mostly for debug
13436
13437 size_t ret_val_size = 0;
13438
13439 clGetProgramBuildInfo (device_param->program_weak, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13440
13441 if (ret_val_size > 2)
13442 {
13443 char *build_log = (char *) mymalloc (ret_val_size + 1);
13444
13445 memset (build_log, 0, ret_val_size + 1);
13446
13447 clGetProgramBuildInfo (device_param->program_weak, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13448
13449 puts (build_log);
13450
13451 myfree (build_log);
13452 }
13453 }
13454
13455 /**
13456 * main kernel
13457 */
13458
13459 {
13460 /**
13461 * kernel source filename
13462 */
13463
13464 char source_file[256];
13465
13466 memset (source_file, 0, sizeof (source_file));
13467
13468 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13469
13470 struct stat sst;
13471
13472 if (stat (source_file, &sst) == -1)
13473 {
13474 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13475
13476 return -1;
13477 }
13478
13479 /**
13480 * kernel cached filename
13481 */
13482
13483 char cached_file[256];
13484
13485 memset (cached_file, 0, sizeof (cached_file));
13486
13487 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13488
13489 int cached = 1;
13490
13491 struct stat cst;
13492
13493 if (stat (cached_file, &cst) == -1)
13494 {
13495 cached = 0;
13496 }
13497
13498 /**
13499 * kernel compile or load
13500 */
13501
13502 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13503
13504 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13505
13506 if (force_jit_compilation == 0)
13507 {
13508 if (cached == 0)
13509 {
13510 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13511
13512 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13513
13514 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13515
13516 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13517
13518 size_t binary_size;
13519
13520 clGetProgramInfo (device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13521
13522 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13523
13524 clGetProgramInfo (device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13525
13526 writeProgramBin (cached_file, binary, binary_size);
13527
13528 local_free (binary);
13529 }
13530 else
13531 {
13532 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13533
13534 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13535
13536 device_param->program = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13537
13538 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13539 }
13540 }
13541 else
13542 {
13543 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13544
13545 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13546
13547 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13548
13549 if (force_jit_compilation == 1500)
13550 {
13551 sprintf (build_opts, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13552 }
13553 else if (force_jit_compilation == 8900)
13554 {
13555 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);
13556 }
13557
13558 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13559 }
13560
13561 local_free (kernel_lengths);
13562 local_free (kernel_sources[0]);
13563 local_free (kernel_sources);
13564
13565 // this is mostly for debug
13566
13567 size_t ret_val_size = 0;
13568
13569 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13570
13571 if (ret_val_size > 2)
13572 {
13573 char *build_log = (char *) mymalloc (ret_val_size + 1);
13574
13575 memset (build_log, 0, ret_val_size + 1);
13576
13577 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13578
13579 puts (build_log);
13580
13581 myfree (build_log);
13582 }
13583 }
13584
13585 /**
13586 * word generator kernel
13587 */
13588
13589 if (attack_mode != ATTACK_MODE_STRAIGHT)
13590 {
13591 /**
13592 * kernel mp source filename
13593 */
13594
13595 char source_file[256];
13596
13597 memset (source_file, 0, sizeof (source_file));
13598
13599 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
13600
13601 struct stat sst;
13602
13603 if (stat (source_file, &sst) == -1)
13604 {
13605 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13606
13607 return -1;
13608 }
13609
13610 /**
13611 * kernel mp cached filename
13612 */
13613
13614 char cached_file[256];
13615
13616 memset (cached_file, 0, sizeof (cached_file));
13617
13618 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
13619
13620 int cached = 1;
13621
13622 struct stat cst;
13623
13624 if (stat (cached_file, &cst) == -1)
13625 {
13626 cached = 0;
13627 }
13628
13629 /**
13630 * kernel compile or load
13631 */
13632
13633 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13634
13635 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13636
13637 if (cached == 0)
13638 {
13639 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13640
13641 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13642
13643 device_param->program_mp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13644
13645 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13646
13647 size_t binary_size;
13648
13649 clGetProgramInfo (device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13650
13651 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13652
13653 clGetProgramInfo (device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13654
13655 writeProgramBin (cached_file, binary, binary_size);
13656
13657 local_free (binary);
13658 }
13659 else
13660 {
13661 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13662
13663 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13664
13665 device_param->program_mp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13666
13667 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13668 }
13669
13670 local_free (kernel_lengths);
13671 local_free (kernel_sources[0]);
13672 local_free (kernel_sources);
13673
13674 // this is mostly for debug
13675
13676 size_t ret_val_size = 0;
13677
13678 clGetProgramBuildInfo (device_param->program_mp, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13679
13680 if (ret_val_size > 2)
13681 {
13682 char *build_log = (char *) mymalloc (ret_val_size + 1);
13683
13684 memset (build_log, 0, ret_val_size + 1);
13685
13686 clGetProgramBuildInfo (device_param->program_mp, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13687
13688 puts (build_log);
13689
13690 myfree (build_log);
13691 }
13692 }
13693
13694 /**
13695 * amplifier kernel
13696 */
13697
13698 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13699 {
13700
13701 }
13702 else
13703 {
13704 /**
13705 * kernel amp source filename
13706 */
13707
13708 char source_file[256];
13709
13710 memset (source_file, 0, sizeof (source_file));
13711
13712 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
13713
13714 struct stat sst;
13715
13716 if (stat (source_file, &sst) == -1)
13717 {
13718 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13719
13720 return -1;
13721 }
13722
13723 /**
13724 * kernel amp cached filename
13725 */
13726
13727 char cached_file[256];
13728
13729 memset (cached_file, 0, sizeof (cached_file));
13730
13731 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
13732
13733 int cached = 1;
13734
13735 struct stat cst;
13736
13737 if (stat (cached_file, &cst) == -1)
13738 {
13739 cached = 0;
13740 }
13741
13742 /**
13743 * kernel compile or load
13744 */
13745
13746 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13747
13748 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13749
13750 if (cached == 0)
13751 {
13752 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13753
13754 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13755
13756 device_param->program_amp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13757
13758 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13759
13760 size_t binary_size;
13761
13762 clGetProgramInfo (device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13763
13764 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13765
13766 clGetProgramInfo (device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13767
13768 writeProgramBin (cached_file, binary, binary_size);
13769
13770 local_free (binary);
13771 }
13772 else
13773 {
13774 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13775
13776 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13777
13778 device_param->program_amp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13779
13780 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13781 }
13782
13783 local_free (kernel_lengths);
13784 local_free (kernel_sources[0]);
13785 local_free (kernel_sources);
13786
13787 // this is mostly for debug
13788
13789 size_t ret_val_size = 0;
13790
13791 clGetProgramBuildInfo (device_param->program_amp, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13792
13793 if (ret_val_size > 2)
13794 {
13795 char *build_log = (char *) mymalloc (ret_val_size + 1);
13796
13797 memset (build_log, 0, ret_val_size + 1);
13798
13799 clGetProgramBuildInfo (device_param->program_amp, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13800
13801 puts (build_log);
13802
13803 myfree (build_log);
13804 }
13805 }
13806
13807 /**
13808 * global buffers
13809 */
13810
13811 device_param->d_pws_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13812 device_param->d_pws_amp_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13813 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
13814 device_param->d_tmps = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
13815 device_param->d_hooks = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
13816 device_param->d_bitmap_s1_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13817 device_param->d_bitmap_s1_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13818 device_param->d_bitmap_s1_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13819 device_param->d_bitmap_s1_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13820 device_param->d_bitmap_s2_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13821 device_param->d_bitmap_s2_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13822 device_param->d_bitmap_s2_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13823 device_param->d_bitmap_s2_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13824 device_param->d_plain_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
13825 device_param->d_digests_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
13826 device_param->d_digests_shown = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
13827 device_param->d_salt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
13828 device_param->d_result = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
13829 device_param->d_scryptV_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
13830
13831 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_a, CL_TRUE, 0, bitmap_size, bitmap_s1_a, 0, NULL, NULL);
13832 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_b, CL_TRUE, 0, bitmap_size, bitmap_s1_b, 0, NULL, NULL);
13833 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_c, CL_TRUE, 0, bitmap_size, bitmap_s1_c, 0, NULL, NULL);
13834 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_d, CL_TRUE, 0, bitmap_size, bitmap_s1_d, 0, NULL, NULL);
13835 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_a, CL_TRUE, 0, bitmap_size, bitmap_s2_a, 0, NULL, NULL);
13836 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_b, CL_TRUE, 0, bitmap_size, bitmap_s2_b, 0, NULL, NULL);
13837 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_c, CL_TRUE, 0, bitmap_size, bitmap_s2_c, 0, NULL, NULL);
13838 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_d, CL_TRUE, 0, bitmap_size, bitmap_s2_d, 0, NULL, NULL);
13839 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
13840 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
13841 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
13842
13843 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
13844 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
13845 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
13846 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
13847 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
13848 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
13849 run_kernel_bzero (device_param, device_param->d_result, size_results);
13850
13851 /**
13852 * special buffers
13853 */
13854
13855 if (attack_kern == ATTACK_KERN_STRAIGHT)
13856 {
13857 device_param->d_rules = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
13858
13859 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
13860 }
13861 else if (attack_kern == ATTACK_KERN_COMBI)
13862 {
13863 device_param->d_combs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13864 device_param->d_combs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13865 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13866 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13867
13868 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
13869 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
13870 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13871 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13872 }
13873 else if (attack_kern == ATTACK_KERN_BF)
13874 {
13875 device_param->d_bfs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13876 device_param->d_bfs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13877 device_param->d_tm_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
13878 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13879 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13880
13881 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
13882 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
13883 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
13884 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13885 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13886 }
13887
13888 if (size_esalts)
13889 {
13890 device_param->d_esalt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
13891
13892 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
13893 }
13894
13895 /**
13896 * main host data
13897 */
13898
13899 uint *result = (uint *) mymalloc (size_results);
13900
13901 memset (result, 0, size_results);
13902
13903 device_param->result = result;
13904
13905 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
13906
13907 memset (pws_buf, 0, size_pws);
13908
13909 device_param->pws_buf = pws_buf;
13910
13911 pw_cache_t *pw_caches = (pw_cache_t *) mycalloc (64, sizeof (pw_cache_t));
13912
13913 for (int i = 0; i < 64; i++)
13914 {
13915 pw_caches[i].pw_buf.pw_len = i;
13916 pw_caches[i].cnt = 0;
13917 }
13918
13919 device_param->pw_caches = pw_caches;
13920
13921 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
13922
13923 device_param->combs_buf = combs_buf;
13924
13925 void *hooks_buf = mymalloc (size_hooks);
13926
13927 device_param->hooks_buf = hooks_buf;
13928
13929 device_param->pw_transpose = pw_transpose_to_hi1;
13930 device_param->pw_add = pw_add_to_hc1;
13931
13932 /**
13933 * kernel args
13934 */
13935
13936 device_param->kernel_params_buf32[21] = bitmap_mask;
13937 device_param->kernel_params_buf32[22] = bitmap_shift1;
13938 device_param->kernel_params_buf32[23] = bitmap_shift2;
13939 device_param->kernel_params_buf32[24] = 0; // salt_pos
13940 device_param->kernel_params_buf32[25] = 0; // loop_pos
13941 device_param->kernel_params_buf32[26] = 0; // loop_cnt
13942 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
13943 device_param->kernel_params_buf32[28] = 0; // digests_cnt
13944 device_param->kernel_params_buf32[29] = 0; // digests_offset
13945 device_param->kernel_params_buf32[30] = 0; // combs_mode
13946 device_param->kernel_params_buf32[31] = 0; // gid_max
13947
13948 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13949 ? &device_param->d_pws_buf
13950 : &device_param->d_pws_amp_buf;
13951 device_param->kernel_params[ 1] = &device_param->d_rules_c;
13952 device_param->kernel_params[ 2] = &device_param->d_combs_c;
13953 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
13954 device_param->kernel_params[ 4] = &device_param->d_tmps;
13955 device_param->kernel_params[ 5] = &device_param->d_hooks;
13956 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
13957 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
13958 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
13959 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
13960 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
13961 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
13962 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
13963 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
13964 device_param->kernel_params[14] = &device_param->d_plain_bufs;
13965 device_param->kernel_params[15] = &device_param->d_digests_buf;
13966 device_param->kernel_params[16] = &device_param->d_digests_shown;
13967 device_param->kernel_params[17] = &device_param->d_salt_bufs;
13968 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
13969 device_param->kernel_params[19] = &device_param->d_result;
13970 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
13971 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
13972 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
13973 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
13974 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
13975 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
13976 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
13977 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
13978 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
13979 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
13980 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
13981 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
13982
13983 device_param->kernel_params_mp_buf64[3] = 0;
13984 device_param->kernel_params_mp_buf32[4] = 0;
13985 device_param->kernel_params_mp_buf32[5] = 0;
13986 device_param->kernel_params_mp_buf32[6] = 0;
13987 device_param->kernel_params_mp_buf32[7] = 0;
13988 device_param->kernel_params_mp_buf32[8] = 0;
13989
13990 device_param->kernel_params_mp[0] = NULL;
13991 device_param->kernel_params_mp[1] = NULL;
13992 device_param->kernel_params_mp[2] = NULL;
13993 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
13994 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
13995 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
13996 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
13997 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
13998 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
13999
14000 device_param->kernel_params_mp_l_buf64[3] = 0;
14001 device_param->kernel_params_mp_l_buf32[4] = 0;
14002 device_param->kernel_params_mp_l_buf32[5] = 0;
14003 device_param->kernel_params_mp_l_buf32[6] = 0;
14004 device_param->kernel_params_mp_l_buf32[7] = 0;
14005 device_param->kernel_params_mp_l_buf32[8] = 0;
14006 device_param->kernel_params_mp_l_buf32[9] = 0;
14007
14008 device_param->kernel_params_mp_l[0] = NULL;
14009 device_param->kernel_params_mp_l[1] = NULL;
14010 device_param->kernel_params_mp_l[2] = NULL;
14011 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14012 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14013 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14014 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14015 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14016 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14017 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14018
14019 device_param->kernel_params_mp_r_buf64[3] = 0;
14020 device_param->kernel_params_mp_r_buf32[4] = 0;
14021 device_param->kernel_params_mp_r_buf32[5] = 0;
14022 device_param->kernel_params_mp_r_buf32[6] = 0;
14023 device_param->kernel_params_mp_r_buf32[7] = 0;
14024 device_param->kernel_params_mp_r_buf32[8] = 0;
14025
14026 device_param->kernel_params_mp_r[0] = NULL;
14027 device_param->kernel_params_mp_r[1] = NULL;
14028 device_param->kernel_params_mp_r[2] = NULL;
14029 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14030 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14031 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14032 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14033 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14034 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14035
14036 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14037 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14038
14039 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14040 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14041 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14042 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14043 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14044 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14045 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14046
14047 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
14048
14049 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14050 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14051
14052 /**
14053 * kernel name
14054 */
14055
14056 char kernel_name[64];
14057
14058 memset (kernel_name, 0, sizeof (kernel_name));
14059
14060 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14061 {
14062 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14063 {
14064 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14065
14066 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
14067
14068 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14069
14070 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
14071
14072 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14073
14074 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
14075 }
14076 else
14077 {
14078 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14079
14080 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
14081
14082 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14083
14084 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
14085
14086 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14087
14088 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
14089 }
14090
14091 if (weak_hash_threshold)
14092 {
14093 if (opts_type & add_flag)
14094 {
14095 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14096 {
14097 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14098
14099 device_param->kernel_weak = hc_clCreateKernel (device_param->program_weak, kernel_name);
14100 }
14101 else
14102 {
14103 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14104
14105 device_param->kernel_weak = hc_clCreateKernel (device_param->program_weak, kernel_name);
14106 }
14107 }
14108 else
14109 {
14110 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14111 {
14112 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14113
14114 device_param->kernel_weak = hc_clCreateKernel (device_param->program, kernel_name);
14115 }
14116 else
14117 {
14118 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14119
14120 device_param->kernel_weak = hc_clCreateKernel (device_param->program, kernel_name);
14121 }
14122 }
14123 }
14124
14125 if (data.attack_mode == ATTACK_MODE_BF)
14126 {
14127 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14128 {
14129 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
14130
14131 device_param->kernel_tb = hc_clCreateKernel (device_param->program, kernel_name);
14132
14133 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14134
14135 device_param->kernel_tm = hc_clCreateKernel (device_param->program, kernel_name);
14136 }
14137 }
14138 }
14139 else
14140 {
14141 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14142
14143 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
14144
14145 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14146
14147 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
14148
14149 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14150
14151 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
14152
14153 if (opts_type & OPTS_TYPE_HOOK12)
14154 {
14155 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14156
14157 device_param->kernel12 = hc_clCreateKernel (device_param->program, kernel_name);
14158 }
14159
14160 if (opts_type & OPTS_TYPE_HOOK23)
14161 {
14162 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14163
14164 device_param->kernel23 = hc_clCreateKernel (device_param->program, kernel_name);
14165 }
14166 }
14167
14168 for (uint i = 0; i <= 20; i++)
14169 {
14170 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14171 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14172 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14173
14174 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14175 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14176
14177 if (weak_hash_threshold)
14178 {
14179 hc_clSetKernelArg (device_param->kernel_weak, i, sizeof (cl_mem), device_param->kernel_params[i]);
14180 }
14181 }
14182
14183 for (uint i = 21; i <= 31; i++)
14184 {
14185 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14186 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14187 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14188
14189 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14190 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14191
14192 if (weak_hash_threshold)
14193 {
14194 hc_clSetKernelArg (device_param->kernel_weak, i, sizeof (cl_uint), device_param->kernel_params[i]);
14195 }
14196 }
14197
14198 if (attack_mode == ATTACK_MODE_BF)
14199 {
14200 device_param->kernel_mp_l = hc_clCreateKernel (device_param->program_mp, "l_markov");
14201 device_param->kernel_mp_r = hc_clCreateKernel (device_param->program_mp, "r_markov");
14202
14203 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14204 {
14205 hc_clSetKernelArg (device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
14206
14207 hc_clSetKernelArg (device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14208 hc_clSetKernelArg (device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14209 }
14210 }
14211 else if (attack_mode == ATTACK_MODE_HYBRID1)
14212 {
14213 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
14214 }
14215 else if (attack_mode == ATTACK_MODE_HYBRID2)
14216 {
14217 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
14218 }
14219
14220 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14221 {
14222 // nothing to do
14223 }
14224 else
14225 {
14226 device_param->kernel_amp = hc_clCreateKernel (device_param->program_amp, "amp");
14227 }
14228
14229 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14230 {
14231 // nothing to do
14232 }
14233 else
14234 {
14235 for (uint i = 0; i < 5; i++)
14236 {
14237 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14238 }
14239
14240 for (uint i = 5; i < 7; i++)
14241 {
14242 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14243 }
14244 }
14245
14246 /**
14247 * Store initial fanspeed if gpu_temp_retain is enabled
14248 */
14249
14250 int gpu_temp_retain_set = 0;
14251
14252 if (gpu_temp_disable == 0)
14253 {
14254 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14255 {
14256 hc_thread_mutex_lock (mux_adl);
14257
14258 if (data.hm_device[device_id].fan_supported == 1)
14259 {
14260 if (gpu_temp_retain_chgd == 0)
14261 {
14262 uint cur_temp = 0;
14263 uint default_temp = 0;
14264
14265 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);
14266
14267 if (ADL_rc == ADL_OK)
14268 {
14269 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14270
14271 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14272
14273 // special case with multi gpu setups: always use minimum retain
14274
14275 if (gpu_temp_retain_set == 0)
14276 {
14277 gpu_temp_retain = gpu_temp_retain_target;
14278 gpu_temp_retain_set = 1;
14279 }
14280 else
14281 {
14282 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14283 }
14284
14285 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14286 }
14287 }
14288
14289 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14290
14291 temp_retain_fanspeed_value[device_id] = fan_speed;
14292
14293 if (fan_speed == -1)
14294 {
14295 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14296
14297 temp_retain_fanspeed_value[device_id] = 0;
14298 }
14299 }
14300
14301 hc_thread_mutex_unlock (mux_adl);
14302 }
14303 }
14304
14305 /**
14306 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14307 */
14308
14309 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14310 {
14311 hc_thread_mutex_lock (mux_adl);
14312
14313 if (data.hm_device[device_id].od_version == 6)
14314 {
14315 int ADL_rc;
14316
14317 // check powertune capabilities first, if not available then skip device
14318
14319 int powertune_supported = 0;
14320
14321 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14322 {
14323 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14324
14325 return (-1);
14326 }
14327
14328 if (powertune_supported != 0)
14329 {
14330 // powercontrol settings
14331
14332 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14333
14334 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14335 {
14336 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]);
14337 }
14338
14339 if (ADL_rc != ADL_OK)
14340 {
14341 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14342
14343 return (-1);
14344 }
14345
14346 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14347 {
14348 log_error ("ERROR: Failed to set new ADL PowerControl values");
14349
14350 return (-1);
14351 }
14352
14353 // clocks
14354
14355 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14356
14357 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14358
14359 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)
14360 {
14361 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14362
14363 return (-1);
14364 }
14365
14366 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14367
14368 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14369
14370 if ((ADL_rc = hc_ADL_Overdrive_Capabilities_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14371 {
14372 log_error ("ERROR: Failed to get ADL device capabilities");
14373
14374 return (-1);
14375 }
14376
14377 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14378 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14379
14380 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14381 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14382
14383 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14384 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14385
14386 // warning if profile has to low max values
14387
14388 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14389 {
14390 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14391 }
14392
14393 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14394 {
14395 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14396 }
14397
14398 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14399
14400 performance_state->iNumberOfPerformanceLevels = 2;
14401
14402 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14403 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14404 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14405 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14406
14407 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)
14408 {
14409 log_info ("ERROR: Failed to set ADL performance state");
14410
14411 return (-1);
14412 }
14413
14414 local_free (performance_state);
14415 }
14416 }
14417
14418 hc_thread_mutex_unlock (mux_adl);
14419 }
14420 }
14421
14422 data.kernel_blocks_all = kernel_blocks_all;
14423
14424 if (data.quiet == 0) log_info ("");
14425
14426 /**
14427 * Inform user which algorithm is checked and at which workload setting
14428 */
14429
14430 if (benchmark == 1)
14431 {
14432 quiet = 0;
14433
14434 data.quiet = quiet;
14435
14436 char *hash_type = strhashtype (data.hash_mode); // not a bug
14437
14438 log_info ("Hashtype: %s", hash_type);
14439 log_info ("Workload: %u loops, %u accel", kernel_loops, kernel_accel);
14440 log_info ("");
14441 }
14442
14443 /**
14444 * keep track of the progress
14445 */
14446
14447 data.words_progress_done = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
14448 data.words_progress_rejected = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
14449 data.words_progress_restored = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
14450
14451 /**
14452 * open filehandles
14453 */
14454
14455 #if _WIN
14456 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14457 {
14458 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14459
14460 return (-1);
14461 }
14462
14463 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14464 {
14465 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14466
14467 return (-1);
14468 }
14469
14470 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14471 {
14472 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14473
14474 return (-1);
14475 }
14476 #endif
14477
14478 /**
14479 * dictionary pad
14480 */
14481
14482 segment_size *= (1024 * 1024);
14483
14484 data.segment_size = segment_size;
14485
14486 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14487
14488 wl_data->buf = (char *) mymalloc (segment_size);
14489 wl_data->avail = segment_size;
14490 wl_data->incr = segment_size;
14491 wl_data->cnt = 0;
14492 wl_data->pos = 0;
14493
14494 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14495
14496 data.wordlist_mode = wordlist_mode;
14497
14498 cs_t *css_buf = NULL;
14499 uint css_cnt = 0;
14500 uint dictcnt = 0;
14501 uint maskcnt = 1;
14502 char **masks = NULL;
14503 char **dictfiles = NULL;
14504
14505 uint mask_from_file = 0;
14506
14507 if (attack_mode == ATTACK_MODE_STRAIGHT)
14508 {
14509 if (wordlist_mode == WL_MODE_FILE)
14510 {
14511 int wls_left = myargc - (optind + 1);
14512
14513 for (int i = 0; i < wls_left; i++)
14514 {
14515 char *l0_filename = myargv[optind + 1 + i];
14516
14517 struct stat l0_stat;
14518
14519 if (stat (l0_filename, &l0_stat) == -1)
14520 {
14521 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14522
14523 return (-1);
14524 }
14525
14526 uint is_dir = S_ISDIR (l0_stat.st_mode);
14527
14528 if (is_dir == 0)
14529 {
14530 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14531
14532 dictcnt++;
14533
14534 dictfiles[dictcnt - 1] = l0_filename;
14535 }
14536 else
14537 {
14538 // do not allow --keyspace w/ a directory
14539
14540 if (keyspace == 1)
14541 {
14542 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14543
14544 return (-1);
14545 }
14546
14547 char **dictionary_files = NULL;
14548
14549 dictionary_files = scan_directory (l0_filename);
14550
14551 if (dictionary_files != NULL)
14552 {
14553 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14554
14555 for (int d = 0; dictionary_files[d] != NULL; d++)
14556 {
14557 char *l1_filename = dictionary_files[d];
14558
14559 struct stat l1_stat;
14560
14561 if (stat (l1_filename, &l1_stat) == -1)
14562 {
14563 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14564
14565 return (-1);
14566 }
14567
14568 if (S_ISREG (l1_stat.st_mode))
14569 {
14570 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14571
14572 dictcnt++;
14573
14574 dictfiles[dictcnt - 1] = strdup (l1_filename);
14575 }
14576 }
14577 }
14578
14579 local_free (dictionary_files);
14580 }
14581 }
14582
14583 if (dictcnt < 1)
14584 {
14585 log_error ("ERROR: No usable dictionary file found.");
14586
14587 return (-1);
14588 }
14589 }
14590 else if (wordlist_mode == WL_MODE_STDIN)
14591 {
14592 dictcnt = 1;
14593 }
14594 }
14595 else if (attack_mode == ATTACK_MODE_COMBI)
14596 {
14597 // display
14598
14599 char *dictfile1 = myargv[optind + 1 + 0];
14600 char *dictfile2 = myargv[optind + 1 + 1];
14601
14602 // find the bigger dictionary and use as base
14603
14604 FILE *fp1;
14605 FILE *fp2;
14606
14607 struct stat tmp_stat;
14608
14609 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14610 {
14611 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14612
14613 return (-1);
14614 }
14615
14616 if (stat (dictfile1, &tmp_stat) == -1)
14617 {
14618 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14619
14620 fclose (fp1);
14621
14622 return (-1);
14623 }
14624
14625 if (S_ISDIR (tmp_stat.st_mode))
14626 {
14627 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14628
14629 fclose (fp1);
14630
14631 return (-1);
14632 }
14633
14634 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14635 {
14636 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14637
14638 fclose (fp1);
14639
14640 return (-1);
14641 }
14642
14643 if (stat (dictfile2, &tmp_stat) == -1)
14644 {
14645 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14646
14647 fclose (fp1);
14648 fclose (fp2);
14649
14650 return (-1);
14651 }
14652
14653 if (S_ISDIR (tmp_stat.st_mode))
14654 {
14655 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14656
14657 fclose (fp1);
14658 fclose (fp2);
14659
14660 return (-1);
14661 }
14662
14663 data.combs_cnt = 1;
14664
14665 data.quiet = 1;
14666
14667 const uint64_t words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14668
14669 data.quiet = quiet;
14670
14671 if (words1_cnt == 0)
14672 {
14673 log_error ("ERROR: %s: empty file", dictfile1);
14674
14675 fclose (fp1);
14676 fclose (fp2);
14677
14678 return (-1);
14679 }
14680
14681 data.combs_cnt = 1;
14682
14683 data.quiet = 1;
14684
14685 const uint64_t words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14686
14687 data.quiet = quiet;
14688
14689 if (words2_cnt == 0)
14690 {
14691 log_error ("ERROR: %s: empty file", dictfile2);
14692
14693 fclose (fp1);
14694 fclose (fp2);
14695
14696 return (-1);
14697 }
14698
14699 fclose (fp1);
14700 fclose (fp2);
14701
14702 data.dictfile = dictfile1;
14703 data.dictfile2 = dictfile2;
14704
14705 if (words1_cnt >= words2_cnt)
14706 {
14707 data.combs_cnt = words2_cnt;
14708 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14709
14710 dictfiles = &data.dictfile;
14711
14712 dictcnt = 1;
14713 }
14714 else
14715 {
14716 data.combs_cnt = words1_cnt;
14717 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14718
14719 dictfiles = &data.dictfile2;
14720
14721 dictcnt = 1;
14722
14723 // we also have to switch wordlist related rules!
14724
14725 char *tmpc = data.rule_buf_l;
14726
14727 data.rule_buf_l = data.rule_buf_r;
14728 data.rule_buf_r = tmpc;
14729
14730 int tmpi = data.rule_len_l;
14731
14732 data.rule_len_l = data.rule_len_r;
14733 data.rule_len_r = tmpi;
14734 }
14735 }
14736 else if (attack_mode == ATTACK_MODE_BF)
14737 {
14738 char *mask = NULL;
14739
14740 maskcnt = 0;
14741
14742 if (benchmark == 0)
14743 {
14744 mask = myargv[optind + 1];
14745
14746 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
14747
14748 if ((optind + 2) <= myargc)
14749 {
14750 struct stat file_stat;
14751
14752 if (stat (mask, &file_stat) == -1)
14753 {
14754 maskcnt = 1;
14755
14756 masks[maskcnt - 1] = mystrdup (mask);
14757 }
14758 else
14759 {
14760 int wls_left = myargc - (optind + 1);
14761
14762 uint masks_avail = INCR_MASKS;
14763
14764 for (int i = 0; i < wls_left; i++)
14765 {
14766 if (i != 0)
14767 {
14768 mask = myargv[optind + 1 + i];
14769
14770 if (stat (mask, &file_stat) == -1)
14771 {
14772 log_error ("ERROR: %s: %s", mask, strerror (errno));
14773
14774 return (-1);
14775 }
14776 }
14777
14778 uint is_file = S_ISREG (file_stat.st_mode);
14779
14780 if (is_file == 1)
14781 {
14782 FILE *mask_fp;
14783
14784 if ((mask_fp = fopen (mask, "r")) == NULL)
14785 {
14786 log_error ("ERROR: %s: %s", mask, strerror (errno));
14787
14788 return (-1);
14789 }
14790
14791 char line_buf[BUFSIZ];
14792
14793 while (!feof (mask_fp))
14794 {
14795 memset (line_buf, 0, BUFSIZ);
14796
14797 int line_len = fgetl (mask_fp, line_buf);
14798
14799 if (line_len == 0) continue;
14800
14801 if (line_buf[0] == '#') continue;
14802
14803 if (masks_avail == maskcnt)
14804 {
14805 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14806
14807 masks_avail += INCR_MASKS;
14808 }
14809
14810 masks[maskcnt] = mystrdup (line_buf);
14811
14812 maskcnt++;
14813 }
14814
14815 fclose (mask_fp);
14816 }
14817 else
14818 {
14819 log_error ("ERROR: %s: unsupported file-type", mask);
14820
14821 return (-1);
14822 }
14823 }
14824
14825 mask_from_file = 1;
14826 }
14827 }
14828 else
14829 {
14830 custom_charset_1 = (char *) "?l?d?u";
14831 custom_charset_2 = (char *) "?l?d";
14832 custom_charset_3 = (char *) "?l?d*!$@_";
14833
14834 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
14835 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
14836 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
14837
14838 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
14839
14840 wordlist_mode = WL_MODE_MASK;
14841
14842 data.wordlist_mode = wordlist_mode;
14843
14844 increment = 1;
14845
14846 maskcnt = 1;
14847 }
14848 }
14849 else
14850 {
14851 /**
14852 * generate full masks and charsets
14853 */
14854
14855 masks = (char **) mymalloc (sizeof (char *));
14856
14857 switch (hash_mode)
14858 {
14859 case 1731: pw_min = 5;
14860 pw_max = 5;
14861 mask = mystrdup ("?b?b?b?b?b");
14862 break;
14863 case 12500: pw_min = 5;
14864 pw_max = 5;
14865 mask = mystrdup ("?b?b?b?b?b");
14866 break;
14867 default: pw_min = 7;
14868 pw_max = 7;
14869 mask = mystrdup ("?b?b?b?b?b?b?b");
14870 break;
14871 }
14872
14873 maskcnt = 1;
14874
14875 masks[maskcnt - 1] = mystrdup (mask);
14876
14877 wordlist_mode = WL_MODE_MASK;
14878
14879 data.wordlist_mode = wordlist_mode;
14880
14881 increment = 1;
14882 }
14883
14884 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
14885
14886 if (increment)
14887 {
14888 if (increment_min > pw_min) pw_min = increment_min;
14889
14890 if (increment_max < pw_max) pw_max = increment_max;
14891 }
14892 }
14893 else if (attack_mode == ATTACK_MODE_HYBRID1)
14894 {
14895 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14896
14897 // display
14898
14899 char *mask = myargv[myargc - 1];
14900
14901 maskcnt = 0;
14902
14903 masks = (char **) mymalloc (1 * sizeof (char *));
14904
14905 // mod
14906
14907 struct stat file_stat;
14908
14909 if (stat (mask, &file_stat) == -1)
14910 {
14911 maskcnt = 1;
14912
14913 masks[maskcnt - 1] = mystrdup (mask);
14914 }
14915 else
14916 {
14917 uint is_file = S_ISREG (file_stat.st_mode);
14918
14919 if (is_file == 1)
14920 {
14921 FILE *mask_fp;
14922
14923 if ((mask_fp = fopen (mask, "r")) == NULL)
14924 {
14925 log_error ("ERROR: %s: %s", mask, strerror (errno));
14926
14927 return (-1);
14928 }
14929
14930 char line_buf[BUFSIZ];
14931
14932 uint masks_avail = 1;
14933
14934 while (!feof (mask_fp))
14935 {
14936 memset (line_buf, 0, BUFSIZ);
14937
14938 int line_len = fgetl (mask_fp, line_buf);
14939
14940 if (line_len == 0) continue;
14941
14942 if (line_buf[0] == '#') continue;
14943
14944 if (masks_avail == maskcnt)
14945 {
14946 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14947
14948 masks_avail += INCR_MASKS;
14949 }
14950
14951 masks[maskcnt] = mystrdup (line_buf);
14952
14953 maskcnt++;
14954 }
14955
14956 fclose (mask_fp);
14957
14958 mask_from_file = 1;
14959 }
14960 else
14961 {
14962 maskcnt = 1;
14963
14964 masks[maskcnt - 1] = mystrdup (mask);
14965 }
14966 }
14967
14968 // base
14969
14970 int wls_left = myargc - (optind + 2);
14971
14972 for (int i = 0; i < wls_left; i++)
14973 {
14974 char *filename = myargv[optind + 1 + i];
14975
14976 struct stat file_stat;
14977
14978 if (stat (filename, &file_stat) == -1)
14979 {
14980 log_error ("ERROR: %s: %s", filename, strerror (errno));
14981
14982 return (-1);
14983 }
14984
14985 uint is_dir = S_ISDIR (file_stat.st_mode);
14986
14987 if (is_dir == 0)
14988 {
14989 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14990
14991 dictcnt++;
14992
14993 dictfiles[dictcnt - 1] = filename;
14994 }
14995 else
14996 {
14997 // do not allow --keyspace w/ a directory
14998
14999 if (keyspace == 1)
15000 {
15001 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15002
15003 return (-1);
15004 }
15005
15006 char **dictionary_files = NULL;
15007
15008 dictionary_files = scan_directory (filename);
15009
15010 if (dictionary_files != NULL)
15011 {
15012 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15013
15014 for (int d = 0; dictionary_files[d] != NULL; d++)
15015 {
15016 char *l1_filename = dictionary_files[d];
15017
15018 struct stat l1_stat;
15019
15020 if (stat (l1_filename, &l1_stat) == -1)
15021 {
15022 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15023
15024 return (-1);
15025 }
15026
15027 if (S_ISREG (l1_stat.st_mode))
15028 {
15029 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15030
15031 dictcnt++;
15032
15033 dictfiles[dictcnt - 1] = strdup (l1_filename);
15034 }
15035 }
15036 }
15037
15038 local_free (dictionary_files);
15039 }
15040 }
15041
15042 if (dictcnt < 1)
15043 {
15044 log_error ("ERROR: No usable dictionary file found.");
15045
15046 return (-1);
15047 }
15048
15049 if (increment)
15050 {
15051 maskcnt = 0;
15052
15053 uint mask_min = increment_min; // we can't reject smaller masks here
15054 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15055
15056 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15057 {
15058 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15059
15060 if (cur_mask == NULL) break;
15061
15062 masks[maskcnt] = cur_mask;
15063
15064 maskcnt++;
15065
15066 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15067 }
15068 }
15069 }
15070 else if (attack_mode == ATTACK_MODE_HYBRID2)
15071 {
15072 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15073
15074 // display
15075
15076 char *mask = myargv[optind + 1 + 0];
15077
15078 maskcnt = 0;
15079
15080 masks = (char **) mymalloc (1 * sizeof (char *));
15081
15082 // mod
15083
15084 struct stat file_stat;
15085
15086 if (stat (mask, &file_stat) == -1)
15087 {
15088 maskcnt = 1;
15089
15090 masks[maskcnt - 1] = mystrdup (mask);
15091 }
15092 else
15093 {
15094 uint is_file = S_ISREG (file_stat.st_mode);
15095
15096 if (is_file == 1)
15097 {
15098 FILE *mask_fp;
15099
15100 if ((mask_fp = fopen (mask, "r")) == NULL)
15101 {
15102 log_error ("ERROR: %s: %s", mask, strerror (errno));
15103
15104 return (-1);
15105 }
15106
15107 char line_buf[BUFSIZ];
15108
15109 uint masks_avail = 1;
15110
15111 while (!feof (mask_fp))
15112 {
15113 memset (line_buf, 0, BUFSIZ);
15114
15115 int line_len = fgetl (mask_fp, line_buf);
15116
15117 if (line_len == 0) continue;
15118
15119 if (line_buf[0] == '#') continue;
15120
15121 if (masks_avail == maskcnt)
15122 {
15123 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15124
15125 masks_avail += INCR_MASKS;
15126 }
15127
15128 masks[maskcnt] = mystrdup (line_buf);
15129
15130 maskcnt++;
15131 }
15132
15133 fclose (mask_fp);
15134
15135 mask_from_file = 1;
15136 }
15137 else
15138 {
15139 maskcnt = 1;
15140
15141 masks[maskcnt - 1] = mystrdup (mask);
15142 }
15143 }
15144
15145 // base
15146
15147 int wls_left = myargc - (optind + 2);
15148
15149 for (int i = 0; i < wls_left; i++)
15150 {
15151 char *filename = myargv[optind + 2 + i];
15152
15153 struct stat file_stat;
15154
15155 if (stat (filename, &file_stat) == -1)
15156 {
15157 log_error ("ERROR: %s: %s", filename, strerror (errno));
15158
15159 return (-1);
15160 }
15161
15162 uint is_dir = S_ISDIR (file_stat.st_mode);
15163
15164 if (is_dir == 0)
15165 {
15166 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15167
15168 dictcnt++;
15169
15170 dictfiles[dictcnt - 1] = filename;
15171 }
15172 else
15173 {
15174 // do not allow --keyspace w/ a directory
15175
15176 if (keyspace == 1)
15177 {
15178 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15179
15180 return (-1);
15181 }
15182
15183 char **dictionary_files = NULL;
15184
15185 dictionary_files = scan_directory (filename);
15186
15187 if (dictionary_files != NULL)
15188 {
15189 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15190
15191 for (int d = 0; dictionary_files[d] != NULL; d++)
15192 {
15193 char *l1_filename = dictionary_files[d];
15194
15195 struct stat l1_stat;
15196
15197 if (stat (l1_filename, &l1_stat) == -1)
15198 {
15199 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15200
15201 return (-1);
15202 }
15203
15204 if (S_ISREG (l1_stat.st_mode))
15205 {
15206 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15207
15208 dictcnt++;
15209
15210 dictfiles[dictcnt - 1] = strdup (l1_filename);
15211 }
15212 }
15213 }
15214
15215 local_free (dictionary_files);
15216 }
15217 }
15218
15219 if (dictcnt < 1)
15220 {
15221 log_error ("ERROR: No usable dictionary file found.");
15222
15223 return (-1);
15224 }
15225
15226 if (increment)
15227 {
15228 maskcnt = 0;
15229
15230 uint mask_min = increment_min; // we can't reject smaller masks here
15231 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15232
15233 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15234 {
15235 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15236
15237 if (cur_mask == NULL) break;
15238
15239 masks[maskcnt] = cur_mask;
15240
15241 maskcnt++;
15242
15243 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15244 }
15245 }
15246 }
15247
15248 data.pw_min = pw_min;
15249 data.pw_max = pw_max;
15250
15251 /**
15252 * weak hash check
15253 */
15254
15255 if (weak_hash_threshold >= salts_cnt)
15256 {
15257 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15258
15259 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15260 {
15261 weak_hash_check (&data.devices_param[0], salt_pos, kernel_loops);
15262 }
15263 }
15264
15265 // Display hack, guarantee that there is at least one \r before real start
15266
15267 if (data.quiet == 0) log_info_nn ("");
15268
15269 /**
15270 * status and monitor threads
15271 */
15272
15273 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15274
15275 hc_thread_t i_thread = 0;
15276
15277 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15278 {
15279 hc_thread_create (i_thread, thread_keypress, &benchmark);
15280 }
15281
15282 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15283
15284 uint ni_threads_cnt = 0;
15285
15286 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15287
15288 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15289
15290 ni_threads_cnt++;
15291
15292 /**
15293 * Outfile remove
15294 */
15295
15296 if (keyspace == 0)
15297 {
15298 if (outfile_check_timer != 0)
15299 {
15300 if (data.outfile_check_directory != NULL)
15301 {
15302 if ((hash_mode != 5200) &&
15303 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15304 (hash_mode != 9000))
15305 {
15306 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15307
15308 ni_threads_cnt++;
15309 }
15310 else
15311 {
15312 outfile_check_timer = 0;
15313 }
15314 }
15315 else
15316 {
15317 outfile_check_timer = 0;
15318 }
15319 }
15320 }
15321
15322 /**
15323 * Inform the user if we got some hashes remove because of the pot file remove feature
15324 */
15325
15326 if (data.quiet == 0)
15327 {
15328 if (potfile_remove_cracks > 0)
15329 {
15330 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15331 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15332 }
15333 }
15334
15335 data.outfile_check_timer = outfile_check_timer;
15336
15337 /**
15338 * main loop
15339 */
15340
15341 char **induction_dictionaries = NULL;
15342
15343 int induction_dictionaries_cnt = 0;
15344
15345 hcstat_table_t *root_table_buf = NULL;
15346 hcstat_table_t *markov_table_buf = NULL;
15347
15348 uint initial_restore_done = 0;
15349
15350 data.maskcnt = maskcnt;
15351
15352 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15353 {
15354 if (data.devices_status == STATUS_CRACKED) break;
15355
15356 data.devices_status = STATUS_INIT;
15357
15358 if (maskpos > rd->maskpos)
15359 {
15360 rd->dictpos = 0;
15361 }
15362
15363 rd->maskpos = maskpos;
15364 data.maskpos = maskpos;
15365
15366 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15367 {
15368 char *mask = masks[maskpos];
15369
15370 if (mask_from_file == 1)
15371 {
15372 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15373
15374 char *str_ptr;
15375 uint str_pos;
15376
15377 uint mask_offset = 0;
15378
15379 uint separator_cnt;
15380
15381 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15382 {
15383 str_ptr = strstr (mask + mask_offset, ",");
15384
15385 if (str_ptr == NULL) break;
15386
15387 str_pos = str_ptr - mask;
15388
15389 // escaped separator, i.e. "\,"
15390
15391 if (str_pos > 0)
15392 {
15393 if (mask[str_pos - 1] == '\\')
15394 {
15395 separator_cnt --;
15396
15397 mask_offset = str_pos + 1;
15398
15399 continue;
15400 }
15401 }
15402
15403 // reset the offset
15404
15405 mask_offset = 0;
15406
15407 mask[str_pos] = '\0';
15408
15409 switch (separator_cnt)
15410 {
15411 case 0:
15412 mp_reset_usr (mp_usr, 0);
15413
15414 custom_charset_1 = mask;
15415 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15416 break;
15417
15418 case 1:
15419 mp_reset_usr (mp_usr, 1);
15420
15421 custom_charset_2 = mask;
15422 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15423 break;
15424
15425 case 2:
15426 mp_reset_usr (mp_usr, 2);
15427
15428 custom_charset_3 = mask;
15429 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15430 break;
15431
15432 case 3:
15433 mp_reset_usr (mp_usr, 3);
15434
15435 custom_charset_4 = mask;
15436 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15437 break;
15438 }
15439
15440 mask = mask + str_pos + 1;
15441 }
15442 }
15443
15444 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15445 {
15446 if (maskpos > 0)
15447 {
15448 local_free (css_buf);
15449 local_free (data.root_css_buf);
15450 local_free (data.markov_css_buf);
15451
15452 local_free (masks[maskpos - 1]);
15453 }
15454
15455 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15456
15457 data.mask = mask;
15458 data.css_cnt = css_cnt;
15459 data.css_buf = css_buf;
15460
15461 uint uniq_tbls[SP_PW_MAX][CHARSIZ];
15462
15463 memset (uniq_tbls, 0, sizeof (uniq_tbls));
15464
15465 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15466
15467 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15468 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15469
15470 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15471
15472 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15473
15474 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15475 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15476
15477 data.root_css_buf = root_css_buf;
15478 data.markov_css_buf = markov_css_buf;
15479
15480 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15481
15482 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15483
15484 local_free (root_table_buf);
15485 local_free (markov_table_buf);
15486
15487 // args
15488
15489 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15490 {
15491 hc_device_param_t *device_param = &data.devices_param[device_id];
15492
15493 device_param->kernel_params_mp[0] = &device_param->d_combs;
15494 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15495 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15496
15497 device_param->kernel_params_mp_buf64[3] = 0;
15498 device_param->kernel_params_mp_buf32[4] = css_cnt;
15499 device_param->kernel_params_mp_buf32[5] = 0;
15500 device_param->kernel_params_mp_buf32[6] = 0;
15501 device_param->kernel_params_mp_buf32[7] = 0;
15502
15503 if (attack_mode == ATTACK_MODE_HYBRID1)
15504 {
15505 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15506 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15507 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15508 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15509 }
15510 else if (attack_mode == ATTACK_MODE_HYBRID2)
15511 {
15512 device_param->kernel_params_mp_buf32[5] = 0;
15513 device_param->kernel_params_mp_buf32[6] = 0;
15514 device_param->kernel_params_mp_buf32[7] = 0;
15515 }
15516
15517 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp[i]);
15518 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp[i]);
15519 for (uint i = 4; i < 8; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp[i]);
15520
15521 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);
15522 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);
15523 }
15524 }
15525 else if (attack_mode == ATTACK_MODE_BF)
15526 {
15527 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15528
15529 if (increment)
15530 {
15531 for (uint i = 0; i < dictcnt; i++)
15532 {
15533 local_free (dictfiles[i]);
15534 }
15535
15536 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15537 {
15538 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15539
15540 if (l1_filename == NULL) break;
15541
15542 dictcnt++;
15543
15544 dictfiles[dictcnt - 1] = l1_filename;
15545 }
15546 }
15547 else
15548 {
15549 dictcnt++;
15550
15551 dictfiles[dictcnt - 1] = mask;
15552 }
15553
15554 if (dictcnt == 0)
15555 {
15556 log_error ("ERROR: Mask is too small");
15557
15558 return (-1);
15559 }
15560 }
15561 }
15562
15563 free (induction_dictionaries);
15564
15565 // induction_dictionaries_cnt = 0; // implied
15566
15567 if (attack_mode != ATTACK_MODE_BF)
15568 {
15569 if (keyspace == 0)
15570 {
15571 induction_dictionaries = scan_directory (induction_directory);
15572
15573 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15574 }
15575 }
15576
15577 if (induction_dictionaries_cnt)
15578 {
15579 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15580 }
15581
15582 /**
15583 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15584 */
15585 if (keyspace == 1)
15586 {
15587 if ((maskcnt > 1) || (dictcnt > 1))
15588 {
15589 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15590
15591 return (-1);
15592 }
15593 }
15594
15595 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15596 {
15597 char *subid = logfile_generate_subid ();
15598
15599 data.subid = subid;
15600
15601 logfile_sub_msg ("START");
15602
15603 data.devices_status = STATUS_INIT;
15604
15605 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (uint64_t));
15606 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (uint64_t));
15607 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (uint64_t));
15608
15609 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15610
15611 data.cpt_pos = 0;
15612
15613 data.cpt_start = time (NULL);
15614
15615 data.cpt_total = 0;
15616
15617 if (data.restore == 0)
15618 {
15619 rd->words_cur = skip;
15620
15621 skip = 0;
15622
15623 data.skip = 0;
15624 }
15625
15626 data.ms_paused = 0;
15627
15628 data.words_cur = rd->words_cur;
15629
15630 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15631 {
15632 hc_device_param_t *device_param = &data.devices_param[device_id];
15633
15634 device_param->speed_pos = 0;
15635
15636 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (uint64_t));
15637 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15638 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15639
15640 device_param->kernel_power = device_param->kernel_power_user;
15641 device_param->kernel_blocks = device_param->kernel_blocks_user;
15642
15643 device_param->outerloop_pos = 0;
15644 device_param->outerloop_left = 0;
15645 device_param->innerloop_pos = 0;
15646 device_param->innerloop_left = 0;
15647
15648 // some more resets:
15649
15650 memset (device_param->pw_caches, 0, 64 * sizeof (pw_cache_t));
15651
15652 memset (device_param->pws_buf, 0, device_param->size_pws);
15653
15654 device_param->pw_cnt = 0;
15655 device_param->pws_cnt = 0;
15656
15657 device_param->words_off = 0;
15658 device_param->words_done = 0;
15659 }
15660
15661 data.kernel_blocks_div = 0;
15662
15663 // figure out some workload
15664
15665 if (attack_mode == ATTACK_MODE_STRAIGHT)
15666 {
15667 if (data.wordlist_mode == WL_MODE_FILE)
15668 {
15669 char *dictfile = NULL;
15670
15671 if (induction_dictionaries_cnt)
15672 {
15673 dictfile = induction_dictionaries[0];
15674 }
15675 else
15676 {
15677 dictfile = dictfiles[dictpos];
15678 }
15679
15680 data.dictfile = dictfile;
15681
15682 logfile_sub_string (dictfile);
15683
15684 for (uint i = 0; i < rp_files_cnt; i++)
15685 {
15686 logfile_sub_var_string ("rulefile", rp_files[i]);
15687 }
15688
15689 FILE *fd2 = fopen (dictfile, "rb");
15690
15691 if (fd2 == NULL)
15692 {
15693 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15694
15695 return (-1);
15696 }
15697
15698 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15699
15700 fclose (fd2);
15701
15702 if (data.words_cnt == 0)
15703 {
15704 if (data.devices_status == STATUS_CRACKED) break;
15705 if (data.devices_status == STATUS_ABORTED) break;
15706
15707 dictpos++;
15708
15709 continue;
15710 }
15711 }
15712 }
15713 else if (attack_mode == ATTACK_MODE_COMBI)
15714 {
15715 char *dictfile = data.dictfile;
15716 char *dictfile2 = data.dictfile2;
15717
15718 logfile_sub_string (dictfile);
15719 logfile_sub_string (dictfile2);
15720
15721 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
15722 {
15723 FILE *fd2 = fopen (dictfile, "rb");
15724
15725 if (fd2 == NULL)
15726 {
15727 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15728
15729 return (-1);
15730 }
15731
15732 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15733
15734 fclose (fd2);
15735 }
15736 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
15737 {
15738 FILE *fd2 = fopen (dictfile2, "rb");
15739
15740 if (fd2 == NULL)
15741 {
15742 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15743
15744 return (-1);
15745 }
15746
15747 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
15748
15749 fclose (fd2);
15750 }
15751
15752 if (data.words_cnt == 0)
15753 {
15754 if (data.devices_status == STATUS_CRACKED) break;
15755 if (data.devices_status == STATUS_ABORTED) break;
15756
15757 dictpos++;
15758
15759 continue;
15760 }
15761 }
15762 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15763 {
15764 char *dictfile = NULL;
15765
15766 if (induction_dictionaries_cnt)
15767 {
15768 dictfile = induction_dictionaries[0];
15769 }
15770 else
15771 {
15772 dictfile = dictfiles[dictpos];
15773 }
15774
15775 data.dictfile = dictfile;
15776
15777 char *mask = data.mask;
15778
15779 logfile_sub_string (dictfile);
15780 logfile_sub_string (mask);
15781
15782 FILE *fd2 = fopen (dictfile, "rb");
15783
15784 if (fd2 == NULL)
15785 {
15786 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15787
15788 return (-1);
15789 }
15790
15791 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15792
15793 fclose (fd2);
15794
15795 if (data.words_cnt == 0)
15796 {
15797 if (data.devices_status == STATUS_CRACKED) break;
15798 if (data.devices_status == STATUS_ABORTED) break;
15799
15800 dictpos++;
15801
15802 continue;
15803 }
15804 }
15805 else if (attack_mode == ATTACK_MODE_BF)
15806 {
15807 local_free (css_buf);
15808 local_free (data.root_css_buf);
15809 local_free (data.markov_css_buf);
15810
15811 char *mask = dictfiles[dictpos];
15812
15813 logfile_sub_string (mask);
15814
15815 // base
15816
15817 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15818
15819 if (opts_type & OPTS_TYPE_PT_UNICODE)
15820 {
15821 uint css_cnt_unicode = css_cnt * 2;
15822
15823 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
15824
15825 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
15826 {
15827 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
15828
15829 css_buf_unicode[j + 1].cs_buf[0] = 0;
15830 css_buf_unicode[j + 1].cs_len = 1;
15831 }
15832
15833 free (css_buf);
15834
15835 css_buf = css_buf_unicode;
15836 css_cnt = css_cnt_unicode;
15837 }
15838
15839 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
15840
15841 uint mask_min = pw_min;
15842 uint mask_max = pw_max;
15843
15844 if (opts_type & OPTS_TYPE_PT_UNICODE)
15845 {
15846 mask_min *= 2;
15847 mask_max *= 2;
15848 }
15849
15850 if ((css_cnt < mask_min) || (css_cnt > mask_max))
15851 {
15852 if (css_cnt < mask_min)
15853 {
15854 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
15855 }
15856
15857 if (css_cnt > mask_max)
15858 {
15859 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
15860 }
15861
15862 // skip to next mask
15863
15864 dictpos++;
15865
15866 rd->dictpos = dictpos;
15867
15868 logfile_sub_msg ("STOP");
15869
15870 continue;
15871 }
15872
15873 uint save_css_cnt = css_cnt;
15874
15875 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15876 {
15877 if (opti_type & OPTI_TYPE_APPENDED_SALT)
15878 {
15879 uint salt_len = (uint) data.salts_buf[0].salt_len;
15880 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
15881
15882 uint css_cnt_salt = css_cnt + salt_len;
15883
15884 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
15885
15886 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
15887
15888 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
15889 {
15890 css_buf_salt[j].cs_buf[0] = salt_buf[i];
15891 css_buf_salt[j].cs_len = 1;
15892 }
15893
15894 free (css_buf);
15895
15896 css_buf = css_buf_salt;
15897 css_cnt = css_cnt_salt;
15898 }
15899 }
15900
15901 data.mask = mask;
15902 data.css_cnt = css_cnt;
15903 data.css_buf = css_buf;
15904
15905 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
15906
15907 uint uniq_tbls[SP_PW_MAX][CHARSIZ];
15908
15909 memset (uniq_tbls, 0, sizeof (uniq_tbls));
15910
15911 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15912
15913 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15914 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15915
15916 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15917
15918 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15919
15920 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15921 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15922
15923 data.root_css_buf = root_css_buf;
15924 data.markov_css_buf = markov_css_buf;
15925
15926 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15927
15928 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15929
15930 local_free (root_table_buf);
15931 local_free (markov_table_buf);
15932
15933 // copy + args
15934
15935 uint css_cnt_l = css_cnt;
15936 uint css_cnt_r;
15937
15938 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15939 {
15940 if (save_css_cnt < 6)
15941 {
15942 css_cnt_r = 1;
15943 }
15944 else if (save_css_cnt == 6)
15945 {
15946 css_cnt_r = 2;
15947 }
15948 else
15949 {
15950 if (opts_type & OPTS_TYPE_PT_UNICODE)
15951 {
15952 if (save_css_cnt == 8 || save_css_cnt == 10)
15953 {
15954 css_cnt_r = 2;
15955 }
15956 else
15957 {
15958 css_cnt_r = 4;
15959 }
15960 }
15961 else
15962 {
15963 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
15964 {
15965 css_cnt_r = 3;
15966 }
15967 else
15968 {
15969 css_cnt_r = 4;
15970 }
15971 }
15972 }
15973 }
15974 else
15975 {
15976 css_cnt_r = 1;
15977
15978 /* unfinished code?
15979 int sum = css_buf[css_cnt_r - 1].cs_len;
15980
15981 for (uint i = 1; i < 4 && i < css_cnt; i++)
15982 {
15983 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
15984
15985 css_cnt_r++;
15986
15987 sum *= css_buf[css_cnt_r - 1].cs_len;
15988 }
15989 */
15990 }
15991
15992 css_cnt_l -= css_cnt_r;
15993
15994 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
15995
15996 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15997 {
15998 hc_device_param_t *device_param = &data.devices_param[device_id];
15999
16000 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16001 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16002 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16003
16004 device_param->kernel_params_mp_l_buf64[3] = 0;
16005 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16006 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16007 device_param->kernel_params_mp_l_buf32[6] = 0;
16008 device_param->kernel_params_mp_l_buf32[7] = 0;
16009 device_param->kernel_params_mp_l_buf32[8] = 0;
16010
16011 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16012 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16013 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16014 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16015
16016 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16017 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16018 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16019
16020 device_param->kernel_params_mp_r_buf64[3] = 0;
16021 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16022 device_param->kernel_params_mp_r_buf32[5] = 0;
16023 device_param->kernel_params_mp_r_buf32[6] = 0;
16024 device_param->kernel_params_mp_r_buf32[7] = 0;
16025
16026 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]);
16027 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]);
16028 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]);
16029
16030 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]);
16031 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]);
16032 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]);
16033
16034 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);
16035 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);
16036 }
16037 }
16038
16039 uint64_t words_base = data.words_cnt;
16040
16041 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16042 {
16043 if (data.kernel_rules_cnt)
16044 {
16045 words_base /= data.kernel_rules_cnt;
16046 }
16047 }
16048 else if (data.attack_kern == ATTACK_KERN_COMBI)
16049 {
16050 if (data.combs_cnt)
16051 {
16052 words_base /= data.combs_cnt;
16053 }
16054 }
16055 else if (data.attack_kern == ATTACK_KERN_BF)
16056 {
16057 if (data.bfs_cnt)
16058 {
16059 words_base /= data.bfs_cnt;
16060 }
16061 }
16062
16063 data.words_base = words_base;
16064
16065 if (keyspace == 1)
16066 {
16067 log_info ("%llu", (unsigned long long int) words_base);
16068
16069 return (0);
16070 }
16071
16072 if (data.words_cur > data.words_base)
16073 {
16074 log_error ("ERROR: restore value greater keyspace");
16075
16076 return (-1);
16077 }
16078
16079 if (data.words_cur)
16080 {
16081 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16082 {
16083 for (uint i = 0; i < data.salts_cnt; i++)
16084 {
16085 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16086 }
16087 }
16088 else if (data.attack_kern == ATTACK_KERN_COMBI)
16089 {
16090 for (uint i = 0; i < data.salts_cnt; i++)
16091 {
16092 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16093 }
16094 }
16095 else if (data.attack_kern == ATTACK_KERN_BF)
16096 {
16097 for (uint i = 0; i < data.salts_cnt; i++)
16098 {
16099 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16100 }
16101 }
16102 }
16103
16104 /*
16105 * Inform user about possible slow speeds
16106 */
16107
16108 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16109 {
16110 if (data.words_base < kernel_blocks_all)
16111 {
16112 if (quiet == 0)
16113 {
16114 log_info ("");
16115 log_info ("ATTENTION!");
16116 log_info (" The wordlist or mask you are using is too small.");
16117 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16118 log_info (" The cracking speed will drop.");
16119 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16120 log_info ("");
16121 }
16122 }
16123 }
16124
16125 /*
16126 * Update loopback file
16127 */
16128
16129 if (loopback == 1)
16130 {
16131 time_t now;
16132
16133 time (&now);
16134
16135 uint random_num = get_random_num (0, 9999);
16136
16137 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16138
16139 data.loopback_file = loopback_file;
16140 }
16141
16142 /*
16143 * Update dictionary statistic
16144 */
16145
16146 if (keyspace == 0)
16147 {
16148 dictstat_fp = fopen (dictstat, "wb");
16149
16150 if (dictstat_fp)
16151 {
16152 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16153
16154 fclose (dictstat_fp);
16155 }
16156 }
16157
16158 data.devices_status = STATUS_RUNNING;
16159
16160 if (initial_restore_done == 0)
16161 {
16162 if (data.restore_disable == 0) cycle_restore ();
16163
16164 initial_restore_done = 1;
16165 }
16166
16167 hc_timer_set (&data.timer_running);
16168
16169 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16170 {
16171 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16172 {
16173 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16174 if (quiet == 0) fflush (stdout);
16175 }
16176 }
16177 else if (wordlist_mode == WL_MODE_STDIN)
16178 {
16179 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16180 if (data.quiet == 0) log_info ("");
16181 }
16182
16183 time_t runtime_start;
16184
16185 time (&runtime_start);
16186
16187 data.runtime_start = runtime_start;
16188
16189 /**
16190 * create cracker threads
16191 */
16192
16193 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (devices_cnt, sizeof (hc_thread_t));
16194
16195 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16196 {
16197 hc_device_param_t *device_param = &devices_param[device_id];
16198
16199 device_param->device_id = device_id;
16200
16201 if (wordlist_mode == WL_MODE_STDIN)
16202 {
16203 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16204 }
16205 else
16206 {
16207 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16208 }
16209 }
16210
16211 // wait for crack threads to exit
16212
16213 hc_thread_wait (devices_cnt, c_threads);
16214
16215 local_free (c_threads);
16216
16217 data.restore = 0;
16218
16219 // finalize task
16220
16221 logfile_sub_var_uint ("status-after-work", data.devices_status);
16222
16223 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16224
16225 if (data.devices_status == STATUS_CRACKED) break;
16226 if (data.devices_status == STATUS_ABORTED) break;
16227
16228 if (data.devices_status == STATUS_BYPASS)
16229 {
16230 data.devices_status = STATUS_RUNNING;
16231 }
16232
16233 if (induction_dictionaries_cnt)
16234 {
16235 unlink (induction_dictionaries[0]);
16236 }
16237
16238 free (induction_dictionaries);
16239
16240 if (attack_mode != ATTACK_MODE_BF)
16241 {
16242 induction_dictionaries = scan_directory (induction_directory);
16243
16244 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16245 }
16246
16247 if (benchmark == 0)
16248 {
16249 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16250 {
16251 if (quiet == 0) clear_prompt ();
16252
16253 if (quiet == 0) log_info ("");
16254
16255 if (status == 1)
16256 {
16257 status_display ();
16258 }
16259 else
16260 {
16261 if (quiet == 0) status_display ();
16262 }
16263
16264 if (quiet == 0) log_info ("");
16265 }
16266 }
16267
16268 if (attack_mode == ATTACK_MODE_BF)
16269 {
16270 dictpos++;
16271
16272 rd->dictpos = dictpos;
16273 }
16274 else
16275 {
16276 if (induction_dictionaries_cnt)
16277 {
16278 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16279 }
16280 else
16281 {
16282 dictpos++;
16283
16284 rd->dictpos = dictpos;
16285 }
16286 }
16287
16288 time_t runtime_stop;
16289
16290 time (&runtime_stop);
16291
16292 data.runtime_stop = runtime_stop;
16293
16294 logfile_sub_uint (runtime_start);
16295 logfile_sub_uint (runtime_stop);
16296
16297 logfile_sub_msg ("STOP");
16298
16299 global_free (subid);
16300 }
16301
16302 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16303
16304 if (data.devices_status == STATUS_CRACKED) break;
16305 if (data.devices_status == STATUS_ABORTED) break;
16306 if (data.devices_status == STATUS_QUIT) break;
16307
16308 if (data.devices_status == STATUS_BYPASS)
16309 {
16310 data.devices_status = STATUS_RUNNING;
16311 }
16312 }
16313
16314 // 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
16315
16316 if (attack_mode == ATTACK_MODE_STRAIGHT)
16317 {
16318 if (data.wordlist_mode == WL_MODE_FILE)
16319 {
16320 if (data.dictfile == NULL)
16321 {
16322 if (dictfiles != NULL)
16323 {
16324 data.dictfile = dictfiles[0];
16325
16326 hc_timer_set (&data.timer_running);
16327 }
16328 }
16329 }
16330 }
16331 // NOTE: combi is okay because it is already set beforehand
16332 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16333 {
16334 if (data.dictfile == NULL)
16335 {
16336 if (dictfiles != NULL)
16337 {
16338 hc_timer_set (&data.timer_running);
16339
16340 data.dictfile = dictfiles[0];
16341 }
16342 }
16343 }
16344 else if (attack_mode == ATTACK_MODE_BF)
16345 {
16346 if (data.mask == NULL)
16347 {
16348 hc_timer_set (&data.timer_running);
16349
16350 data.mask = masks[0];
16351 }
16352 }
16353
16354 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16355 {
16356 data.devices_status = STATUS_EXHAUSTED;
16357 }
16358
16359 // if cracked / aborted remove last induction dictionary
16360
16361 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16362 {
16363 struct stat induct_stat;
16364
16365 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16366 {
16367 unlink (induction_dictionaries[file_pos]);
16368 }
16369 }
16370
16371 // wait for non-interactive threads
16372
16373 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16374 {
16375 hc_thread_wait (1, &ni_threads[thread_idx]);
16376 }
16377
16378 local_free (ni_threads);
16379
16380 // wait for interactive threads
16381
16382 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16383 {
16384 hc_thread_wait (1, &i_thread);
16385 }
16386
16387 // we dont need restore file anymore
16388 if (data.restore_disable == 0)
16389 {
16390 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16391 {
16392 unlink (eff_restore_file);
16393 unlink (new_restore_file);
16394 }
16395 else
16396 {
16397 cycle_restore ();
16398 }
16399 }
16400
16401 // finally save left hashes
16402
16403 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16404 {
16405 save_hash ();
16406 }
16407
16408 /**
16409 * Clean up
16410 */
16411
16412 if (benchmark == 1)
16413 {
16414 status_benchmark ();
16415
16416 log_info ("");
16417 }
16418 else
16419 {
16420 if (quiet == 0) clear_prompt ();
16421
16422 if (quiet == 0) log_info ("");
16423
16424 if (status == 1)
16425 {
16426 status_display ();
16427 }
16428 else
16429 {
16430 if (quiet == 0) status_display ();
16431 }
16432
16433 if (quiet == 0) log_info ("");
16434 }
16435
16436 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16437 {
16438 hc_device_param_t *device_param = &data.devices_param[device_id];
16439
16440 local_free (device_param->result);
16441
16442 local_free (device_param->pw_caches);
16443
16444 local_free (device_param->combs_buf);
16445
16446 local_free (device_param->hooks_buf);
16447
16448 local_free (device_param->device_name);
16449
16450 local_free (device_param->device_name_chksum);
16451
16452 local_free (device_param->device_version);
16453
16454 local_free (device_param->driver_version);
16455
16456 if (device_param->pws_buf) myfree (device_param->pws_buf);
16457 if (device_param->d_pws_buf) hc_clReleaseMemObject (device_param->d_pws_buf);
16458 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (device_param->d_pws_amp_buf);
16459 if (device_param->d_rules) hc_clReleaseMemObject (device_param->d_rules);
16460 if (device_param->d_rules_c) hc_clReleaseMemObject (device_param->d_rules_c);
16461 if (device_param->d_combs) hc_clReleaseMemObject (device_param->d_combs);
16462 if (device_param->d_combs_c) hc_clReleaseMemObject (device_param->d_combs_c);
16463 if (device_param->d_bfs) hc_clReleaseMemObject (device_param->d_bfs);
16464 if (device_param->d_bfs_c) hc_clReleaseMemObject (device_param->d_bfs_c);
16465 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (device_param->d_bitmap_s1_a);
16466 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (device_param->d_bitmap_s1_b);
16467 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (device_param->d_bitmap_s1_c);
16468 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (device_param->d_bitmap_s1_d);
16469 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (device_param->d_bitmap_s2_a);
16470 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (device_param->d_bitmap_s2_b);
16471 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (device_param->d_bitmap_s2_c);
16472 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (device_param->d_bitmap_s2_d);
16473 if (device_param->d_plain_bufs) hc_clReleaseMemObject (device_param->d_plain_bufs);
16474 if (device_param->d_digests_buf) hc_clReleaseMemObject (device_param->d_digests_buf);
16475 if (device_param->d_digests_shown) hc_clReleaseMemObject (device_param->d_digests_shown);
16476 if (device_param->d_salt_bufs) hc_clReleaseMemObject (device_param->d_salt_bufs);
16477 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (device_param->d_esalt_bufs);
16478 if (device_param->d_tmps) hc_clReleaseMemObject (device_param->d_tmps);
16479 if (device_param->d_hooks) hc_clReleaseMemObject (device_param->d_hooks);
16480 if (device_param->d_result) hc_clReleaseMemObject (device_param->d_result);
16481 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (device_param->d_scryptV_buf);
16482 if (device_param->d_root_css_buf) hc_clReleaseMemObject (device_param->d_root_css_buf);
16483 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (device_param->d_markov_css_buf);
16484 if (device_param->d_tm_c) hc_clReleaseMemObject (device_param->d_tm_c);
16485
16486 if (device_param->kernel1) hc_clReleaseKernel (device_param->kernel1);
16487 if (device_param->kernel12) hc_clReleaseKernel (device_param->kernel12);
16488 if (device_param->kernel2) hc_clReleaseKernel (device_param->kernel2);
16489 if (device_param->kernel23) hc_clReleaseKernel (device_param->kernel23);
16490 if (device_param->kernel3) hc_clReleaseKernel (device_param->kernel3);
16491 if (device_param->kernel_mp) hc_clReleaseKernel (device_param->kernel_mp);
16492 if (device_param->kernel_mp_l) hc_clReleaseKernel (device_param->kernel_mp_l);
16493 if (device_param->kernel_mp_r) hc_clReleaseKernel (device_param->kernel_mp_r);
16494 if (device_param->kernel_tb) hc_clReleaseKernel (device_param->kernel_tb);
16495 if (device_param->kernel_tm) hc_clReleaseKernel (device_param->kernel_tm);
16496 if (device_param->kernel_amp) hc_clReleaseKernel (device_param->kernel_amp);
16497 if (device_param->kernel_weak) hc_clReleaseKernel (device_param->kernel_weak);
16498
16499 if (device_param->program) hc_clReleaseProgram (device_param->program);
16500 if (device_param->program_mp) hc_clReleaseProgram (device_param->program_mp);
16501 if (device_param->program_amp) hc_clReleaseProgram (device_param->program_amp);
16502 if (device_param->program_weak) hc_clReleaseProgram (device_param->program_weak);
16503
16504 if (device_param->command_queue) hc_clReleaseCommandQueue (device_param->command_queue);
16505 if (device_param->context) hc_clReleaseContext (device_param->context);
16506 }
16507
16508 // reset default fan speed
16509
16510 if (gpu_temp_disable == 0)
16511 {
16512 if (gpu_temp_retain != 0) // 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].fan_supported == 1)
16519 {
16520 int fanspeed = temp_retain_fanspeed_value[i];
16521
16522 if (fanspeed == -1) continue;
16523
16524 int rc = hm_set_fanspeed_with_device_id_amd (i, fanspeed);
16525
16526 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", i);
16527 }
16528 }
16529
16530 hc_thread_mutex_unlock (mux_adl);
16531 }
16532 }
16533
16534 // reset power tuning
16535
16536 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16537 {
16538 hc_thread_mutex_lock (mux_adl);
16539
16540 for (uint i = 0; i < data.devices_cnt; i++)
16541 {
16542 if (data.hm_device[i].od_version == 6)
16543 {
16544 // check powertune capabilities first, if not available then skip device
16545
16546 int powertune_supported = 0;
16547
16548 if ((hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll_amd, data.hm_device[i].adapter_index.amd, &powertune_supported)) != ADL_OK)
16549 {
16550 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16551
16552 return (-1);
16553 }
16554
16555 if (powertune_supported != 0)
16556 {
16557 // powercontrol settings
16558
16559 if ((hc_ADL_Overdrive_PowerControl_Set (data.hm_dll_amd, data.hm_device[i].adapter_index.amd, od_power_control_status[i])) != ADL_OK)
16560 {
16561 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16562
16563 return (-1);
16564 }
16565
16566 // clocks
16567
16568 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16569
16570 performance_state->iNumberOfPerformanceLevels = 2;
16571
16572 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[i].state.aLevels[0].iEngineClock;
16573 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[i].state.aLevels[1].iEngineClock;
16574 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[i].state.aLevels[0].iMemoryClock;
16575 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[i].state.aLevels[1].iMemoryClock;
16576
16577 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)
16578 {
16579 log_info ("ERROR: Failed to restore ADL performance state");
16580
16581 return (-1);
16582 }
16583
16584 local_free (performance_state);
16585 }
16586 }
16587 }
16588
16589 hc_thread_mutex_unlock (mux_adl);
16590 }
16591
16592 if (gpu_temp_disable == 0)
16593 {
16594 #ifdef LINUX
16595 if (data.hm_dll_nv)
16596 {
16597 hc_NVML_nvmlShutdown (data.hm_dll_nv);
16598
16599 hm_close (data.hm_dll_nv);
16600 }
16601 #endif
16602
16603 #ifdef WIN
16604 NvAPI_Unload ();
16605 #endif
16606
16607 if (data.hm_dll_amd)
16608 {
16609 hc_ADL_Main_Control_Destroy (data.hm_dll_amd);
16610
16611 hm_close (data.hm_dll_amd);
16612 }
16613 }
16614
16615 // free memory
16616
16617 local_free (masks);
16618
16619 local_free (dictstat_base);
16620
16621 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16622 {
16623 pot_t *pot_ptr = &pot[pot_pos];
16624
16625 hash_t *hash = &pot_ptr->hash;
16626
16627 local_free (hash->digest);
16628
16629 if (isSalted)
16630 {
16631 local_free (hash->salt);
16632 }
16633 }
16634
16635 local_free (pot);
16636
16637 local_free (all_kernel_rules_cnt);
16638 local_free (all_kernel_rules_buf);
16639
16640 local_free (wl_data->buf);
16641 local_free (wl_data);
16642
16643 local_free (bitmap_s1_a);
16644 local_free (bitmap_s1_b);
16645 local_free (bitmap_s1_c);
16646 local_free (bitmap_s1_d);
16647 local_free (bitmap_s2_a);
16648 local_free (bitmap_s2_b);
16649 local_free (bitmap_s2_c);
16650 local_free (bitmap_s2_d);
16651
16652 local_free (temp_retain_fanspeed_value);
16653 local_free (od_clock_mem_status);
16654 local_free (od_power_control_status);
16655
16656 global_free (devices_param);
16657
16658 global_free (kernel_rules_buf);
16659
16660 global_free (root_css_buf);
16661 global_free (markov_css_buf);
16662
16663 global_free (digests_buf);
16664 global_free (digests_shown);
16665 global_free (digests_shown_tmp);
16666
16667 global_free (salts_buf);
16668 global_free (salts_shown);
16669
16670 global_free (esalts_buf);
16671
16672 global_free (words_progress_done);
16673 global_free (words_progress_rejected);
16674 global_free (words_progress_restored);
16675
16676 if (pot_fp) fclose (pot_fp);
16677
16678 if (data.devices_status == STATUS_QUIT) break;
16679 }
16680
16681 // destroy others mutex
16682
16683 hc_thread_mutex_delete (mux_dispatcher);
16684 hc_thread_mutex_delete (mux_counter);
16685 hc_thread_mutex_delete (mux_display);
16686 hc_thread_mutex_delete (mux_adl);
16687
16688 // free memory
16689
16690 local_free (eff_restore_file);
16691 local_free (new_restore_file);
16692
16693 local_free (rd);
16694
16695 // loopback
16696
16697 local_free (loopback_file);
16698
16699 if (loopback == 1) unlink (loopback_file);
16700
16701 // induction directory
16702
16703 if (induction_dir == NULL)
16704 {
16705 if (attack_mode != ATTACK_MODE_BF)
16706 {
16707 if (rmdir (induction_directory) == -1)
16708 {
16709 if (errno == ENOENT)
16710 {
16711 // good, we can ignore
16712 }
16713 else if (errno == ENOTEMPTY)
16714 {
16715 // good, we can ignore
16716 }
16717 else
16718 {
16719 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
16720
16721 return (-1);
16722 }
16723 }
16724
16725 local_free (induction_directory);
16726 }
16727 }
16728
16729 // outfile-check directory
16730
16731 if (outfile_check_dir == NULL)
16732 {
16733 if (rmdir (outfile_check_directory) == -1)
16734 {
16735 if (errno == ENOENT)
16736 {
16737 // good, we can ignore
16738 }
16739 else if (errno == ENOTEMPTY)
16740 {
16741 // good, we can ignore
16742 }
16743 else
16744 {
16745 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
16746
16747 return (-1);
16748 }
16749 }
16750
16751 local_free (outfile_check_directory);
16752 }
16753
16754 time_t proc_stop;
16755
16756 time (&proc_stop);
16757
16758 logfile_top_uint (proc_start);
16759 logfile_top_uint (proc_stop);
16760
16761 logfile_top_msg ("STOP");
16762
16763 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
16764 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
16765
16766 if (data.devices_status == STATUS_ABORTED) return 2;
16767 if (data.devices_status == STATUS_QUIT) return 2;
16768 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
16769 if (data.devices_status == STATUS_EXHAUSTED) return 1;
16770 if (data.devices_status == STATUS_CRACKED) return 0;
16771
16772 return -1;
16773 }
Hashcat additions to support pwdhash