projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
HMS: nvapi does not need a dll (windows + NV)
[hashcat.git] / src / oclHashcat.c
1 /**
2 * Author......: Jens Steube <jens.steube@gmail.com>
3 * License.....: MIT
4 */
5
6 #include <common.h>
7 #include <shared.h>
8 #include <rp_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
13327 if ((weak_hash_threshold) && (attack_exec == ATTACK_EXEC_INSIDE_KERNEL) && (opts_type & add_flag))
13328 {
13329 /**
13330 * kernel source filename
13331 */
13332
13333 char source_file[256];
13334
13335 memset (source_file, 0, sizeof (source_file));
13336
13337 generate_source_kernel_filename (attack_exec, ATTACK_KERN_STRAIGHT, kern_type, shared_dir, source_file);
13338
13339 struct stat sst;
13340
13341 if (stat (source_file, &sst) == -1)
13342 {
13343 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13344
13345 return -1;
13346 }
13347
13348 /**
13349 * kernel cached filename
13350 */
13351
13352 char cached_file[256];
13353
13354 memset (cached_file, 0, sizeof (cached_file));
13355
13356 generate_cached_kernel_filename (attack_exec, ATTACK_KERN_STRAIGHT, kern_type, profile_dir, device_name_chksum, cached_file);
13357
13358 int cached = 1;
13359
13360 struct stat cst;
13361
13362 if (stat (cached_file, &cst) == -1)
13363 {
13364 cached = 0;
13365 }
13366
13367 /**
13368 * kernel compile or load
13369 */
13370
13371 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13372
13373 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13374
13375 if (force_jit_compilation == 0)
13376 {
13377 if (cached == 0)
13378 {
13379 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13380
13381 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13382
13383 device_param->program_weak = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13384
13385 hc_clBuildProgram (device_param->program_weak, 1, &device_param->device, build_opts, NULL, NULL);
13386
13387 size_t binary_size;
13388
13389 clGetProgramInfo (device_param->program_weak, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13390
13391 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13392
13393 clGetProgramInfo (device_param->program_weak, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13394
13395 writeProgramBin (cached_file, binary, binary_size);
13396
13397 local_free (binary);
13398 }
13399 else
13400 {
13401 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13402
13403 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13404
13405 device_param->program_weak = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13406
13407 hc_clBuildProgram (device_param->program_weak, 1, &device_param->device, build_opts, NULL, NULL);
13408 }
13409 }
13410 else
13411 {
13412 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13413
13414 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13415
13416 device_param->program_weak = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13417
13418 if (force_jit_compilation == 1500)
13419 {
13420 sprintf (build_opts, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13421 }
13422 else if (force_jit_compilation == 8900)
13423 {
13424 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);
13425 }
13426
13427 hc_clBuildProgram (device_param->program_weak, 1, &device_param->device, build_opts, NULL, NULL);
13428 }
13429
13430 local_free (kernel_lengths);
13431 local_free (kernel_sources[0]);
13432 local_free (kernel_sources);
13433
13434 // this is mostly for debug
13435
13436 size_t ret_val_size = 0;
13437
13438 clGetProgramBuildInfo (device_param->program_weak, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13439
13440 if (ret_val_size > 2)
13441 {
13442 char *build_log = (char *) mymalloc (ret_val_size + 1);
13443
13444 memset (build_log, 0, ret_val_size + 1);
13445
13446 clGetProgramBuildInfo (device_param->program_weak, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13447
13448 puts (build_log);
13449
13450 myfree (build_log);
13451 }
13452 }
13453
13454 /**
13455 * main kernel
13456 */
13457
13458 {
13459 /**
13460 * kernel source filename
13461 */
13462
13463 char source_file[256];
13464
13465 memset (source_file, 0, sizeof (source_file));
13466
13467 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13468
13469 struct stat sst;
13470
13471 if (stat (source_file, &sst) == -1)
13472 {
13473 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13474
13475 return -1;
13476 }
13477
13478 /**
13479 * kernel cached filename
13480 */
13481
13482 char cached_file[256];
13483
13484 memset (cached_file, 0, sizeof (cached_file));
13485
13486 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13487
13488 int cached = 1;
13489
13490 struct stat cst;
13491
13492 if (stat (cached_file, &cst) == -1)
13493 {
13494 cached = 0;
13495 }
13496
13497 /**
13498 * kernel compile or load
13499 */
13500
13501 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13502
13503 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13504
13505 if (force_jit_compilation == 0)
13506 {
13507 if (cached == 0)
13508 {
13509 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13510
13511 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13512
13513 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13514
13515 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13516
13517 size_t binary_size;
13518
13519 clGetProgramInfo (device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13520
13521 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13522
13523 clGetProgramInfo (device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13524
13525 writeProgramBin (cached_file, binary, binary_size);
13526
13527 local_free (binary);
13528 }
13529 else
13530 {
13531 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13532
13533 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13534
13535 device_param->program = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13536
13537 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13538 }
13539 }
13540 else
13541 {
13542 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13543
13544 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13545
13546 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13547
13548 if (force_jit_compilation == 1500)
13549 {
13550 sprintf (build_opts, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13551 }
13552 else if (force_jit_compilation == 8900)
13553 {
13554 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);
13555 }
13556
13557 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13558 }
13559
13560 local_free (kernel_lengths);
13561 local_free (kernel_sources[0]);
13562 local_free (kernel_sources);
13563
13564 // this is mostly for debug
13565
13566 size_t ret_val_size = 0;
13567
13568 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13569
13570 if (ret_val_size > 2)
13571 {
13572 char *build_log = (char *) mymalloc (ret_val_size + 1);
13573
13574 memset (build_log, 0, ret_val_size + 1);
13575
13576 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13577
13578 puts (build_log);
13579
13580 myfree (build_log);
13581 }
13582 }
13583
13584 /**
13585 * word generator kernel
13586 */
13587
13588 if (attack_mode != ATTACK_MODE_STRAIGHT)
13589 {
13590 /**
13591 * kernel mp source filename
13592 */
13593
13594 char source_file[256];
13595
13596 memset (source_file, 0, sizeof (source_file));
13597
13598 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
13599
13600 struct stat sst;
13601
13602 if (stat (source_file, &sst) == -1)
13603 {
13604 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13605
13606 return -1;
13607 }
13608
13609 /**
13610 * kernel mp cached filename
13611 */
13612
13613 char cached_file[256];
13614
13615 memset (cached_file, 0, sizeof (cached_file));
13616
13617 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
13618
13619 int cached = 1;
13620
13621 struct stat cst;
13622
13623 if (stat (cached_file, &cst) == -1)
13624 {
13625 cached = 0;
13626 }
13627
13628 /**
13629 * kernel compile or load
13630 */
13631
13632 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13633
13634 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13635
13636 if (cached == 0)
13637 {
13638 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13639
13640 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13641
13642 device_param->program_mp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13643
13644 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13645
13646 size_t binary_size;
13647
13648 clGetProgramInfo (device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13649
13650 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13651
13652 clGetProgramInfo (device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13653
13654 writeProgramBin (cached_file, binary, binary_size);
13655
13656 local_free (binary);
13657 }
13658 else
13659 {
13660 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13661
13662 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13663
13664 device_param->program_mp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13665
13666 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13667 }
13668
13669 local_free (kernel_lengths);
13670 local_free (kernel_sources[0]);
13671 local_free (kernel_sources);
13672
13673 // this is mostly for debug
13674
13675 size_t ret_val_size = 0;
13676
13677 clGetProgramBuildInfo (device_param->program_mp, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13678
13679 if (ret_val_size > 2)
13680 {
13681 char *build_log = (char *) mymalloc (ret_val_size + 1);
13682
13683 memset (build_log, 0, ret_val_size + 1);
13684
13685 clGetProgramBuildInfo (device_param->program_mp, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13686
13687 puts (build_log);
13688
13689 myfree (build_log);
13690 }
13691 }
13692
13693 /**
13694 * amplifier kernel
13695 */
13696
13697 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13698 {
13699
13700 }
13701 else
13702 {
13703 /**
13704 * kernel amp source filename
13705 */
13706
13707 char source_file[256];
13708
13709 memset (source_file, 0, sizeof (source_file));
13710
13711 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
13712
13713 struct stat sst;
13714
13715 if (stat (source_file, &sst) == -1)
13716 {
13717 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13718
13719 return -1;
13720 }
13721
13722 /**
13723 * kernel amp cached filename
13724 */
13725
13726 char cached_file[256];
13727
13728 memset (cached_file, 0, sizeof (cached_file));
13729
13730 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
13731
13732 int cached = 1;
13733
13734 struct stat cst;
13735
13736 if (stat (cached_file, &cst) == -1)
13737 {
13738 cached = 0;
13739 }
13740
13741 /**
13742 * kernel compile or load
13743 */
13744
13745 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13746
13747 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13748
13749 if (cached == 0)
13750 {
13751 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13752
13753 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13754
13755 device_param->program_amp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13756
13757 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13758
13759 size_t binary_size;
13760
13761 clGetProgramInfo (device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13762
13763 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13764
13765 clGetProgramInfo (device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13766
13767 writeProgramBin (cached_file, binary, binary_size);
13768
13769 local_free (binary);
13770 }
13771 else
13772 {
13773 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13774
13775 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13776
13777 device_param->program_amp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13778
13779 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13780 }
13781
13782 local_free (kernel_lengths);
13783 local_free (kernel_sources[0]);
13784 local_free (kernel_sources);
13785
13786 // this is mostly for debug
13787
13788 size_t ret_val_size = 0;
13789
13790 clGetProgramBuildInfo (device_param->program_amp, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13791
13792 if (ret_val_size > 2)
13793 {
13794 char *build_log = (char *) mymalloc (ret_val_size + 1);
13795
13796 memset (build_log, 0, ret_val_size + 1);
13797
13798 clGetProgramBuildInfo (device_param->program_amp, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13799
13800 puts (build_log);
13801
13802 myfree (build_log);
13803 }
13804 }
13805
13806 /**
13807 * global buffers
13808 */
13809
13810 device_param->d_pws_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13811 device_param->d_pws_amp_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13812 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
13813 device_param->d_tmps = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
13814 device_param->d_hooks = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
13815 device_param->d_bitmap_s1_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13816 device_param->d_bitmap_s1_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13817 device_param->d_bitmap_s1_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13818 device_param->d_bitmap_s1_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13819 device_param->d_bitmap_s2_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13820 device_param->d_bitmap_s2_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13821 device_param->d_bitmap_s2_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13822 device_param->d_bitmap_s2_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13823 device_param->d_plain_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
13824 device_param->d_digests_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
13825 device_param->d_digests_shown = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
13826 device_param->d_salt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
13827 device_param->d_result = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
13828 device_param->d_scryptV_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
13829
13830 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_a, CL_TRUE, 0, bitmap_size, bitmap_s1_a, 0, NULL, NULL);
13831 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_b, CL_TRUE, 0, bitmap_size, bitmap_s1_b, 0, NULL, NULL);
13832 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_c, CL_TRUE, 0, bitmap_size, bitmap_s1_c, 0, NULL, NULL);
13833 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_d, CL_TRUE, 0, bitmap_size, bitmap_s1_d, 0, NULL, NULL);
13834 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_a, CL_TRUE, 0, bitmap_size, bitmap_s2_a, 0, NULL, NULL);
13835 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_b, CL_TRUE, 0, bitmap_size, bitmap_s2_b, 0, NULL, NULL);
13836 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_c, CL_TRUE, 0, bitmap_size, bitmap_s2_c, 0, NULL, NULL);
13837 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_d, CL_TRUE, 0, bitmap_size, bitmap_s2_d, 0, NULL, NULL);
13838 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
13839 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
13840 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
13841
13842 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
13843 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
13844 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
13845 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
13846 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
13847 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
13848 run_kernel_bzero (device_param, device_param->d_result, size_results);
13849
13850 /**
13851 * special buffers
13852 */
13853
13854 if (attack_kern == ATTACK_KERN_STRAIGHT)
13855 {
13856 device_param->d_rules = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
13857
13858 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
13859 }
13860 else if (attack_kern == ATTACK_KERN_COMBI)
13861 {
13862 device_param->d_combs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13863 device_param->d_combs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13864 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13865 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13866
13867 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
13868 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
13869 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13870 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13871 }
13872 else if (attack_kern == ATTACK_KERN_BF)
13873 {
13874 device_param->d_bfs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13875 device_param->d_bfs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13876 device_param->d_tm_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
13877 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13878 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13879
13880 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
13881 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
13882 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
13883 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13884 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13885 }
13886
13887 if (size_esalts)
13888 {
13889 device_param->d_esalt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
13890
13891 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
13892 }
13893
13894 /**
13895 * main host data
13896 */
13897
13898 uint *result = (uint *) mymalloc (size_results);
13899
13900 memset (result, 0, size_results);
13901
13902 device_param->result = result;
13903
13904 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
13905
13906 memset (pws_buf, 0, size_pws);
13907
13908 device_param->pws_buf = pws_buf;
13909
13910 pw_cache_t *pw_caches = (pw_cache_t *) mycalloc (64, sizeof (pw_cache_t));
13911
13912 for (int i = 0; i < 64; i++)
13913 {
13914 pw_caches[i].pw_buf.pw_len = i;
13915 pw_caches[i].cnt = 0;
13916 }
13917
13918 device_param->pw_caches = pw_caches;
13919
13920 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
13921
13922 device_param->combs_buf = combs_buf;
13923
13924 void *hooks_buf = mymalloc (size_hooks);
13925
13926 device_param->hooks_buf = hooks_buf;
13927
13928 device_param->pw_transpose = pw_transpose_to_hi1;
13929 device_param->pw_add = pw_add_to_hc1;
13930
13931 /**
13932 * kernel args
13933 */
13934
13935 device_param->kernel_params_buf32[21] = bitmap_mask;
13936 device_param->kernel_params_buf32[22] = bitmap_shift1;
13937 device_param->kernel_params_buf32[23] = bitmap_shift2;
13938 device_param->kernel_params_buf32[24] = 0; // salt_pos
13939 device_param->kernel_params_buf32[25] = 0; // loop_pos
13940 device_param->kernel_params_buf32[26] = 0; // loop_cnt
13941 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
13942 device_param->kernel_params_buf32[28] = 0; // digests_cnt
13943 device_param->kernel_params_buf32[29] = 0; // digests_offset
13944 device_param->kernel_params_buf32[30] = 0; // combs_mode
13945 device_param->kernel_params_buf32[31] = 0; // gid_max
13946
13947 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13948 ? &device_param->d_pws_buf
13949 : &device_param->d_pws_amp_buf;
13950 device_param->kernel_params[ 1] = &device_param->d_rules_c;
13951 device_param->kernel_params[ 2] = &device_param->d_combs_c;
13952 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
13953 device_param->kernel_params[ 4] = &device_param->d_tmps;
13954 device_param->kernel_params[ 5] = &device_param->d_hooks;
13955 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
13956 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
13957 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
13958 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
13959 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
13960 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
13961 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
13962 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
13963 device_param->kernel_params[14] = &device_param->d_plain_bufs;
13964 device_param->kernel_params[15] = &device_param->d_digests_buf;
13965 device_param->kernel_params[16] = &device_param->d_digests_shown;
13966 device_param->kernel_params[17] = &device_param->d_salt_bufs;
13967 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
13968 device_param->kernel_params[19] = &device_param->d_result;
13969 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
13970 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
13971 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
13972 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
13973 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
13974 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
13975 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
13976 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
13977 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
13978 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
13979 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
13980 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
13981
13982 device_param->kernel_params_mp_buf64[3] = 0;
13983 device_param->kernel_params_mp_buf32[4] = 0;
13984 device_param->kernel_params_mp_buf32[5] = 0;
13985 device_param->kernel_params_mp_buf32[6] = 0;
13986 device_param->kernel_params_mp_buf32[7] = 0;
13987 device_param->kernel_params_mp_buf32[8] = 0;
13988
13989 device_param->kernel_params_mp[0] = NULL;
13990 device_param->kernel_params_mp[1] = NULL;
13991 device_param->kernel_params_mp[2] = NULL;
13992 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
13993 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
13994 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
13995 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
13996 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
13997 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
13998
13999 device_param->kernel_params_mp_l_buf64[3] = 0;
14000 device_param->kernel_params_mp_l_buf32[4] = 0;
14001 device_param->kernel_params_mp_l_buf32[5] = 0;
14002 device_param->kernel_params_mp_l_buf32[6] = 0;
14003 device_param->kernel_params_mp_l_buf32[7] = 0;
14004 device_param->kernel_params_mp_l_buf32[8] = 0;
14005 device_param->kernel_params_mp_l_buf32[9] = 0;
14006
14007 device_param->kernel_params_mp_l[0] = NULL;
14008 device_param->kernel_params_mp_l[1] = NULL;
14009 device_param->kernel_params_mp_l[2] = NULL;
14010 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14011 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14012 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14013 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14014 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14015 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14016 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14017
14018 device_param->kernel_params_mp_r_buf64[3] = 0;
14019 device_param->kernel_params_mp_r_buf32[4] = 0;
14020 device_param->kernel_params_mp_r_buf32[5] = 0;
14021 device_param->kernel_params_mp_r_buf32[6] = 0;
14022 device_param->kernel_params_mp_r_buf32[7] = 0;
14023 device_param->kernel_params_mp_r_buf32[8] = 0;
14024
14025 device_param->kernel_params_mp_r[0] = NULL;
14026 device_param->kernel_params_mp_r[1] = NULL;
14027 device_param->kernel_params_mp_r[2] = NULL;
14028 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14029 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14030 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14031 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14032 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14033 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14034
14035 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14036 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14037
14038 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14039 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14040 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14041 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14042 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14043 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14044 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14045
14046 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
14047
14048 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14049 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14050
14051 /**
14052 * kernel name
14053 */
14054
14055 char kernel_name[64];
14056
14057 memset (kernel_name, 0, sizeof (kernel_name));
14058
14059 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14060 {
14061 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14062 {
14063 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14064
14065 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
14066
14067 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14068
14069 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
14070
14071 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14072
14073 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
14074 }
14075 else
14076 {
14077 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14078
14079 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
14080
14081 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14082
14083 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
14084
14085 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14086
14087 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
14088 }
14089
14090 if (weak_hash_threshold)
14091 {
14092 if (opts_type & add_flag)
14093 {
14094 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14095 {
14096 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14097
14098 device_param->kernel_weak = hc_clCreateKernel (device_param->program_weak, kernel_name);
14099 }
14100 else
14101 {
14102 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14103
14104 device_param->kernel_weak = hc_clCreateKernel (device_param->program_weak, kernel_name);
14105 }
14106 }
14107 else
14108 {
14109 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14110 {
14111 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14112
14113 device_param->kernel_weak = hc_clCreateKernel (device_param->program, kernel_name);
14114 }
14115 else
14116 {
14117 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14118
14119 device_param->kernel_weak = hc_clCreateKernel (device_param->program, kernel_name);
14120 }
14121 }
14122 }
14123
14124 if (data.attack_mode == ATTACK_MODE_BF)
14125 {
14126 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14127 {
14128 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
14129
14130 device_param->kernel_tb = hc_clCreateKernel (device_param->program, kernel_name);
14131
14132 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14133
14134 device_param->kernel_tm = hc_clCreateKernel (device_param->program, kernel_name);
14135 }
14136 }
14137 }
14138 else
14139 {
14140 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14141
14142 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
14143
14144 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14145
14146 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
14147
14148 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14149
14150 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
14151
14152 if (opts_type & OPTS_TYPE_HOOK12)
14153 {
14154 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14155
14156 device_param->kernel12 = hc_clCreateKernel (device_param->program, kernel_name);
14157 }
14158
14159 if (opts_type & OPTS_TYPE_HOOK23)
14160 {
14161 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14162
14163 device_param->kernel23 = hc_clCreateKernel (device_param->program, kernel_name);
14164 }
14165 }
14166
14167 for (uint i = 0; i <= 20; i++)
14168 {
14169 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14170 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14171 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14172
14173 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14174 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14175
14176 if (weak_hash_threshold)
14177 {
14178 hc_clSetKernelArg (device_param->kernel_weak, i, sizeof (cl_mem), device_param->kernel_params[i]);
14179 }
14180 }
14181
14182 for (uint i = 21; i <= 31; i++)
14183 {
14184 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14185 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14186 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14187
14188 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14189 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14190
14191 if (weak_hash_threshold)
14192 {
14193 hc_clSetKernelArg (device_param->kernel_weak, i, sizeof (cl_uint), device_param->kernel_params[i]);
14194 }
14195 }
14196
14197 if (attack_mode == ATTACK_MODE_BF)
14198 {
14199 device_param->kernel_mp_l = hc_clCreateKernel (device_param->program_mp, "l_markov");
14200 device_param->kernel_mp_r = hc_clCreateKernel (device_param->program_mp, "r_markov");
14201
14202 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14203 {
14204 hc_clSetKernelArg (device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
14205
14206 hc_clSetKernelArg (device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14207 hc_clSetKernelArg (device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14208 }
14209 }
14210 else if (attack_mode == ATTACK_MODE_HYBRID1)
14211 {
14212 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
14213 }
14214 else if (attack_mode == ATTACK_MODE_HYBRID2)
14215 {
14216 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
14217 }
14218
14219 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14220 {
14221 // nothing to do
14222 }
14223 else
14224 {
14225 device_param->kernel_amp = hc_clCreateKernel (device_param->program_amp, "amp");
14226 }
14227
14228 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14229 {
14230 // nothing to do
14231 }
14232 else
14233 {
14234 for (uint i = 0; i < 5; i++)
14235 {
14236 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14237 }
14238
14239 for (uint i = 5; i < 7; i++)
14240 {
14241 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14242 }
14243 }
14244
14245 /**
14246 * Store initial fanspeed if gpu_temp_retain is enabled
14247 */
14248
14249 int gpu_temp_retain_set = 0;
14250
14251 if (gpu_temp_disable == 0)
14252 {
14253 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14254 {
14255 hc_thread_mutex_lock (mux_adl);
14256
14257 if (data.hm_device[device_id].fan_supported == 1)
14258 {
14259 if (gpu_temp_retain_chgd == 0)
14260 {
14261 uint cur_temp = 0;
14262 uint default_temp = 0;
14263
14264 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);
14265
14266 if (ADL_rc == ADL_OK)
14267 {
14268 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14269
14270 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14271
14272 // special case with multi gpu setups: always use minimum retain
14273
14274 if (gpu_temp_retain_set == 0)
14275 {
14276 gpu_temp_retain = gpu_temp_retain_target;
14277 gpu_temp_retain_set = 1;
14278 }
14279 else
14280 {
14281 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14282 }
14283
14284 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14285 }
14286 }
14287
14288 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14289
14290 temp_retain_fanspeed_value[device_id] = fan_speed;
14291
14292 if (fan_speed == -1)
14293 {
14294 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14295
14296 temp_retain_fanspeed_value[device_id] = 0;
14297 }
14298 }
14299
14300 hc_thread_mutex_unlock (mux_adl);
14301 }
14302 }
14303
14304 /**
14305 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14306 */
14307
14308 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14309 {
14310 hc_thread_mutex_lock (mux_adl);
14311
14312 if (data.hm_device[device_id].od_version == 6)
14313 {
14314 int ADL_rc;
14315
14316 // check powertune capabilities first, if not available then skip device
14317
14318 int powertune_supported = 0;
14319
14320 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14321 {
14322 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14323
14324 return (-1);
14325 }
14326
14327 if (powertune_supported != 0)
14328 {
14329 // powercontrol settings
14330
14331 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14332
14333 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14334 {
14335 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]);
14336 }
14337
14338 if (ADL_rc != ADL_OK)
14339 {
14340 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14341
14342 return (-1);
14343 }
14344
14345 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14346 {
14347 log_error ("ERROR: Failed to set new ADL PowerControl values");
14348
14349 return (-1);
14350 }
14351
14352 // clocks
14353
14354 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14355
14356 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14357
14358 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)
14359 {
14360 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14361
14362 return (-1);
14363 }
14364
14365 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14366
14367 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14368
14369 if ((ADL_rc = hc_ADL_Overdrive_Capabilities_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14370 {
14371 log_error ("ERROR: Failed to get ADL device capabilities");
14372
14373 return (-1);
14374 }
14375
14376 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14377 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14378
14379 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14380 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14381
14382 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14383 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14384
14385 // warning if profile has to low max values
14386
14387 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14388 {
14389 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14390 }
14391
14392 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14393 {
14394 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14395 }
14396
14397 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14398
14399 performance_state->iNumberOfPerformanceLevels = 2;
14400
14401 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14402 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14403 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14404 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14405
14406 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)
14407 {
14408 log_info ("ERROR: Failed to set ADL performance state");
14409
14410 return (-1);
14411 }
14412
14413 local_free (performance_state);
14414 }
14415 }
14416
14417 hc_thread_mutex_unlock (mux_adl);
14418 }
14419 }
14420
14421 data.kernel_blocks_all = kernel_blocks_all;
14422
14423 if (data.quiet == 0) log_info ("");
14424
14425 /**
14426 * Inform user which algorithm is checked and at which workload setting
14427 */
14428
14429 if (benchmark == 1)
14430 {
14431 quiet = 0;
14432
14433 data.quiet = quiet;
14434
14435 char *hash_type = strhashtype (data.hash_mode); // not a bug
14436
14437 log_info ("Hashtype: %s", hash_type);
14438 log_info ("Workload: %u loops, %u accel", kernel_loops, kernel_accel);
14439 log_info ("");
14440 }
14441
14442 /**
14443 * keep track of the progress
14444 */
14445
14446 data.words_progress_done = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
14447 data.words_progress_rejected = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
14448 data.words_progress_restored = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
14449
14450 /**
14451 * open filehandles
14452 */
14453
14454 #if _WIN
14455 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14456 {
14457 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14458
14459 return (-1);
14460 }
14461
14462 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14463 {
14464 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14465
14466 return (-1);
14467 }
14468
14469 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14470 {
14471 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14472
14473 return (-1);
14474 }
14475 #endif
14476
14477 /**
14478 * dictionary pad
14479 */
14480
14481 segment_size *= (1024 * 1024);
14482
14483 data.segment_size = segment_size;
14484
14485 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14486
14487 wl_data->buf = (char *) mymalloc (segment_size);
14488 wl_data->avail = segment_size;
14489 wl_data->incr = segment_size;
14490 wl_data->cnt = 0;
14491 wl_data->pos = 0;
14492
14493 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14494
14495 data.wordlist_mode = wordlist_mode;
14496
14497 cs_t *css_buf = NULL;
14498 uint css_cnt = 0;
14499 uint dictcnt = 0;
14500 uint maskcnt = 1;
14501 char **masks = NULL;
14502 char **dictfiles = NULL;
14503
14504 uint mask_from_file = 0;
14505
14506 if (attack_mode == ATTACK_MODE_STRAIGHT)
14507 {
14508 if (wordlist_mode == WL_MODE_FILE)
14509 {
14510 int wls_left = myargc - (optind + 1);
14511
14512 for (int i = 0; i < wls_left; i++)
14513 {
14514 char *l0_filename = myargv[optind + 1 + i];
14515
14516 struct stat l0_stat;
14517
14518 if (stat (l0_filename, &l0_stat) == -1)
14519 {
14520 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14521
14522 return (-1);
14523 }
14524
14525 uint is_dir = S_ISDIR (l0_stat.st_mode);
14526
14527 if (is_dir == 0)
14528 {
14529 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14530
14531 dictcnt++;
14532
14533 dictfiles[dictcnt - 1] = l0_filename;
14534 }
14535 else
14536 {
14537 // do not allow --keyspace w/ a directory
14538
14539 if (keyspace == 1)
14540 {
14541 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14542
14543 return (-1);
14544 }
14545
14546 char **dictionary_files = NULL;
14547
14548 dictionary_files = scan_directory (l0_filename);
14549
14550 if (dictionary_files != NULL)
14551 {
14552 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14553
14554 for (int d = 0; dictionary_files[d] != NULL; d++)
14555 {
14556 char *l1_filename = dictionary_files[d];
14557
14558 struct stat l1_stat;
14559
14560 if (stat (l1_filename, &l1_stat) == -1)
14561 {
14562 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14563
14564 return (-1);
14565 }
14566
14567 if (S_ISREG (l1_stat.st_mode))
14568 {
14569 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14570
14571 dictcnt++;
14572
14573 dictfiles[dictcnt - 1] = strdup (l1_filename);
14574 }
14575 }
14576 }
14577
14578 local_free (dictionary_files);
14579 }
14580 }
14581
14582 if (dictcnt < 1)
14583 {
14584 log_error ("ERROR: No usable dictionary file found.");
14585
14586 return (-1);
14587 }
14588 }
14589 else if (wordlist_mode == WL_MODE_STDIN)
14590 {
14591 dictcnt = 1;
14592 }
14593 }
14594 else if (attack_mode == ATTACK_MODE_COMBI)
14595 {
14596 // display
14597
14598 char *dictfile1 = myargv[optind + 1 + 0];
14599 char *dictfile2 = myargv[optind + 1 + 1];
14600
14601 // find the bigger dictionary and use as base
14602
14603 FILE *fp1;
14604 FILE *fp2;
14605
14606 struct stat tmp_stat;
14607
14608 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14609 {
14610 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14611
14612 return (-1);
14613 }
14614
14615 if (stat (dictfile1, &tmp_stat) == -1)
14616 {
14617 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14618
14619 fclose (fp1);
14620
14621 return (-1);
14622 }
14623
14624 if (S_ISDIR (tmp_stat.st_mode))
14625 {
14626 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14627
14628 fclose (fp1);
14629
14630 return (-1);
14631 }
14632
14633 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14634 {
14635 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14636
14637 fclose (fp1);
14638
14639 return (-1);
14640 }
14641
14642 if (stat (dictfile2, &tmp_stat) == -1)
14643 {
14644 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14645
14646 fclose (fp1);
14647 fclose (fp2);
14648
14649 return (-1);
14650 }
14651
14652 if (S_ISDIR (tmp_stat.st_mode))
14653 {
14654 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14655
14656 fclose (fp1);
14657 fclose (fp2);
14658
14659 return (-1);
14660 }
14661
14662 data.combs_cnt = 1;
14663
14664 data.quiet = 1;
14665
14666 const uint64_t words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14667
14668 data.quiet = quiet;
14669
14670 if (words1_cnt == 0)
14671 {
14672 log_error ("ERROR: %s: empty file", dictfile1);
14673
14674 fclose (fp1);
14675 fclose (fp2);
14676
14677 return (-1);
14678 }
14679
14680 data.combs_cnt = 1;
14681
14682 data.quiet = 1;
14683
14684 const uint64_t words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14685
14686 data.quiet = quiet;
14687
14688 if (words2_cnt == 0)
14689 {
14690 log_error ("ERROR: %s: empty file", dictfile2);
14691
14692 fclose (fp1);
14693 fclose (fp2);
14694
14695 return (-1);
14696 }
14697
14698 fclose (fp1);
14699 fclose (fp2);
14700
14701 data.dictfile = dictfile1;
14702 data.dictfile2 = dictfile2;
14703
14704 if (words1_cnt >= words2_cnt)
14705 {
14706 data.combs_cnt = words2_cnt;
14707 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14708
14709 dictfiles = &data.dictfile;
14710
14711 dictcnt = 1;
14712 }
14713 else
14714 {
14715 data.combs_cnt = words1_cnt;
14716 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14717
14718 dictfiles = &data.dictfile2;
14719
14720 dictcnt = 1;
14721
14722 // we also have to switch wordlist related rules!
14723
14724 char *tmpc = data.rule_buf_l;
14725
14726 data.rule_buf_l = data.rule_buf_r;
14727 data.rule_buf_r = tmpc;
14728
14729 int tmpi = data.rule_len_l;
14730
14731 data.rule_len_l = data.rule_len_r;
14732 data.rule_len_r = tmpi;
14733 }
14734 }
14735 else if (attack_mode == ATTACK_MODE_BF)
14736 {
14737 char *mask = NULL;
14738
14739 maskcnt = 0;
14740
14741 if (benchmark == 0)
14742 {
14743 mask = myargv[optind + 1];
14744
14745 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
14746
14747 if ((optind + 2) <= myargc)
14748 {
14749 struct stat file_stat;
14750
14751 if (stat (mask, &file_stat) == -1)
14752 {
14753 maskcnt = 1;
14754
14755 masks[maskcnt - 1] = mystrdup (mask);
14756 }
14757 else
14758 {
14759 int wls_left = myargc - (optind + 1);
14760
14761 uint masks_avail = INCR_MASKS;
14762
14763 for (int i = 0; i < wls_left; i++)
14764 {
14765 if (i != 0)
14766 {
14767 mask = myargv[optind + 1 + i];
14768
14769 if (stat (mask, &file_stat) == -1)
14770 {
14771 log_error ("ERROR: %s: %s", mask, strerror (errno));
14772
14773 return (-1);
14774 }
14775 }
14776
14777 uint is_file = S_ISREG (file_stat.st_mode);
14778
14779 if (is_file == 1)
14780 {
14781 FILE *mask_fp;
14782
14783 if ((mask_fp = fopen (mask, "r")) == NULL)
14784 {
14785 log_error ("ERROR: %s: %s", mask, strerror (errno));
14786
14787 return (-1);
14788 }
14789
14790 char line_buf[BUFSIZ];
14791
14792 while (!feof (mask_fp))
14793 {
14794 memset (line_buf, 0, BUFSIZ);
14795
14796 int line_len = fgetl (mask_fp, line_buf);
14797
14798 if (line_len == 0) continue;
14799
14800 if (line_buf[0] == '#') continue;
14801
14802 if (masks_avail == maskcnt)
14803 {
14804 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14805
14806 masks_avail += INCR_MASKS;
14807 }
14808
14809 masks[maskcnt] = mystrdup (line_buf);
14810
14811 maskcnt++;
14812 }
14813
14814 fclose (mask_fp);
14815 }
14816 else
14817 {
14818 log_error ("ERROR: %s: unsupported file-type", mask);
14819
14820 return (-1);
14821 }
14822 }
14823
14824 mask_from_file = 1;
14825 }
14826 }
14827 else
14828 {
14829 custom_charset_1 = (char *) "?l?d?u";
14830 custom_charset_2 = (char *) "?l?d";
14831 custom_charset_3 = (char *) "?l?d*!$@_";
14832
14833 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
14834 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
14835 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
14836
14837 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
14838
14839 wordlist_mode = WL_MODE_MASK;
14840
14841 data.wordlist_mode = wordlist_mode;
14842
14843 increment = 1;
14844
14845 maskcnt = 1;
14846 }
14847 }
14848 else
14849 {
14850 /**
14851 * generate full masks and charsets
14852 */
14853
14854 masks = (char **) mymalloc (sizeof (char *));
14855
14856 switch (hash_mode)
14857 {
14858 case 1731: pw_min = 5;
14859 pw_max = 5;
14860 mask = mystrdup ("?b?b?b?b?b");
14861 break;
14862 case 12500: pw_min = 5;
14863 pw_max = 5;
14864 mask = mystrdup ("?b?b?b?b?b");
14865 break;
14866 default: pw_min = 7;
14867 pw_max = 7;
14868 mask = mystrdup ("?b?b?b?b?b?b?b");
14869 break;
14870 }
14871
14872 maskcnt = 1;
14873
14874 masks[maskcnt - 1] = mystrdup (mask);
14875
14876 wordlist_mode = WL_MODE_MASK;
14877
14878 data.wordlist_mode = wordlist_mode;
14879
14880 increment = 1;
14881 }
14882
14883 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
14884
14885 if (increment)
14886 {
14887 if (increment_min > pw_min) pw_min = increment_min;
14888
14889 if (increment_max < pw_max) pw_max = increment_max;
14890 }
14891 }
14892 else if (attack_mode == ATTACK_MODE_HYBRID1)
14893 {
14894 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14895
14896 // display
14897
14898 char *mask = myargv[myargc - 1];
14899
14900 maskcnt = 0;
14901
14902 masks = (char **) mymalloc (1 * sizeof (char *));
14903
14904 // mod
14905
14906 struct stat file_stat;
14907
14908 if (stat (mask, &file_stat) == -1)
14909 {
14910 maskcnt = 1;
14911
14912 masks[maskcnt - 1] = mystrdup (mask);
14913 }
14914 else
14915 {
14916 uint is_file = S_ISREG (file_stat.st_mode);
14917
14918 if (is_file == 1)
14919 {
14920 FILE *mask_fp;
14921
14922 if ((mask_fp = fopen (mask, "r")) == NULL)
14923 {
14924 log_error ("ERROR: %s: %s", mask, strerror (errno));
14925
14926 return (-1);
14927 }
14928
14929 char line_buf[BUFSIZ];
14930
14931 uint masks_avail = 1;
14932
14933 while (!feof (mask_fp))
14934 {
14935 memset (line_buf, 0, BUFSIZ);
14936
14937 int line_len = fgetl (mask_fp, line_buf);
14938
14939 if (line_len == 0) continue;
14940
14941 if (line_buf[0] == '#') continue;
14942
14943 if (masks_avail == maskcnt)
14944 {
14945 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14946
14947 masks_avail += INCR_MASKS;
14948 }
14949
14950 masks[maskcnt] = mystrdup (line_buf);
14951
14952 maskcnt++;
14953 }
14954
14955 fclose (mask_fp);
14956
14957 mask_from_file = 1;
14958 }
14959 else
14960 {
14961 maskcnt = 1;
14962
14963 masks[maskcnt - 1] = mystrdup (mask);
14964 }
14965 }
14966
14967 // base
14968
14969 int wls_left = myargc - (optind + 2);
14970
14971 for (int i = 0; i < wls_left; i++)
14972 {
14973 char *filename = myargv[optind + 1 + i];
14974
14975 struct stat file_stat;
14976
14977 if (stat (filename, &file_stat) == -1)
14978 {
14979 log_error ("ERROR: %s: %s", filename, strerror (errno));
14980
14981 return (-1);
14982 }
14983
14984 uint is_dir = S_ISDIR (file_stat.st_mode);
14985
14986 if (is_dir == 0)
14987 {
14988 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14989
14990 dictcnt++;
14991
14992 dictfiles[dictcnt - 1] = filename;
14993 }
14994 else
14995 {
14996 // do not allow --keyspace w/ a directory
14997
14998 if (keyspace == 1)
14999 {
15000 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15001
15002 return (-1);
15003 }
15004
15005 char **dictionary_files = NULL;
15006
15007 dictionary_files = scan_directory (filename);
15008
15009 if (dictionary_files != NULL)
15010 {
15011 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15012
15013 for (int d = 0; dictionary_files[d] != NULL; d++)
15014 {
15015 char *l1_filename = dictionary_files[d];
15016
15017 struct stat l1_stat;
15018
15019 if (stat (l1_filename, &l1_stat) == -1)
15020 {
15021 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15022
15023 return (-1);
15024 }
15025
15026 if (S_ISREG (l1_stat.st_mode))
15027 {
15028 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15029
15030 dictcnt++;
15031
15032 dictfiles[dictcnt - 1] = strdup (l1_filename);
15033 }
15034 }
15035 }
15036
15037 local_free (dictionary_files);
15038 }
15039 }
15040
15041 if (dictcnt < 1)
15042 {
15043 log_error ("ERROR: No usable dictionary file found.");
15044
15045 return (-1);
15046 }
15047
15048 if (increment)
15049 {
15050 maskcnt = 0;
15051
15052 uint mask_min = increment_min; // we can't reject smaller masks here
15053 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15054
15055 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15056 {
15057 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15058
15059 if (cur_mask == NULL) break;
15060
15061 masks[maskcnt] = cur_mask;
15062
15063 maskcnt++;
15064
15065 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15066 }
15067 }
15068 }
15069 else if (attack_mode == ATTACK_MODE_HYBRID2)
15070 {
15071 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15072
15073 // display
15074
15075 char *mask = myargv[optind + 1 + 0];
15076
15077 maskcnt = 0;
15078
15079 masks = (char **) mymalloc (1 * sizeof (char *));
15080
15081 // mod
15082
15083 struct stat file_stat;
15084
15085 if (stat (mask, &file_stat) == -1)
15086 {
15087 maskcnt = 1;
15088
15089 masks[maskcnt - 1] = mystrdup (mask);
15090 }
15091 else
15092 {
15093 uint is_file = S_ISREG (file_stat.st_mode);
15094
15095 if (is_file == 1)
15096 {
15097 FILE *mask_fp;
15098
15099 if ((mask_fp = fopen (mask, "r")) == NULL)
15100 {
15101 log_error ("ERROR: %s: %s", mask, strerror (errno));
15102
15103 return (-1);
15104 }
15105
15106 char line_buf[BUFSIZ];
15107
15108 uint masks_avail = 1;
15109
15110 while (!feof (mask_fp))
15111 {
15112 memset (line_buf, 0, BUFSIZ);
15113
15114 int line_len = fgetl (mask_fp, line_buf);
15115
15116 if (line_len == 0) continue;
15117
15118 if (line_buf[0] == '#') continue;
15119
15120 if (masks_avail == maskcnt)
15121 {
15122 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15123
15124 masks_avail += INCR_MASKS;
15125 }
15126
15127 masks[maskcnt] = mystrdup (line_buf);
15128
15129 maskcnt++;
15130 }
15131
15132 fclose (mask_fp);
15133
15134 mask_from_file = 1;
15135 }
15136 else
15137 {
15138 maskcnt = 1;
15139
15140 masks[maskcnt - 1] = mystrdup (mask);
15141 }
15142 }
15143
15144 // base
15145
15146 int wls_left = myargc - (optind + 2);
15147
15148 for (int i = 0; i < wls_left; i++)
15149 {
15150 char *filename = myargv[optind + 2 + i];
15151
15152 struct stat file_stat;
15153
15154 if (stat (filename, &file_stat) == -1)
15155 {
15156 log_error ("ERROR: %s: %s", filename, strerror (errno));
15157
15158 return (-1);
15159 }
15160
15161 uint is_dir = S_ISDIR (file_stat.st_mode);
15162
15163 if (is_dir == 0)
15164 {
15165 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15166
15167 dictcnt++;
15168
15169 dictfiles[dictcnt - 1] = filename;
15170 }
15171 else
15172 {
15173 // do not allow --keyspace w/ a directory
15174
15175 if (keyspace == 1)
15176 {
15177 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15178
15179 return (-1);
15180 }
15181
15182 char **dictionary_files = NULL;
15183
15184 dictionary_files = scan_directory (filename);
15185
15186 if (dictionary_files != NULL)
15187 {
15188 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15189
15190 for (int d = 0; dictionary_files[d] != NULL; d++)
15191 {
15192 char *l1_filename = dictionary_files[d];
15193
15194 struct stat l1_stat;
15195
15196 if (stat (l1_filename, &l1_stat) == -1)
15197 {
15198 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15199
15200 return (-1);
15201 }
15202
15203 if (S_ISREG (l1_stat.st_mode))
15204 {
15205 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15206
15207 dictcnt++;
15208
15209 dictfiles[dictcnt - 1] = strdup (l1_filename);
15210 }
15211 }
15212 }
15213
15214 local_free (dictionary_files);
15215 }
15216 }
15217
15218 if (dictcnt < 1)
15219 {
15220 log_error ("ERROR: No usable dictionary file found.");
15221
15222 return (-1);
15223 }
15224
15225 if (increment)
15226 {
15227 maskcnt = 0;
15228
15229 uint mask_min = increment_min; // we can't reject smaller masks here
15230 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15231
15232 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15233 {
15234 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15235
15236 if (cur_mask == NULL) break;
15237
15238 masks[maskcnt] = cur_mask;
15239
15240 maskcnt++;
15241
15242 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15243 }
15244 }
15245 }
15246
15247 data.pw_min = pw_min;
15248 data.pw_max = pw_max;
15249
15250 /**
15251 * weak hash check
15252 */
15253
15254 if (weak_hash_threshold >= salts_cnt)
15255 {
15256 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15257
15258 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15259 {
15260 weak_hash_check (&data.devices_param[0], salt_pos, kernel_loops);
15261 }
15262 }
15263
15264 // Display hack, guarantee that there is at least one \r before real start
15265
15266 if (data.quiet == 0) log_info_nn ("");
15267
15268 /**
15269 * status and monitor threads
15270 */
15271
15272 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15273
15274 hc_thread_t i_thread = 0;
15275
15276 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15277 {
15278 hc_thread_create (i_thread, thread_keypress, &benchmark);
15279 }
15280
15281 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15282
15283 uint ni_threads_cnt = 0;
15284
15285 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15286
15287 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15288
15289 ni_threads_cnt++;
15290
15291 /**
15292 * Outfile remove
15293 */
15294
15295 if (keyspace == 0)
15296 {
15297 if (outfile_check_timer != 0)
15298 {
15299 if (data.outfile_check_directory != NULL)
15300 {
15301 if ((hash_mode != 5200) &&
15302 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15303 (hash_mode != 9000))
15304 {
15305 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15306
15307 ni_threads_cnt++;
15308 }
15309 else
15310 {
15311 outfile_check_timer = 0;
15312 }
15313 }
15314 else
15315 {
15316 outfile_check_timer = 0;
15317 }
15318 }
15319 }
15320
15321 /**
15322 * Inform the user if we got some hashes remove because of the pot file remove feature
15323 */
15324
15325 if (data.quiet == 0)
15326 {
15327 if (potfile_remove_cracks > 0)
15328 {
15329 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15330 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15331 }
15332 }
15333
15334 data.outfile_check_timer = outfile_check_timer;
15335
15336 /**
15337 * main loop
15338 */
15339
15340 char **induction_dictionaries = NULL;
15341
15342 int induction_dictionaries_cnt = 0;
15343
15344 hcstat_table_t *root_table_buf = NULL;
15345 hcstat_table_t *markov_table_buf = NULL;
15346
15347 uint initial_restore_done = 0;
15348
15349 data.maskcnt = maskcnt;
15350
15351 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15352 {
15353 if (data.devices_status == STATUS_CRACKED) break;
15354
15355 data.devices_status = STATUS_INIT;
15356
15357 if (maskpos > rd->maskpos)
15358 {
15359 rd->dictpos = 0;
15360 }
15361
15362 rd->maskpos = maskpos;
15363 data.maskpos = maskpos;
15364
15365 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15366 {
15367 char *mask = masks[maskpos];
15368
15369 if (mask_from_file == 1)
15370 {
15371 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15372
15373 char *str_ptr;
15374 uint str_pos;
15375
15376 uint mask_offset = 0;
15377
15378 uint separator_cnt;
15379
15380 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15381 {
15382 str_ptr = strstr (mask + mask_offset, ",");
15383
15384 if (str_ptr == NULL) break;
15385
15386 str_pos = str_ptr - mask;
15387
15388 // escaped separator, i.e. "\,"
15389
15390 if (str_pos > 0)
15391 {
15392 if (mask[str_pos - 1] == '\\')
15393 {
15394 separator_cnt --;
15395
15396 mask_offset = str_pos + 1;
15397
15398 continue;
15399 }
15400 }
15401
15402 // reset the offset
15403
15404 mask_offset = 0;
15405
15406 mask[str_pos] = '\0';
15407
15408 switch (separator_cnt)
15409 {
15410 case 0:
15411 mp_reset_usr (mp_usr, 0);
15412
15413 custom_charset_1 = mask;
15414 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15415 break;
15416
15417 case 1:
15418 mp_reset_usr (mp_usr, 1);
15419
15420 custom_charset_2 = mask;
15421 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15422 break;
15423
15424 case 2:
15425 mp_reset_usr (mp_usr, 2);
15426
15427 custom_charset_3 = mask;
15428 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15429 break;
15430
15431 case 3:
15432 mp_reset_usr (mp_usr, 3);
15433
15434 custom_charset_4 = mask;
15435 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15436 break;
15437 }
15438
15439 mask = mask + str_pos + 1;
15440 }
15441 }
15442
15443 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15444 {
15445 if (maskpos > 0)
15446 {
15447 local_free (css_buf);
15448 local_free (data.root_css_buf);
15449 local_free (data.markov_css_buf);
15450
15451 local_free (masks[maskpos - 1]);
15452 }
15453
15454 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15455
15456 data.mask = mask;
15457 data.css_cnt = css_cnt;
15458 data.css_buf = css_buf;
15459
15460 uint uniq_tbls[SP_PW_MAX][CHARSIZ];
15461
15462 memset (uniq_tbls, 0, sizeof (uniq_tbls));
15463
15464 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15465
15466 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15467 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15468
15469 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15470
15471 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15472
15473 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15474 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15475
15476 data.root_css_buf = root_css_buf;
15477 data.markov_css_buf = markov_css_buf;
15478
15479 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15480
15481 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15482
15483 local_free (root_table_buf);
15484 local_free (markov_table_buf);
15485
15486 // args
15487
15488 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15489 {
15490 hc_device_param_t *device_param = &data.devices_param[device_id];
15491
15492 device_param->kernel_params_mp[0] = &device_param->d_combs;
15493 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15494 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15495
15496 device_param->kernel_params_mp_buf64[3] = 0;
15497 device_param->kernel_params_mp_buf32[4] = css_cnt;
15498 device_param->kernel_params_mp_buf32[5] = 0;
15499 device_param->kernel_params_mp_buf32[6] = 0;
15500 device_param->kernel_params_mp_buf32[7] = 0;
15501
15502 if (attack_mode == ATTACK_MODE_HYBRID1)
15503 {
15504 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15505 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15506 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15507 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15508 }
15509 else if (attack_mode == ATTACK_MODE_HYBRID2)
15510 {
15511 device_param->kernel_params_mp_buf32[5] = 0;
15512 device_param->kernel_params_mp_buf32[6] = 0;
15513 device_param->kernel_params_mp_buf32[7] = 0;
15514 }
15515
15516 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp[i]);
15517 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp[i]);
15518 for (uint i = 4; i < 8; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp[i]);
15519
15520 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);
15521 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);
15522 }
15523 }
15524 else if (attack_mode == ATTACK_MODE_BF)
15525 {
15526 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15527
15528 if (increment)
15529 {
15530 for (uint i = 0; i < dictcnt; i++)
15531 {
15532 local_free (dictfiles[i]);
15533 }
15534
15535 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15536 {
15537 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15538
15539 if (l1_filename == NULL) break;
15540
15541 dictcnt++;
15542
15543 dictfiles[dictcnt - 1] = l1_filename;
15544 }
15545 }
15546 else
15547 {
15548 dictcnt++;
15549
15550 dictfiles[dictcnt - 1] = mask;
15551 }
15552
15553 if (dictcnt == 0)
15554 {
15555 log_error ("ERROR: Mask is too small");
15556
15557 return (-1);
15558 }
15559 }
15560 }
15561
15562 free (induction_dictionaries);
15563
15564 // induction_dictionaries_cnt = 0; // implied
15565
15566 if (attack_mode != ATTACK_MODE_BF)
15567 {
15568 if (keyspace == 0)
15569 {
15570 induction_dictionaries = scan_directory (induction_directory);
15571
15572 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15573 }
15574 }
15575
15576 if (induction_dictionaries_cnt)
15577 {
15578 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15579 }
15580
15581 /**
15582 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15583 */
15584 if (keyspace == 1)
15585 {
15586 if ((maskcnt > 1) || (dictcnt > 1))
15587 {
15588 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15589
15590 return (-1);
15591 }
15592 }
15593
15594 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15595 {
15596 char *subid = logfile_generate_subid ();
15597
15598 data.subid = subid;
15599
15600 logfile_sub_msg ("START");
15601
15602 data.devices_status = STATUS_INIT;
15603
15604 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (uint64_t));
15605 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (uint64_t));
15606 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (uint64_t));
15607
15608 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15609
15610 data.cpt_pos = 0;
15611
15612 data.cpt_start = time (NULL);
15613
15614 data.cpt_total = 0;
15615
15616 if (data.restore == 0)
15617 {
15618 rd->words_cur = skip;
15619
15620 skip = 0;
15621
15622 data.skip = 0;
15623 }
15624
15625 data.ms_paused = 0;
15626
15627 data.words_cur = rd->words_cur;
15628
15629 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15630 {
15631 hc_device_param_t *device_param = &data.devices_param[device_id];
15632
15633 device_param->speed_pos = 0;
15634
15635 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (uint64_t));
15636 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15637 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15638
15639 device_param->kernel_power = device_param->kernel_power_user;
15640 device_param->kernel_blocks = device_param->kernel_blocks_user;
15641
15642 device_param->outerloop_pos = 0;
15643 device_param->outerloop_left = 0;
15644 device_param->innerloop_pos = 0;
15645 device_param->innerloop_left = 0;
15646
15647 // some more resets:
15648
15649 memset (device_param->pw_caches, 0, 64 * sizeof (pw_cache_t));
15650
15651 memset (device_param->pws_buf, 0, device_param->size_pws);
15652
15653 device_param->pw_cnt = 0;
15654 device_param->pws_cnt = 0;
15655
15656 device_param->words_off = 0;
15657 device_param->words_done = 0;
15658 }
15659
15660 data.kernel_blocks_div = 0;
15661
15662 // figure out some workload
15663
15664 if (attack_mode == ATTACK_MODE_STRAIGHT)
15665 {
15666 if (data.wordlist_mode == WL_MODE_FILE)
15667 {
15668 char *dictfile = NULL;
15669
15670 if (induction_dictionaries_cnt)
15671 {
15672 dictfile = induction_dictionaries[0];
15673 }
15674 else
15675 {
15676 dictfile = dictfiles[dictpos];
15677 }
15678
15679 data.dictfile = dictfile;
15680
15681 logfile_sub_string (dictfile);
15682
15683 for (uint i = 0; i < rp_files_cnt; i++)
15684 {
15685 logfile_sub_var_string ("rulefile", rp_files[i]);
15686 }
15687
15688 FILE *fd2 = fopen (dictfile, "rb");
15689
15690 if (fd2 == NULL)
15691 {
15692 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15693
15694 return (-1);
15695 }
15696
15697 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15698
15699 fclose (fd2);
15700
15701 if (data.words_cnt == 0)
15702 {
15703 if (data.devices_status == STATUS_CRACKED) break;
15704 if (data.devices_status == STATUS_ABORTED) break;
15705
15706 dictpos++;
15707
15708 continue;
15709 }
15710 }
15711 }
15712 else if (attack_mode == ATTACK_MODE_COMBI)
15713 {
15714 char *dictfile = data.dictfile;
15715 char *dictfile2 = data.dictfile2;
15716
15717 logfile_sub_string (dictfile);
15718 logfile_sub_string (dictfile2);
15719
15720 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
15721 {
15722 FILE *fd2 = fopen (dictfile, "rb");
15723
15724 if (fd2 == NULL)
15725 {
15726 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15727
15728 return (-1);
15729 }
15730
15731 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15732
15733 fclose (fd2);
15734 }
15735 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
15736 {
15737 FILE *fd2 = fopen (dictfile2, "rb");
15738
15739 if (fd2 == NULL)
15740 {
15741 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15742
15743 return (-1);
15744 }
15745
15746 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
15747
15748 fclose (fd2);
15749 }
15750
15751 if (data.words_cnt == 0)
15752 {
15753 if (data.devices_status == STATUS_CRACKED) break;
15754 if (data.devices_status == STATUS_ABORTED) break;
15755
15756 dictpos++;
15757
15758 continue;
15759 }
15760 }
15761 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15762 {
15763 char *dictfile = NULL;
15764
15765 if (induction_dictionaries_cnt)
15766 {
15767 dictfile = induction_dictionaries[0];
15768 }
15769 else
15770 {
15771 dictfile = dictfiles[dictpos];
15772 }
15773
15774 data.dictfile = dictfile;
15775
15776 char *mask = data.mask;
15777
15778 logfile_sub_string (dictfile);
15779 logfile_sub_string (mask);
15780
15781 FILE *fd2 = fopen (dictfile, "rb");
15782
15783 if (fd2 == NULL)
15784 {
15785 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15786
15787 return (-1);
15788 }
15789
15790 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15791
15792 fclose (fd2);
15793
15794 if (data.words_cnt == 0)
15795 {
15796 if (data.devices_status == STATUS_CRACKED) break;
15797 if (data.devices_status == STATUS_ABORTED) break;
15798
15799 dictpos++;
15800
15801 continue;
15802 }
15803 }
15804 else if (attack_mode == ATTACK_MODE_BF)
15805 {
15806 local_free (css_buf);
15807 local_free (data.root_css_buf);
15808 local_free (data.markov_css_buf);
15809
15810 char *mask = dictfiles[dictpos];
15811
15812 logfile_sub_string (mask);
15813
15814 // base
15815
15816 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15817
15818 if (opts_type & OPTS_TYPE_PT_UNICODE)
15819 {
15820 uint css_cnt_unicode = css_cnt * 2;
15821
15822 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
15823
15824 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
15825 {
15826 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
15827
15828 css_buf_unicode[j + 1].cs_buf[0] = 0;
15829 css_buf_unicode[j + 1].cs_len = 1;
15830 }
15831
15832 free (css_buf);
15833
15834 css_buf = css_buf_unicode;
15835 css_cnt = css_cnt_unicode;
15836 }
15837
15838 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
15839
15840 uint mask_min = pw_min;
15841 uint mask_max = pw_max;
15842
15843 if (opts_type & OPTS_TYPE_PT_UNICODE)
15844 {
15845 mask_min *= 2;
15846 mask_max *= 2;
15847 }
15848
15849 if ((css_cnt < mask_min) || (css_cnt > mask_max))
15850 {
15851 if (css_cnt < mask_min)
15852 {
15853 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
15854 }
15855
15856 if (css_cnt > mask_max)
15857 {
15858 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
15859 }
15860
15861 // skip to next mask
15862
15863 dictpos++;
15864
15865 rd->dictpos = dictpos;
15866
15867 logfile_sub_msg ("STOP");
15868
15869 continue;
15870 }
15871
15872 uint save_css_cnt = css_cnt;
15873
15874 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15875 {
15876 if (opti_type & OPTI_TYPE_APPENDED_SALT)
15877 {
15878 uint salt_len = (uint) data.salts_buf[0].salt_len;
15879 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
15880
15881 uint css_cnt_salt = css_cnt + salt_len;
15882
15883 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
15884
15885 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
15886
15887 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
15888 {
15889 css_buf_salt[j].cs_buf[0] = salt_buf[i];
15890 css_buf_salt[j].cs_len = 1;
15891 }
15892
15893 free (css_buf);
15894
15895 css_buf = css_buf_salt;
15896 css_cnt = css_cnt_salt;
15897 }
15898 }
15899
15900 data.mask = mask;
15901 data.css_cnt = css_cnt;
15902 data.css_buf = css_buf;
15903
15904 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
15905
15906 uint uniq_tbls[SP_PW_MAX][CHARSIZ];
15907
15908 memset (uniq_tbls, 0, sizeof (uniq_tbls));
15909
15910 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15911
15912 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15913 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15914
15915 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15916
15917 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15918
15919 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15920 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15921
15922 data.root_css_buf = root_css_buf;
15923 data.markov_css_buf = markov_css_buf;
15924
15925 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15926
15927 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15928
15929 local_free (root_table_buf);
15930 local_free (markov_table_buf);
15931
15932 // copy + args
15933
15934 uint css_cnt_l = css_cnt;
15935 uint css_cnt_r;
15936
15937 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15938 {
15939 if (save_css_cnt < 6)
15940 {
15941 css_cnt_r = 1;
15942 }
15943 else if (save_css_cnt == 6)
15944 {
15945 css_cnt_r = 2;
15946 }
15947 else
15948 {
15949 if (opts_type & OPTS_TYPE_PT_UNICODE)
15950 {
15951 if (save_css_cnt == 8 || save_css_cnt == 10)
15952 {
15953 css_cnt_r = 2;
15954 }
15955 else
15956 {
15957 css_cnt_r = 4;
15958 }
15959 }
15960 else
15961 {
15962 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
15963 {
15964 css_cnt_r = 3;
15965 }
15966 else
15967 {
15968 css_cnt_r = 4;
15969 }
15970 }
15971 }
15972 }
15973 else
15974 {
15975 css_cnt_r = 1;
15976
15977 /* unfinished code?
15978 int sum = css_buf[css_cnt_r - 1].cs_len;
15979
15980 for (uint i = 1; i < 4 && i < css_cnt; i++)
15981 {
15982 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
15983
15984 css_cnt_r++;
15985
15986 sum *= css_buf[css_cnt_r - 1].cs_len;
15987 }
15988 */
15989 }
15990
15991 css_cnt_l -= css_cnt_r;
15992
15993 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
15994
15995 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15996 {
15997 hc_device_param_t *device_param = &data.devices_param[device_id];
15998
15999 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16000 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16001 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16002
16003 device_param->kernel_params_mp_l_buf64[3] = 0;
16004 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16005 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16006 device_param->kernel_params_mp_l_buf32[6] = 0;
16007 device_param->kernel_params_mp_l_buf32[7] = 0;
16008 device_param->kernel_params_mp_l_buf32[8] = 0;
16009
16010 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16011 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16012 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16013 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16014
16015 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16016 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16017 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16018
16019 device_param->kernel_params_mp_r_buf64[3] = 0;
16020 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16021 device_param->kernel_params_mp_r_buf32[5] = 0;
16022 device_param->kernel_params_mp_r_buf32[6] = 0;
16023 device_param->kernel_params_mp_r_buf32[7] = 0;
16024
16025 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]);
16026 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]);
16027 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]);
16028
16029 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]);
16030 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]);
16031 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]);
16032
16033 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);
16034 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);
16035 }
16036 }
16037
16038 uint64_t words_base = data.words_cnt;
16039
16040 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16041 {
16042 if (data.kernel_rules_cnt)
16043 {
16044 words_base /= data.kernel_rules_cnt;
16045 }
16046 }
16047 else if (data.attack_kern == ATTACK_KERN_COMBI)
16048 {
16049 if (data.combs_cnt)
16050 {
16051 words_base /= data.combs_cnt;
16052 }
16053 }
16054 else if (data.attack_kern == ATTACK_KERN_BF)
16055 {
16056 if (data.bfs_cnt)
16057 {
16058 words_base /= data.bfs_cnt;
16059 }
16060 }
16061
16062 data.words_base = words_base;
16063
16064 if (keyspace == 1)
16065 {
16066 log_info ("%llu", (unsigned long long int) words_base);
16067
16068 return (0);
16069 }
16070
16071 if (data.words_cur > data.words_base)
16072 {
16073 log_error ("ERROR: restore value greater keyspace");
16074
16075 return (-1);
16076 }
16077
16078 if (data.words_cur)
16079 {
16080 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16081 {
16082 for (uint i = 0; i < data.salts_cnt; i++)
16083 {
16084 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16085 }
16086 }
16087 else if (data.attack_kern == ATTACK_KERN_COMBI)
16088 {
16089 for (uint i = 0; i < data.salts_cnt; i++)
16090 {
16091 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16092 }
16093 }
16094 else if (data.attack_kern == ATTACK_KERN_BF)
16095 {
16096 for (uint i = 0; i < data.salts_cnt; i++)
16097 {
16098 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16099 }
16100 }
16101 }
16102
16103 /*
16104 * Inform user about possible slow speeds
16105 */
16106
16107 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16108 {
16109 if (data.words_base < kernel_blocks_all)
16110 {
16111 if (quiet == 0)
16112 {
16113 log_info ("");
16114 log_info ("ATTENTION!");
16115 log_info (" The wordlist or mask you are using is too small.");
16116 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16117 log_info (" The cracking speed will drop.");
16118 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16119 log_info ("");
16120 }
16121 }
16122 }
16123
16124 /*
16125 * Update loopback file
16126 */
16127
16128 if (loopback == 1)
16129 {
16130 time_t now;
16131
16132 time (&now);
16133
16134 uint random_num = get_random_num (0, 9999);
16135
16136 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16137
16138 data.loopback_file = loopback_file;
16139 }
16140
16141 /*
16142 * Update dictionary statistic
16143 */
16144
16145 if (keyspace == 0)
16146 {
16147 dictstat_fp = fopen (dictstat, "wb");
16148
16149 if (dictstat_fp)
16150 {
16151 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16152
16153 fclose (dictstat_fp);
16154 }
16155 }
16156
16157 data.devices_status = STATUS_RUNNING;
16158
16159 if (initial_restore_done == 0)
16160 {
16161 if (data.restore_disable == 0) cycle_restore ();
16162
16163 initial_restore_done = 1;
16164 }
16165
16166 hc_timer_set (&data.timer_running);
16167
16168 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16169 {
16170 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16171 {
16172 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16173 if (quiet == 0) fflush (stdout);
16174 }
16175 }
16176 else if (wordlist_mode == WL_MODE_STDIN)
16177 {
16178 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16179 if (data.quiet == 0) log_info ("");
16180 }
16181
16182 time_t runtime_start;
16183
16184 time (&runtime_start);
16185
16186 data.runtime_start = runtime_start;
16187
16188 /**
16189 * create cracker threads
16190 */
16191
16192 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (devices_cnt, sizeof (hc_thread_t));
16193
16194 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16195 {
16196 hc_device_param_t *device_param = &devices_param[device_id];
16197
16198 device_param->device_id = device_id;
16199
16200 if (wordlist_mode == WL_MODE_STDIN)
16201 {
16202 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16203 }
16204 else
16205 {
16206 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16207 }
16208 }
16209
16210 // wait for crack threads to exit
16211
16212 hc_thread_wait (devices_cnt, c_threads);
16213
16214 local_free (c_threads);
16215
16216 data.restore = 0;
16217
16218 // finalize task
16219
16220 logfile_sub_var_uint ("status-after-work", data.devices_status);
16221
16222 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16223
16224 if (data.devices_status == STATUS_CRACKED) break;
16225 if (data.devices_status == STATUS_ABORTED) break;
16226
16227 if (data.devices_status == STATUS_BYPASS)
16228 {
16229 data.devices_status = STATUS_RUNNING;
16230 }
16231
16232 if (induction_dictionaries_cnt)
16233 {
16234 unlink (induction_dictionaries[0]);
16235 }
16236
16237 free (induction_dictionaries);
16238
16239 if (attack_mode != ATTACK_MODE_BF)
16240 {
16241 induction_dictionaries = scan_directory (induction_directory);
16242
16243 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16244 }
16245
16246 if (benchmark == 0)
16247 {
16248 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16249 {
16250 if (quiet == 0) clear_prompt ();
16251
16252 if (quiet == 0) log_info ("");
16253
16254 if (status == 1)
16255 {
16256 status_display ();
16257 }
16258 else
16259 {
16260 if (quiet == 0) status_display ();
16261 }
16262
16263 if (quiet == 0) log_info ("");
16264 }
16265 }
16266
16267 if (attack_mode == ATTACK_MODE_BF)
16268 {
16269 dictpos++;
16270
16271 rd->dictpos = dictpos;
16272 }
16273 else
16274 {
16275 if (induction_dictionaries_cnt)
16276 {
16277 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16278 }
16279 else
16280 {
16281 dictpos++;
16282
16283 rd->dictpos = dictpos;
16284 }
16285 }
16286
16287 time_t runtime_stop;
16288
16289 time (&runtime_stop);
16290
16291 data.runtime_stop = runtime_stop;
16292
16293 logfile_sub_uint (runtime_start);
16294 logfile_sub_uint (runtime_stop);
16295
16296 logfile_sub_msg ("STOP");
16297
16298 global_free (subid);
16299 }
16300
16301 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16302
16303 if (data.devices_status == STATUS_CRACKED) break;
16304 if (data.devices_status == STATUS_ABORTED) break;
16305 if (data.devices_status == STATUS_QUIT) break;
16306
16307 if (data.devices_status == STATUS_BYPASS)
16308 {
16309 data.devices_status = STATUS_RUNNING;
16310 }
16311 }
16312
16313 // 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
16314
16315 if (attack_mode == ATTACK_MODE_STRAIGHT)
16316 {
16317 if (data.wordlist_mode == WL_MODE_FILE)
16318 {
16319 if (data.dictfile == NULL)
16320 {
16321 if (dictfiles != NULL)
16322 {
16323 data.dictfile = dictfiles[0];
16324
16325 hc_timer_set (&data.timer_running);
16326 }
16327 }
16328 }
16329 }
16330 // NOTE: combi is okay because it is already set beforehand
16331 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16332 {
16333 if (data.dictfile == NULL)
16334 {
16335 if (dictfiles != NULL)
16336 {
16337 hc_timer_set (&data.timer_running);
16338
16339 data.dictfile = dictfiles[0];
16340 }
16341 }
16342 }
16343 else if (attack_mode == ATTACK_MODE_BF)
16344 {
16345 if (data.mask == NULL)
16346 {
16347 hc_timer_set (&data.timer_running);
16348
16349 data.mask = masks[0];
16350 }
16351 }
16352
16353 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16354 {
16355 data.devices_status = STATUS_EXHAUSTED;
16356 }
16357
16358 // if cracked / aborted remove last induction dictionary
16359
16360 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16361 {
16362 struct stat induct_stat;
16363
16364 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16365 {
16366 unlink (induction_dictionaries[file_pos]);
16367 }
16368 }
16369
16370 // wait for non-interactive threads
16371
16372 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16373 {
16374 hc_thread_wait (1, &ni_threads[thread_idx]);
16375 }
16376
16377 local_free (ni_threads);
16378
16379 // wait for interactive threads
16380
16381 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16382 {
16383 hc_thread_wait (1, &i_thread);
16384 }
16385
16386 // we dont need restore file anymore
16387 if (data.restore_disable == 0)
16388 {
16389 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16390 {
16391 unlink (eff_restore_file);
16392 unlink (new_restore_file);
16393 }
16394 else
16395 {
16396 cycle_restore ();
16397 }
16398 }
16399
16400 // finally save left hashes
16401
16402 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16403 {
16404 save_hash ();
16405 }
16406
16407 /**
16408 * Clean up
16409 */
16410
16411 if (benchmark == 1)
16412 {
16413 status_benchmark ();
16414
16415 log_info ("");
16416 }
16417 else
16418 {
16419 if (quiet == 0) clear_prompt ();
16420
16421 if (quiet == 0) log_info ("");
16422
16423 if (status == 1)
16424 {
16425 status_display ();
16426 }
16427 else
16428 {
16429 if (quiet == 0) status_display ();
16430 }
16431
16432 if (quiet == 0) log_info ("");
16433 }
16434
16435 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16436 {
16437 hc_device_param_t *device_param = &data.devices_param[device_id];
16438
16439 local_free (device_param->result);
16440
16441 local_free (device_param->pw_caches);
16442
16443 local_free (device_param->combs_buf);
16444
16445 local_free (device_param->hooks_buf);
16446
16447 local_free (device_param->device_name);
16448
16449 local_free (device_param->device_name_chksum);
16450
16451 local_free (device_param->device_version);
16452
16453 local_free (device_param->driver_version);
16454
16455 if (device_param->pws_buf) myfree (device_param->pws_buf);
16456 if (device_param->d_pws_buf) hc_clReleaseMemObject (device_param->d_pws_buf);
16457 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (device_param->d_pws_amp_buf);
16458 if (device_param->d_rules) hc_clReleaseMemObject (device_param->d_rules);
16459 if (device_param->d_rules_c) hc_clReleaseMemObject (device_param->d_rules_c);
16460 if (device_param->d_combs) hc_clReleaseMemObject (device_param->d_combs);
16461 if (device_param->d_combs_c) hc_clReleaseMemObject (device_param->d_combs_c);
16462 if (device_param->d_bfs) hc_clReleaseMemObject (device_param->d_bfs);
16463 if (device_param->d_bfs_c) hc_clReleaseMemObject (device_param->d_bfs_c);
16464 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (device_param->d_bitmap_s1_a);
16465 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (device_param->d_bitmap_s1_b);
16466 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (device_param->d_bitmap_s1_c);
16467 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (device_param->d_bitmap_s1_d);
16468 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (device_param->d_bitmap_s2_a);
16469 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (device_param->d_bitmap_s2_b);
16470 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (device_param->d_bitmap_s2_c);
16471 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (device_param->d_bitmap_s2_d);
16472 if (device_param->d_plain_bufs) hc_clReleaseMemObject (device_param->d_plain_bufs);
16473 if (device_param->d_digests_buf) hc_clReleaseMemObject (device_param->d_digests_buf);
16474 if (device_param->d_digests_shown) hc_clReleaseMemObject (device_param->d_digests_shown);
16475 if (device_param->d_salt_bufs) hc_clReleaseMemObject (device_param->d_salt_bufs);
16476 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (device_param->d_esalt_bufs);
16477 if (device_param->d_tmps) hc_clReleaseMemObject (device_param->d_tmps);
16478 if (device_param->d_hooks) hc_clReleaseMemObject (device_param->d_hooks);
16479 if (device_param->d_result) hc_clReleaseMemObject (device_param->d_result);
16480 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (device_param->d_scryptV_buf);
16481 if (device_param->d_root_css_buf) hc_clReleaseMemObject (device_param->d_root_css_buf);
16482 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (device_param->d_markov_css_buf);
16483 if (device_param->d_tm_c) hc_clReleaseMemObject (device_param->d_tm_c);
16484
16485 if (device_param->kernel1) hc_clReleaseKernel (device_param->kernel1);
16486 if (device_param->kernel12) hc_clReleaseKernel (device_param->kernel12);
16487 if (device_param->kernel2) hc_clReleaseKernel (device_param->kernel2);
16488 if (device_param->kernel23) hc_clReleaseKernel (device_param->kernel23);
16489 if (device_param->kernel3) hc_clReleaseKernel (device_param->kernel3);
16490 if (device_param->kernel_mp) hc_clReleaseKernel (device_param->kernel_mp);
16491 if (device_param->kernel_mp_l) hc_clReleaseKernel (device_param->kernel_mp_l);
16492 if (device_param->kernel_mp_r) hc_clReleaseKernel (device_param->kernel_mp_r);
16493 if (device_param->kernel_tb) hc_clReleaseKernel (device_param->kernel_tb);
16494 if (device_param->kernel_tm) hc_clReleaseKernel (device_param->kernel_tm);
16495 if (device_param->kernel_amp) hc_clReleaseKernel (device_param->kernel_amp);
16496 if (device_param->kernel_weak) hc_clReleaseKernel (device_param->kernel_weak);
16497
16498 if (device_param->program) hc_clReleaseProgram (device_param->program);
16499 if (device_param->program_mp) hc_clReleaseProgram (device_param->program_mp);
16500 if (device_param->program_amp) hc_clReleaseProgram (device_param->program_amp);
16501 if (device_param->program_weak) hc_clReleaseProgram (device_param->program_weak);
16502
16503 if (device_param->command_queue) hc_clReleaseCommandQueue (device_param->command_queue);
16504 if (device_param->context) hc_clReleaseContext (device_param->context);
16505 }
16506
16507 // reset default fan speed
16508
16509 if (gpu_temp_disable == 0)
16510 {
16511 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16512 {
16513 hc_thread_mutex_lock (mux_adl);
16514
16515 for (uint i = 0; i < data.devices_cnt; i++)
16516 {
16517 if (data.hm_device[i].fan_supported == 1)
16518 {
16519 int fanspeed = temp_retain_fanspeed_value[i];
16520
16521 if (fanspeed == -1) continue;
16522
16523 int rc = hm_set_fanspeed_with_device_id_amd (i, fanspeed);
16524
16525 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", i);
16526 }
16527 }
16528
16529 hc_thread_mutex_unlock (mux_adl);
16530 }
16531 }
16532
16533 // reset power tuning
16534
16535 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16536 {
16537 hc_thread_mutex_lock (mux_adl);
16538
16539 for (uint i = 0; i < data.devices_cnt; i++)
16540 {
16541 if (data.hm_device[i].od_version == 6)
16542 {
16543 // check powertune capabilities first, if not available then skip device
16544
16545 int powertune_supported = 0;
16546
16547 if ((hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll_amd, data.hm_device[i].adapter_index.amd, &powertune_supported)) != ADL_OK)
16548 {
16549 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16550
16551 return (-1);
16552 }
16553
16554 if (powertune_supported != 0)
16555 {
16556 // powercontrol settings
16557
16558 if ((hc_ADL_Overdrive_PowerControl_Set (data.hm_dll_amd, data.hm_device[i].adapter_index.amd, od_power_control_status[i])) != ADL_OK)
16559 {
16560 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16561
16562 return (-1);
16563 }
16564
16565 // clocks
16566
16567 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16568
16569 performance_state->iNumberOfPerformanceLevels = 2;
16570
16571 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[i].state.aLevels[0].iEngineClock;
16572 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[i].state.aLevels[1].iEngineClock;
16573 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[i].state.aLevels[0].iMemoryClock;
16574 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[i].state.aLevels[1].iMemoryClock;
16575
16576 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)
16577 {
16578 log_info ("ERROR: Failed to restore ADL performance state");
16579
16580 return (-1);
16581 }
16582
16583 local_free (performance_state);
16584 }
16585 }
16586 }
16587
16588 hc_thread_mutex_unlock (mux_adl);
16589 }
16590
16591 if (gpu_temp_disable == 0)
16592 {
16593 #ifdef LINUX
16594 if (data.hm_dll_nv)
16595 {
16596 hc_NVML_nvmlShutdown (data.hm_dll_nv);
16597
16598 hm_close (data.hm_dll_nv);
16599 }
16600 #endif
16601
16602 #ifdef WIN
16603 NvAPI_Unload ();
16604 #endif
16605
16606 if (data.hm_dll_amd)
16607 {
16608 hc_ADL_Main_Control_Destroy (data.hm_dll_amd);
16609
16610 hm_close (data.hm_dll_amd);
16611 }
16612 }
16613
16614 // free memory
16615
16616 local_free (masks);
16617
16618 local_free (dictstat_base);
16619
16620 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16621 {
16622 pot_t *pot_ptr = &pot[pot_pos];
16623
16624 hash_t *hash = &pot_ptr->hash;
16625
16626 local_free (hash->digest);
16627
16628 if (isSalted)
16629 {
16630 local_free (hash->salt);
16631 }
16632 }
16633
16634 local_free (pot);
16635
16636 local_free (all_kernel_rules_cnt);
16637 local_free (all_kernel_rules_buf);
16638
16639 local_free (wl_data->buf);
16640 local_free (wl_data);
16641
16642 local_free (bitmap_s1_a);
16643 local_free (bitmap_s1_b);
16644 local_free (bitmap_s1_c);
16645 local_free (bitmap_s1_d);
16646 local_free (bitmap_s2_a);
16647 local_free (bitmap_s2_b);
16648 local_free (bitmap_s2_c);
16649 local_free (bitmap_s2_d);
16650
16651 local_free (temp_retain_fanspeed_value);
16652 local_free (od_clock_mem_status);
16653 local_free (od_power_control_status);
16654
16655 global_free (devices_param);
16656
16657 global_free (kernel_rules_buf);
16658
16659 global_free (root_css_buf);
16660 global_free (markov_css_buf);
16661
16662 global_free (digests_buf);
16663 global_free (digests_shown);
16664 global_free (digests_shown_tmp);
16665
16666 global_free (salts_buf);
16667 global_free (salts_shown);
16668
16669 global_free (esalts_buf);
16670
16671 global_free (words_progress_done);
16672 global_free (words_progress_rejected);
16673 global_free (words_progress_restored);
16674
16675 if (pot_fp) fclose (pot_fp);
16676
16677 if (data.devices_status == STATUS_QUIT) break;
16678 }
16679
16680 // destroy others mutex
16681
16682 hc_thread_mutex_delete (mux_dispatcher);
16683 hc_thread_mutex_delete (mux_counter);
16684 hc_thread_mutex_delete (mux_display);
16685 hc_thread_mutex_delete (mux_adl);
16686
16687 // free memory
16688
16689 local_free (eff_restore_file);
16690 local_free (new_restore_file);
16691
16692 local_free (rd);
16693
16694 // loopback
16695
16696 local_free (loopback_file);
16697
16698 if (loopback == 1) unlink (loopback_file);
16699
16700 // induction directory
16701
16702 if (induction_dir == NULL)
16703 {
16704 if (attack_mode != ATTACK_MODE_BF)
16705 {
16706 if (rmdir (induction_directory) == -1)
16707 {
16708 if (errno == ENOENT)
16709 {
16710 // good, we can ignore
16711 }
16712 else if (errno == ENOTEMPTY)
16713 {
16714 // good, we can ignore
16715 }
16716 else
16717 {
16718 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
16719
16720 return (-1);
16721 }
16722 }
16723
16724 local_free (induction_directory);
16725 }
16726 }
16727
16728 // outfile-check directory
16729
16730 if (outfile_check_dir == NULL)
16731 {
16732 if (rmdir (outfile_check_directory) == -1)
16733 {
16734 if (errno == ENOENT)
16735 {
16736 // good, we can ignore
16737 }
16738 else if (errno == ENOTEMPTY)
16739 {
16740 // good, we can ignore
16741 }
16742 else
16743 {
16744 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
16745
16746 return (-1);
16747 }
16748 }
16749
16750 local_free (outfile_check_directory);
16751 }
16752
16753 time_t proc_stop;
16754
16755 time (&proc_stop);
16756
16757 logfile_top_uint (proc_start);
16758 logfile_top_uint (proc_stop);
16759
16760 logfile_top_msg ("STOP");
16761
16762 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
16763 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
16764
16765 if (data.devices_status == STATUS_ABORTED) return 2;
16766 if (data.devices_status == STATUS_QUIT) return 2;
16767 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
16768 if (data.devices_status == STATUS_EXHAUSTED) return 1;
16769 if (data.devices_status == STATUS_CRACKED) return 0;
16770
16771 return -1;
16772 }
Hashcat additions to support pwdhash