projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Added new hash mode -m 12900 = Android FDE (Samsung DEK)
[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 129
132
133 #define global_free(attr) \
134 { \
135 myfree ((void *) data.attr); \
136 \
137 data.attr = NULL; \
138 }
139
140 #define local_free(attr) \
141 { \
142 myfree ((void *) attr); \
143 \
144 attr = NULL; \
145 }
146
147 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
148 {
149 900,
150 0,
151 5100,
152 100,
153 1400,
154 10800,
155 1700,
156 5000,
157 10100,
158 6000,
159 6100,
160 6900,
161 11700,
162 11800,
163 400,
164 8900,
165 11900,
166 12000,
167 10900,
168 12100,
169 23,
170 2500,
171 5300,
172 5400,
173 5500,
174 5600,
175 7300,
176 7500,
177 8300,
178 11100,
179 11200,
180 11400,
181 121,
182 2611,
183 2711,
184 2811,
185 8400,
186 11,
187 2612,
188 7900,
189 21,
190 11000,
191 124,
192 10000,
193 3711,
194 7600,
195 12,
196 131,
197 132,
198 1731,
199 200,
200 300,
201 3100,
202 112,
203 12300,
204 8000,
205 141,
206 1441,
207 1600,
208 12600,
209 1421,
210 101,
211 111,
212 1711,
213 3000,
214 1000,
215 1100,
216 2100,
217 12800,
218 1500,
219 12400,
220 500,
221 3200,
222 7400,
223 1800,
224 122,
225 1722,
226 7100,
227 6300,
228 6700,
229 6400,
230 6500,
231 2400,
232 2410,
233 5700,
234 9200,
235 9300,
236 22,
237 501,
238 5800,
239 8100,
240 8500,
241 7200,
242 9900,
243 7700,
244 7800,
245 10300,
246 8600,
247 8700,
248 9100,
249 133,
250 11600,
251 12500,
252 6211,
253 6221,
254 6231,
255 6241,
256 8800,
257 12900,
258 12200,
259 9700,
260 9710,
261 9800,
262 9810,
263 9400,
264 9500,
265 9600,
266 10400,
267 10410,
268 10500,
269 10600,
270 10700,
271 9000,
272 5200,
273 6800,
274 6600,
275 8200,
276 11300,
277 12700
278 };
279
280 /**
281 * types
282 */
283
284 static void (*get_next_word_func) (char *, uint32_t, uint32_t *, uint32_t *);
285
286 /**
287 * globals
288 */
289
290 static unsigned int full01 = 0x01010101;
291 static unsigned int full80 = 0x80808080;
292
293 int SUPPRESS_OUTPUT = 0;
294
295 hc_thread_mutex_t mux_adl;
296 hc_thread_mutex_t mux_counter;
297 hc_thread_mutex_t mux_dispatcher;
298 hc_thread_mutex_t mux_display;
299
300 hc_global_data_t data;
301
302 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
303
304 const char *USAGE_MINI[] =
305 {
306 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
307 "",
308 "Try --help for more help.",
309 NULL
310 };
311
312 const char *USAGE_BIG[] =
313 {
314 "%s, advanced password recovery",
315 "",
316 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
317 "",
318 "=======",
319 "Options",
320 "=======",
321 "",
322 "* General:",
323 "",
324 " -m, --hash-type=NUM Hash-type, see references below",
325 " -a, --attack-mode=NUM Attack-mode, see references below",
326 " -V, --version Print version",
327 " -h, --help Print help",
328 " --quiet Suppress output",
329 "",
330 "* Benchmark:",
331 "",
332 " -b, --benchmark Run benchmark",
333 " --benchmark-mode=NUM Benchmark-mode, see references below",
334 "",
335 "* Misc:",
336 "",
337 " --hex-charset Assume charset is given in hex",
338 " --hex-salt Assume salt is given in hex",
339 " --hex-wordlist Assume words in wordlist is given in hex",
340 " --force Ignore warnings",
341 " --status Enable automatic update of the status-screen",
342 " --status-timer=NUM Seconds between status-screen update",
343 " --status-automat Display the status view in a machine readable format",
344 " --loopback Add new plains to induct directory",
345 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
346 "",
347 "* Markov:",
348 "",
349 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
350 " --markov-disable Disables markov-chains, emulates classic brute-force",
351 " --markov-classic Enables classic markov-chains, no per-position enhancement",
352 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
353 "",
354 "* Session:",
355 "",
356 " --runtime=NUM Abort session after NUM seconds of runtime",
357 " --session=STR Define specific session name",
358 " --restore Restore session from --session",
359 " --restore-disable Do not write restore file",
360 "",
361 "* Files:",
362 "",
363 " -o, --outfile=FILE Define outfile for recovered hash",
364 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
365 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
366 " --outfile-check-timer=NUM Seconds between outfile checks",
367 " -p, --separator=CHAR Separator char for hashlists and outfile",
368 " --show Show cracked passwords only",
369 " --left Show un-cracked passwords only",
370 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
371 " --remove Enable remove of hash once it is cracked",
372 " --remove-timer=NUM Update input hash file each NUM seconds",
373 " --potfile-disable Do not write potfile",
374 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
375 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
376 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
377 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
378 " --logfile-disable Disable the logfile",
379 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
380 "",
381 "* Resources:",
382 "",
383 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
384 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
385 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
386 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
387 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
388 " --opencl-platform=NUM OpenCL platform to use, in case multiple platforms are present",
389 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
390 " -n, --kernel-accel=NUM Workload tuning: 1, 8, 40, 80, 160",
391 " -u, --kernel-loops=NUM Workload fine-tuning: 8 - 1024",
392 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
393 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
394 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
395 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
396 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
397 "",
398 "* Distributed:",
399 "",
400 " -s, --skip=NUM Skip number of words",
401 " -l, --limit=NUM Limit number of words",
402 " --keyspace Show keyspace base:mod values and quit",
403 "",
404 "* Rules:",
405 "",
406 " -j, --rule-left=RULE Single rule applied to each word from left dict",
407 " -k, --rule-right=RULE Single rule applied to each word from right dict",
408 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
409 " -g, --generate-rules=NUM Generate NUM random rules",
410 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
411 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
412 " --generate-rules-seed=NUM Force RNG seed to NUM",
413 "",
414 "* Custom charsets:",
415 "",
416 " -1, --custom-charset1=CS User-defined charsets",
417 " -2, --custom-charset2=CS Example:",
418 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
419 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
420 "",
421 "* Increment:",
422 "",
423 " -i, --increment Enable increment mode",
424 " --increment-min=NUM Start incrementing at NUM",
425 " --increment-max=NUM Stop incrementing at NUM",
426 "",
427 "==========",
428 "References",
429 "==========",
430 "",
431 "* Workload Profile:",
432 "",
433 " 1 = Reduced performance profile (low latency desktop)",
434 " 2 = Default performance profile",
435 " 3 = Tuned performance profile (high latency desktop)",
436 "",
437 "* Benchmark Settings:",
438 "",
439 " 0 = Manual Tuning",
440 " 1 = Performance Tuning, default",
441 "",
442 "* Outfile Formats:",
443 "",
444 " 1 = hash[:salt]",
445 " 2 = plain",
446 " 3 = hash[:salt]:plain",
447 " 4 = hex_plain",
448 " 5 = hash[:salt]:hex_plain",
449 " 6 = plain:hex_plain",
450 " 7 = hash[:salt]:plain:hex_plain",
451 " 8 = crackpos",
452 " 9 = hash[:salt]:crackpos",
453 " 10 = plain:crackpos",
454 " 11 = hash[:salt]:plain:crackpos",
455 " 12 = hex_plain:crackpos",
456 " 13 = hash[:salt]:hex_plain:crackpos",
457 " 14 = plain:hex_plain:crackpos",
458 " 15 = hash[:salt]:plain:hex_plain:crackpos",
459 "",
460 "* Debug mode output formats (for hybrid mode only, by using rules):",
461 "",
462 " 1 = save finding rule",
463 " 2 = save original word",
464 " 3 = save original word and finding rule",
465 " 4 = save original word, finding rule and modified plain",
466 "",
467 "* Built-in charsets:",
468 "",
469 " ?l = abcdefghijklmnopqrstuvwxyz",
470 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
471 " ?d = 0123456789",
472 " ?s = !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~",
473 " ?a = ?l?u?d?s",
474 " ?b = 0x00 - 0xff",
475 "",
476 "* Attack modes:",
477 "",
478 " 0 = Straight",
479 " 1 = Combination",
480 " 3 = Brute-force",
481 " 6 = Hybrid dict + mask",
482 " 7 = Hybrid mask + dict",
483 "",
484 "* Hash types:",
485 "",
486 "[[ Roll-your-own: Raw Hashes ]]",
487 "",
488 " 900 = MD4",
489 " 0 = MD5",
490 " 5100 = Half MD5",
491 " 100 = SHA1",
492 " 10800 = SHA-384",
493 " 1400 = SHA-256",
494 " 1700 = SHA-512",
495 " 5000 = SHA-3(Keccak)",
496 " 10100 = SipHash",
497 " 6000 = RipeMD160",
498 " 6100 = Whirlpool",
499 " 6900 = GOST R 34.11-94",
500 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
501 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
502 "",
503 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
504 "",
505 " 10 = md5($pass.$salt)",
506 " 20 = md5($salt.$pass)",
507 " 30 = md5(unicode($pass).$salt)",
508 " 40 = md5($salt.unicode($pass))",
509 " 3800 = md5($salt.$pass.$salt)",
510 " 3710 = md5($salt.md5($pass))",
511 " 2600 = md5(md5($pass)",
512 " 4300 = md5(strtoupper(md5($pass)))",
513 " 4400 = md5(sha1($pass))",
514 " 110 = sha1($pass.$salt)",
515 " 120 = sha1($salt.$pass)",
516 " 130 = sha1(unicode($pass).$salt)",
517 " 140 = sha1($salt.unicode($pass))",
518 " 4500 = sha1(sha1($pass)",
519 " 4700 = sha1(md5($pass))",
520 " 4900 = sha1($salt.$pass.$salt)",
521 " 1410 = sha256($pass.$salt)",
522 " 1420 = sha256($salt.$pass)",
523 " 1430 = sha256(unicode($pass).$salt)",
524 " 1440 = sha256($salt.unicode($pass))",
525 " 1710 = sha512($pass.$salt)",
526 " 1720 = sha512($salt.$pass)",
527 " 1730 = sha512(unicode($pass).$salt)",
528 " 1740 = sha512($salt.unicode($pass))",
529 "",
530 "[[ Roll-your-own: Authenticated Hashes ]]",
531 "",
532 " 50 = HMAC-MD5 (key = $pass)",
533 " 60 = HMAC-MD5 (key = $salt)",
534 " 150 = HMAC-SHA1 (key = $pass)",
535 " 160 = HMAC-SHA1 (key = $salt)",
536 " 1450 = HMAC-SHA256 (key = $pass)",
537 " 1460 = HMAC-SHA256 (key = $salt)",
538 " 1750 = HMAC-SHA512 (key = $pass)",
539 " 1760 = HMAC-SHA512 (key = $salt)",
540 "",
541 "[[ Generic KDF ]]",
542 "",
543 " 400 = phpass",
544 " 8900 = scrypt",
545 " 11900 = PBKDF2-HMAC-MD5",
546 " 12000 = PBKDF2-HMAC-SHA1",
547 " 10900 = PBKDF2-HMAC-SHA256",
548 " 12100 = PBKDF2-HMAC-SHA512",
549 "",
550 "[[ Network protocols, Challenge-Response ]]",
551 "",
552 " 23 = Skype",
553 " 2500 = WPA/WPA2",
554 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
555 " 5300 = IKE-PSK MD5",
556 " 5400 = IKE-PSK SHA1",
557 " 5500 = NetNTLMv1",
558 " 5500 = NetNTLMv1 + ESS",
559 " 5600 = NetNTLMv2",
560 " 7300 = IPMI2 RAKP HMAC-SHA1",
561 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
562 " 8300 = DNSSEC (NSEC3)",
563 " 10200 = Cram MD5",
564 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
565 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
566 " 11400 = SIP digest authentication (MD5)",
567 "",
568 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
569 "",
570 " 121 = SMF (Simple Machines Forum)",
571 " 400 = phpBB3",
572 " 2611 = vBulletin < v3.8.5",
573 " 2711 = vBulletin > v3.8.5",
574 " 2811 = MyBB",
575 " 2811 = IPB (Invison Power Board)",
576 " 8400 = WBB3 (Woltlab Burning Board)",
577 " 11 = Joomla < 2.5.18",
578 " 400 = Joomla > 2.5.18",
579 " 400 = Wordpress",
580 " 2612 = PHPS",
581 " 7900 = Drupal7",
582 " 21 = osCommerce",
583 " 21 = xt:Commerce",
584 " 11000 = PrestaShop",
585 " 124 = Django (SHA-1)",
586 " 10000 = Django (PBKDF2-SHA256)",
587 " 3711 = Mediawiki B type",
588 " 7600 = Redmine",
589 "",
590 "[[ Database Server ]]",
591 "",
592 " 12 = PostgreSQL",
593 " 131 = MSSQL(2000)",
594 " 132 = MSSQL(2005)",
595 " 1731 = MSSQL(2012)",
596 " 1731 = MSSQL(2014)",
597 " 200 = MySQL323",
598 " 300 = MySQL4.1/MySQL5",
599 " 3100 = Oracle H: Type (Oracle 7+)",
600 " 112 = Oracle S: Type (Oracle 11+)",
601 " 12300 = Oracle T: Type (Oracle 12+)",
602 " 8000 = Sybase ASE",
603 "",
604 "[[ HTTP, SMTP, LDAP Server ]]",
605 "",
606 " 141 = EPiServer 6.x < v4",
607 " 1441 = EPiServer 6.x > v4",
608 " 1600 = Apache $apr1$",
609 " 12600 = ColdFusion 10+",
610 " 1421 = hMailServer",
611 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
612 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
613 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
614 "",
615 "[[ Checksums ]]",
616 "",
617 " 11500 = CRC32",
618 "",
619 "[[ Operating-Systems ]]",
620 "",
621 " 3000 = LM",
622 " 1000 = NTLM",
623 " 1100 = Domain Cached Credentials (DCC), MS Cache",
624 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
625 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
626 " 1500 = descrypt, DES(Unix), Traditional DES",
627 " 12400 = BSDiCrypt, Extended DES",
628 " 500 = md5crypt $1$, MD5(Unix)",
629 " 3200 = bcrypt $2*$, Blowfish(Unix)",
630 " 7400 = sha256crypt $5$, SHA256(Unix)",
631 " 1800 = sha512crypt $6$, SHA512(Unix)",
632 " 122 = OSX v10.4",
633 " 122 = OSX v10.5",
634 " 122 = OSX v10.6",
635 " 1722 = OSX v10.7",
636 " 7100 = OSX v10.8",
637 " 7100 = OSX v10.9",
638 " 7100 = OSX v10.10",
639 " 6300 = AIX {smd5}",
640 " 6700 = AIX {ssha1}",
641 " 6400 = AIX {ssha256}",
642 " 6500 = AIX {ssha512}",
643 " 2400 = Cisco-PIX",
644 " 2410 = Cisco-ASA",
645 " 500 = Cisco-IOS $1$",
646 " 5700 = Cisco-IOS $4$",
647 " 9200 = Cisco-IOS $8$",
648 " 9300 = Cisco-IOS $9$",
649 " 22 = Juniper Netscreen/SSG (ScreenOS)",
650 " 501 = Juniper IVE",
651 " 5800 = Android PIN",
652 " 8100 = Citrix Netscaler",
653 " 8500 = RACF",
654 " 7200 = GRUB 2",
655 " 9900 = Radmin2",
656 "",
657 "[[ Enterprise Application Software (EAS) ]]",
658 "",
659 " 7700 = SAP CODVN B (BCODE)",
660 " 7800 = SAP CODVN F/G (PASSCODE)",
661 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
662 " 8600 = Lotus Notes/Domino 5",
663 " 8700 = Lotus Notes/Domino 6",
664 " 9100 = Lotus Notes/Domino 8",
665 " 133 = PeopleSoft",
666 "",
667 "[[ Archives ]]",
668 "",
669 " 11600 = 7-Zip",
670 " 12500 = RAR3-hp",
671 "",
672 "[[ Full-Disk encryptions (FDE) ]]",
673 "",
674 " 62XY = TrueCrypt 5.0+",
675 " X = 1 = PBKDF2-HMAC-RipeMD160",
676 " X = 2 = PBKDF2-HMAC-SHA512",
677 " X = 3 = PBKDF2-HMAC-Whirlpool",
678 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
679 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
680 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
681 " Y = 3 = XTS 1536 bit (Ciphers: All)",
682 " 8800 = Android FDE < v4.3",
683 " 12900 = Android FDE (Samsung DEK)",
684 " 12200 = eCryptfs",
685 "",
686 "[[ Documents ]]",
687 "",
688 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
689 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
690 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
691 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
692 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
693 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
694 " 9400 = MS Office 2007",
695 " 9500 = MS Office 2010",
696 " 9600 = MS Office 2013",
697 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
698 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
699 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
700 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
701 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
702 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
703 "",
704 "[[ Password Managers ]]",
705 "",
706 " 9000 = Password Safe v2",
707 " 5200 = Password Safe v3",
708 " 6800 = Lastpass",
709 " 6600 = 1Password, agilekeychain",
710 " 8200 = 1Password, cloudkeychain",
711 " 11300 = Bitcoin/Litecoin wallet.dat",
712 " 12700 = Blockchain, My Wallet",
713 "",
714 NULL
715 };
716
717 /**
718 * oclHashcat specific functions
719 */
720
721 void status_display_automat ()
722 {
723 FILE *out = stdout;
724
725 fprintf (out, "STATUS\t%u\t", data.devices_status);
726
727 /**
728 * speed new
729 */
730
731 fprintf (out, "SPEED\t");
732
733 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
734 {
735 hc_device_param_t *device_param = &data.devices_param[device_id];
736
737 uint64_t speed_cnt = 0;
738 float speed_ms = 0;
739
740 for (int i = 0; i < SPEED_CACHE; i++)
741 {
742 float rec_ms;
743
744 hc_timer_get (device_param->speed_rec[i], rec_ms);
745
746 if (rec_ms > SPEED_MAXAGE) continue;
747
748 speed_cnt += device_param->speed_cnt[i];
749 speed_ms += device_param->speed_ms[i];
750 }
751
752 speed_cnt /= SPEED_CACHE;
753 speed_ms /= SPEED_CACHE;
754
755 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
756 }
757
758 /**
759 * words_cur
760 */
761
762 uint64_t words_cur = get_lowest_words_done ();
763
764 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
765
766 /**
767 * counter
768 */
769
770 uint salts_left = data.salts_cnt - data.salts_done;
771
772 if (salts_left == 0) salts_left = 1;
773
774 uint64_t progress_total = data.words_cnt * salts_left;
775
776 uint64_t all_done = 0;
777 uint64_t all_rejected = 0;
778 uint64_t all_restored = 0;
779
780 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
781 {
782 if (salts_left > 1)
783 {
784 // otherwise the final cracked status shows 0/XXX progress
785
786 if (data.salts_shown[salt_pos] == 1) continue;
787 }
788
789 all_done += data.words_progress_done[salt_pos];
790 all_rejected += data.words_progress_rejected[salt_pos];
791 all_restored += data.words_progress_restored[salt_pos];
792 }
793
794 uint64_t progress_cur = all_restored + all_done + all_rejected;
795 uint64_t progress_end = progress_total;
796
797 uint64_t progress_skip = 0;
798
799 if (data.skip)
800 {
801 progress_skip = MIN (data.skip, data.words_base) * salts_left;
802
803 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
804 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
805 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
806 }
807
808 if (data.limit)
809 {
810 progress_end = MIN (data.limit, data.words_base) * salts_left;
811
812 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
813 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
814 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
815 }
816
817 uint64_t progress_cur_relative_skip = progress_cur - progress_skip;
818 uint64_t progress_end_relative_skip = progress_end - progress_skip;
819
820 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
821
822 /**
823 * cracks
824 */
825
826 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
827 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
828
829 /**
830 * temperature
831 */
832
833 if (data.gpu_temp_disable == 0)
834 {
835 fprintf (out, "TEMP\t");
836
837 hc_thread_mutex_lock (mux_adl);
838
839 for (uint i = 0; i < data.devices_cnt; i++)
840 {
841 int temp = hm_get_temperature_with_device_id (i);
842
843 fprintf (out, "%d\t", temp);
844 }
845
846 hc_thread_mutex_unlock (mux_adl);
847 }
848
849 #ifdef _WIN
850 fputc ('\r', out);
851 fputc ('\n', out);
852 #endif
853
854 #ifdef _POSIX
855 fputc ('\n', out);
856 #endif
857
858 fflush (out);
859 }
860
861 void status_display ()
862 {
863 if (data.devices_status == STATUS_INIT) return;
864 if (data.devices_status == STATUS_STARTING) return;
865 if (data.devices_status == STATUS_BYPASS) return;
866
867 if (data.status_automat == 1)
868 {
869 status_display_automat ();
870
871 return;
872 }
873
874 char tmp_buf[1000];
875
876 uint tmp_len = 0;
877
878 log_info ("Session.Name...: %s", data.session);
879
880 char *status_type = strstatus (data.devices_status);
881
882 uint hash_mode = data.hash_mode;
883
884 char *hash_type = strhashtype (hash_mode); // not a bug
885
886 log_info ("Status.........: %s", status_type);
887
888 /**
889 * show rules
890 */
891
892 if (data.rp_files_cnt)
893 {
894 uint i;
895
896 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
897 {
898 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
899 }
900
901 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
902
903 log_info ("Rules.Type.....: %s", tmp_buf);
904
905 tmp_len = 0;
906 }
907
908 if (data.rp_gen)
909 {
910 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
911
912 if (data.rp_gen_seed)
913 {
914 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
915 }
916 }
917
918 /**
919 * show input
920 */
921
922 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
923 {
924 if (data.wordlist_mode == WL_MODE_FILE)
925 {
926 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
927 }
928 else if (data.wordlist_mode == WL_MODE_STDIN)
929 {
930 log_info ("Input.Mode.....: Pipe");
931 }
932 }
933 else if (data.attack_mode == ATTACK_MODE_COMBI)
934 {
935 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
936 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
937 }
938 else if (data.attack_mode == ATTACK_MODE_BF)
939 {
940 char *mask = data.mask;
941
942 if (mask != NULL)
943 {
944 uint mask_len = data.css_cnt;
945
946 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
947
948 if (mask_len > 0)
949 {
950 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
951 {
952 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
953 {
954 mask_len -= data.salts_buf[0].salt_len;
955 }
956 }
957
958 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
959
960 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
961 }
962
963 if (data.maskcnt > 1)
964 {
965 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
966
967 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
968 }
969
970 log_info ("Input.Mode.....: %s", tmp_buf);
971 }
972
973 tmp_len = 0;
974 }
975 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
976 {
977 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
978 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
979 }
980 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
981 {
982 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
983 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
984 }
985
986 if (data.digests_cnt == 1)
987 {
988 if (data.hash_mode == 2500)
989 {
990 wpa_t *wpa = (wpa_t *) data.esalts_buf;
991
992 uint pke[25];
993
994 char *pke_ptr = (char *) pke;
995
996 for (uint i = 0; i < 25; i++)
997 {
998 pke[i] = byte_swap_32 (wpa->pke[i]);
999 }
1000
1001 char mac1[6];
1002 char mac2[6];
1003
1004 memcpy (mac1, pke_ptr + 23, 6);
1005 memcpy (mac2, pke_ptr + 29, 6);
1006
1007 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1008 (char *) data.salts_buf[0].salt_buf,
1009 mac1[0] & 0xff,
1010 mac1[1] & 0xff,
1011 mac1[2] & 0xff,
1012 mac1[3] & 0xff,
1013 mac1[4] & 0xff,
1014 mac1[5] & 0xff,
1015 mac2[0] & 0xff,
1016 mac2[1] & 0xff,
1017 mac2[2] & 0xff,
1018 mac2[3] & 0xff,
1019 mac2[4] & 0xff,
1020 mac2[5] & 0xff);
1021 }
1022 else if (data.hash_mode == 5200)
1023 {
1024 log_info ("Hash.Target....: File (%s)", data.hashfile);
1025 }
1026 else if (data.hash_mode == 9000)
1027 {
1028 log_info ("Hash.Target....: File (%s)", data.hashfile);
1029 }
1030 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1031 {
1032 log_info ("Hash.Target....: File (%s)", data.hashfile);
1033 }
1034 else
1035 {
1036 char out_buf[4096];
1037
1038 ascii_digest (out_buf, 0, 0);
1039
1040 // limit length
1041 if (strlen (out_buf) > 40)
1042 {
1043 out_buf[41] = '.';
1044 out_buf[42] = '.';
1045 out_buf[43] = '.';
1046 out_buf[44] = 0;
1047 }
1048
1049 log_info ("Hash.Target....: %s", out_buf);
1050 }
1051 }
1052 else
1053 {
1054 if (data.hash_mode == 3000)
1055 {
1056 char out_buf1[4096];
1057 char out_buf2[4096];
1058
1059 ascii_digest (out_buf1, 0, 0);
1060 ascii_digest (out_buf2, 0, 1);
1061
1062 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1063 }
1064 else
1065 {
1066 log_info ("Hash.Target....: File (%s)", data.hashfile);
1067 }
1068 }
1069
1070 log_info ("Hash.Type......: %s", hash_type);
1071
1072 /**
1073 * speed new
1074 */
1075
1076 uint64_t speed_cnt[DEVICES_MAX];
1077 float speed_ms[DEVICES_MAX];
1078
1079 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1080 {
1081 hc_device_param_t *device_param = &data.devices_param[device_id];
1082
1083 // we need to clear values (set to 0) because in case the device does
1084 // not get new candidates it idles around but speed display would
1085 // show it as working.
1086 // if we instantly set it to 0 after reading it happens that the
1087 // speed can be shown as zero if the users refreshs to fast.
1088 // therefore, we add a timestamp when a stat was recorded and if its
1089 // to old we will not use it
1090
1091 speed_cnt[device_id] = 0;
1092 speed_ms[device_id] = 0;
1093
1094 for (int i = 0; i < SPEED_CACHE; i++)
1095 {
1096 float rec_ms;
1097
1098 hc_timer_get (device_param->speed_rec[i], rec_ms);
1099
1100 if (rec_ms > SPEED_MAXAGE) continue;
1101
1102 speed_cnt[device_id] += device_param->speed_cnt[i];
1103 speed_ms[device_id] += device_param->speed_ms[i];
1104 }
1105
1106 speed_cnt[device_id] /= SPEED_CACHE;
1107 speed_ms[device_id] /= SPEED_CACHE;
1108 }
1109
1110 float hashes_all_ms = 0;
1111
1112 float hashes_dev_ms[DEVICES_MAX];
1113
1114 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1115 {
1116 hashes_dev_ms[device_id] = 0;
1117
1118 if (speed_ms[device_id])
1119 {
1120 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1121
1122 hashes_all_ms += hashes_dev_ms[device_id];
1123 }
1124 }
1125
1126 /**
1127 * timers
1128 */
1129
1130 float ms_running = 0;
1131
1132 hc_timer_get (data.timer_running, ms_running);
1133
1134 float ms_paused = data.ms_paused;
1135
1136 if (data.devices_status == STATUS_PAUSED)
1137 {
1138 float ms_paused_tmp = 0;
1139
1140 hc_timer_get (data.timer_paused, ms_paused_tmp);
1141
1142 ms_paused += ms_paused_tmp;
1143 }
1144
1145 #ifdef WIN
1146
1147 __time64_t sec_run = ms_running / 1000;
1148
1149 #else
1150
1151 time_t sec_run = ms_running / 1000;
1152
1153 #endif
1154
1155 if (sec_run)
1156 {
1157 char display_run[32];
1158
1159 struct tm tm_run;
1160
1161 struct tm *tmp;
1162
1163 #ifdef WIN
1164
1165 tmp = _gmtime64 (&sec_run);
1166
1167 #else
1168
1169 tmp = gmtime (&sec_run);
1170
1171 #endif
1172
1173 if (tmp != NULL)
1174 {
1175 memcpy (&tm_run, tmp, sizeof (struct tm));
1176
1177 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1178
1179 char *start = ctime (&data.proc_start);
1180
1181 size_t start_len = strlen (start);
1182
1183 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1184 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1185
1186 log_info ("Time.Started...: %s (%s)", start, display_run);
1187 }
1188 }
1189 else
1190 {
1191 log_info ("Time.Started...: 0 secs");
1192 }
1193
1194 /**
1195 * counters
1196 */
1197
1198 uint salts_left = data.salts_cnt - data.salts_done;
1199
1200 if (salts_left == 0) salts_left = 1;
1201
1202 uint64_t progress_total = data.words_cnt * salts_left;
1203
1204 uint64_t all_done = 0;
1205 uint64_t all_rejected = 0;
1206 uint64_t all_restored = 0;
1207
1208 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1209 {
1210 if (salts_left > 1)
1211 {
1212 // otherwise the final cracked status shows 0/XXX progress
1213
1214 if (data.salts_shown[salt_pos] == 1) continue;
1215 }
1216
1217 all_done += data.words_progress_done[salt_pos];
1218 all_rejected += data.words_progress_rejected[salt_pos];
1219 all_restored += data.words_progress_restored[salt_pos];
1220 }
1221
1222 uint64_t progress_cur = all_restored + all_done + all_rejected;
1223 uint64_t progress_end = progress_total;
1224
1225 uint64_t progress_skip = 0;
1226
1227 if (data.skip)
1228 {
1229 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1230
1231 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1232 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1233 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1234 }
1235
1236 if (data.limit)
1237 {
1238 progress_end = MIN (data.limit, data.words_base) * salts_left;
1239
1240 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1241 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1242 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1243 }
1244
1245 uint64_t progress_cur_relative_skip = progress_cur - progress_skip;
1246 uint64_t progress_end_relative_skip = progress_end - progress_skip;
1247
1248 float speed_ms_real = ms_running - ms_paused;
1249 uint64_t speed_plains_real = all_done;
1250
1251 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1252 {
1253 if (data.devices_status != STATUS_CRACKED)
1254 {
1255 uint64_t words_per_ms = 0;
1256
1257 if (speed_plains_real && speed_ms_real)
1258 {
1259 words_per_ms = speed_plains_real / speed_ms_real;
1260 }
1261
1262 #ifdef WIN
1263 __time64_t sec_etc = 0;
1264 #else
1265 time_t sec_etc = 0;
1266 #endif
1267
1268 if (words_per_ms)
1269 {
1270 uint64_t progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1271
1272 uint64_t ms_left = progress_left_relative_skip / words_per_ms;
1273
1274 sec_etc = ms_left / 1000;
1275 }
1276
1277 if (sec_etc == 0)
1278 {
1279 log_info ("Time.Estimated.: 0 secs");
1280 }
1281 else if ((uint64_t) sec_etc > ETC_MAX)
1282 {
1283 log_info ("Time.Estimated.: > 10 Years");
1284 }
1285 else
1286 {
1287 char display_etc[32];
1288
1289 struct tm tm_etc;
1290
1291 struct tm *tmp;
1292
1293 #ifdef WIN
1294
1295 tmp = _gmtime64 (&sec_etc);
1296
1297 #else
1298
1299 tmp = gmtime (&sec_etc);
1300
1301 #endif
1302
1303 if (tmp != NULL)
1304 {
1305 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1306
1307 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1308
1309 time_t now;
1310
1311 time (&now);
1312
1313 now += sec_etc;
1314
1315 char *etc = ctime (&now);
1316
1317 size_t etc_len = strlen (etc);
1318
1319 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1320 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1321
1322 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1323 }
1324 }
1325 }
1326 }
1327
1328 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1329 {
1330 char display_dev_cur[16];
1331
1332 memset (display_dev_cur, 0, sizeof (display_dev_cur));
1333
1334 strncpy (display_dev_cur, "0.00", 4);
1335
1336 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1337
1338 log_info ("Speed.Dev.#%d...: %9sH/s", device_id + 1, display_dev_cur);
1339 }
1340
1341 char display_all_cur[16];
1342
1343 memset (display_all_cur, 0, sizeof (display_all_cur));
1344
1345 strncpy (display_all_cur, "0.00", 4);
1346
1347 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1348
1349 if (data.devices_cnt > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1350
1351 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1352 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1353
1354 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);
1355
1356 // crack-per-time
1357
1358 if (data.digests_cnt > 100)
1359 {
1360 time_t now = time (NULL);
1361
1362 int cpt_cur_min = 0;
1363 int cpt_cur_hour = 0;
1364 int cpt_cur_day = 0;
1365
1366 for (int i = 0; i < CPT_BUF; i++)
1367 {
1368 const uint cracked = data.cpt_buf[i].cracked;
1369 const time_t timestamp = data.cpt_buf[i].timestamp;
1370
1371 if ((timestamp + 60) > now)
1372 {
1373 cpt_cur_min += cracked;
1374 }
1375
1376 if ((timestamp + 3600) > now)
1377 {
1378 cpt_cur_hour += cracked;
1379 }
1380
1381 if ((timestamp + 86400) > now)
1382 {
1383 cpt_cur_day += cracked;
1384 }
1385 }
1386
1387 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1388 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1389 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1390
1391 if ((data.cpt_start + 86400) < now)
1392 {
1393 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1394 cpt_cur_min,
1395 cpt_cur_hour,
1396 cpt_cur_day,
1397 cpt_avg_min,
1398 cpt_avg_hour,
1399 cpt_avg_day);
1400 }
1401 else if ((data.cpt_start + 3600) < now)
1402 {
1403 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1404 cpt_cur_min,
1405 cpt_cur_hour,
1406 cpt_avg_min,
1407 cpt_avg_hour,
1408 cpt_avg_day);
1409 }
1410 else if ((data.cpt_start + 60) < now)
1411 {
1412 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1413 cpt_cur_min,
1414 cpt_avg_min,
1415 cpt_avg_hour,
1416 cpt_avg_day);
1417 }
1418 else
1419 {
1420 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1421 cpt_avg_min,
1422 cpt_avg_hour,
1423 cpt_avg_day);
1424 }
1425 }
1426
1427 // Restore point
1428
1429 uint64_t restore_point = get_lowest_words_done ();
1430
1431 uint64_t restore_total = data.words_base;
1432
1433 float percent_restore = 0;
1434
1435 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1436
1437 if (progress_end_relative_skip)
1438 {
1439 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1440 {
1441 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1442 float percent_rejected = 0.0;
1443
1444 if (progress_cur)
1445 {
1446 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1447 }
1448
1449 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);
1450 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1451
1452 if (data.restore_disable == 0)
1453 {
1454 if (percent_finished != 1)
1455 {
1456 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1457 }
1458 }
1459 }
1460 }
1461 else
1462 {
1463 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1464 {
1465 log_info ("Progress.......: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1466 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1467
1468 if (data.restore_disable == 0)
1469 {
1470 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1471 }
1472 }
1473 else
1474 {
1475 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1476 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1477
1478 // --restore not allowed if stdin is used -- really? why?
1479
1480 //if (data.restore_disable == 0)
1481 //{
1482 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1483 //}
1484 }
1485 }
1486
1487 if (data.gpu_temp_disable == 0)
1488 {
1489 hc_thread_mutex_lock (mux_adl);
1490
1491 for (uint i = 0; i < data.devices_cnt; i++)
1492 {
1493 if (data.hm_device[i].fan_supported == 1)
1494 {
1495 const int temperature = hm_get_temperature_with_device_id (i);
1496 const int utilization = hm_get_utilization_with_device_id (i);
1497 const int fanspeed = hm_get_fanspeed_with_device_id (i);
1498
1499 if (data.vendor_id == VENDOR_ID_AMD)
1500 {
1501 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, %2d%% Fan", i + 1, utilization, temperature, fanspeed);
1502 }
1503
1504 if (data.vendor_id == VENDOR_ID_NV)
1505 {
1506 #ifdef LINUX
1507 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, %2d%% Fan", i + 1, utilization, temperature, fanspeed);
1508 #else
1509 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, %2drpm Fan", i + 1, utilization, temperature, fanspeed);
1510 #endif
1511 }
1512 }
1513 else
1514 {
1515 const int temperature = hm_get_temperature_with_device_id (i);
1516 const int utilization = hm_get_utilization_with_device_id (i);
1517
1518 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, N/A Fan", i + 1, utilization, temperature);
1519 }
1520 }
1521
1522 hc_thread_mutex_unlock (mux_adl);
1523 }
1524 }
1525
1526 static void status_benchmark ()
1527 {
1528 if (data.devices_status == STATUS_INIT) return;
1529 if (data.devices_status == STATUS_STARTING) return;
1530
1531 if (data.words_cnt == 0) return;
1532
1533 uint64_t speed_cnt[DEVICES_MAX];
1534 float speed_ms[DEVICES_MAX];
1535
1536 uint device_id;
1537
1538 for (device_id = 0; device_id < data.devices_cnt; device_id++)
1539 {
1540 hc_device_param_t *device_param = &data.devices_param[device_id];
1541
1542 speed_cnt[device_id] = 0;
1543 speed_ms[device_id] = 0;
1544
1545 for (int i = 0; i < SPEED_CACHE; i++)
1546 {
1547 speed_cnt[device_id] += device_param->speed_cnt[i];
1548 speed_ms[device_id] += device_param->speed_ms[i];
1549 }
1550
1551 speed_cnt[device_id] /= SPEED_CACHE;
1552 speed_ms[device_id] /= SPEED_CACHE;
1553 }
1554
1555 float hashes_all_ms = 0;
1556
1557 float hashes_dev_ms[DEVICES_MAX];
1558
1559 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1560 {
1561 hashes_dev_ms[device_id] = 0;
1562
1563 if (speed_ms[device_id])
1564 {
1565 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1566
1567 hashes_all_ms += hashes_dev_ms[device_id];
1568 }
1569 }
1570
1571 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1572 {
1573 char display_dev_cur[16];
1574
1575 memset (display_dev_cur, 0, sizeof (display_dev_cur));
1576
1577 strncpy (display_dev_cur, "0.00", 4);
1578
1579 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1580
1581 log_info ("Speed.Dev.#%d.: %9sH/s", device_id + 1, display_dev_cur);
1582 }
1583
1584 char display_all_cur[16];
1585
1586 memset (display_all_cur, 0, sizeof (display_all_cur));
1587
1588 strncpy (display_all_cur, "0.00", 4);
1589
1590 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1591
1592 if (data.devices_cnt > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1593 }
1594
1595 /**
1596 * oclHashcat -only- functions
1597 */
1598
1599 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1600 {
1601 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1602 {
1603 if (attack_kern == ATTACK_KERN_STRAIGHT)
1604 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1605 else if (attack_kern == ATTACK_KERN_COMBI)
1606 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1607 else if (attack_kern == ATTACK_KERN_BF)
1608 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1609 }
1610 else
1611 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1612 }
1613
1614 static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *profile_dir, char *device_name_chksum, int vendor_id, char *cached_file)
1615 {
1616 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1617 {
1618 if (attack_kern == ATTACK_KERN_STRAIGHT)
1619 snprintf (cached_file, 255, "%s/kernels/%d/m%05d_a0.%s.kernel", profile_dir, vendor_id, (int) kern_type, device_name_chksum);
1620 else if (attack_kern == ATTACK_KERN_COMBI)
1621 snprintf (cached_file, 255, "%s/kernels/%d/m%05d_a1.%s.kernel", profile_dir, vendor_id, (int) kern_type, device_name_chksum);
1622 else if (attack_kern == ATTACK_KERN_BF)
1623 snprintf (cached_file, 255, "%s/kernels/%d/m%05d_a3.%s.kernel", profile_dir, vendor_id, (int) kern_type, device_name_chksum);
1624 }
1625 else
1626 {
1627 snprintf (cached_file, 255, "%s/kernels/%d/m%05d.%s.kernel", profile_dir, vendor_id, (int) kern_type, device_name_chksum);
1628 }
1629 }
1630
1631 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1632 {
1633 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1634 {
1635 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1636 }
1637 else
1638 {
1639 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1640 }
1641 }
1642
1643 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, char *device_name_chksum, int vendor_id, char *cached_file)
1644 {
1645 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1646 {
1647 snprintf (cached_file, 255, "%s/kernels/%d/markov_be.%s.kernel", profile_dir, vendor_id, device_name_chksum);
1648 }
1649 else
1650 {
1651 snprintf (cached_file, 255, "%s/kernels/%d/markov_le.%s.kernel", profile_dir, vendor_id, device_name_chksum);
1652 }
1653 }
1654
1655 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1656 {
1657 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1658 }
1659
1660 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, char *device_name_chksum, int vendor_id, char *cached_file)
1661 {
1662 snprintf (cached_file, 255, "%s/kernels/%d/amp_a%d.%s.kernel", profile_dir, vendor_id, attack_kern, device_name_chksum);
1663 }
1664
1665 static uint convert_from_hex (char *line_buf, const uint line_len)
1666 {
1667 if (line_len & 1) return (line_len); // not in hex
1668
1669 if (data.hex_wordlist == 1)
1670 {
1671 uint i;
1672 uint j;
1673
1674 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1675 {
1676 line_buf[i] = hex_to_char (&line_buf[j]);
1677 }
1678
1679 memset (line_buf + i, 0, line_len - i);
1680
1681 return (i);
1682 }
1683 else if (line_len >= 6) // $HEX[] = 6
1684 {
1685 if (line_buf[0] != '$') return (line_len);
1686 if (line_buf[1] != 'H') return (line_len);
1687 if (line_buf[2] != 'E') return (line_len);
1688 if (line_buf[3] != 'X') return (line_len);
1689 if (line_buf[4] != '[') return (line_len);
1690 if (line_buf[line_len - 1] != ']') return (line_len);
1691
1692 uint i;
1693 uint j;
1694
1695 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1696 {
1697 line_buf[i] = hex_to_char (&line_buf[j]);
1698 }
1699
1700 memset (line_buf + i, 0, line_len - i);
1701
1702 return (i);
1703 }
1704
1705 return (line_len);
1706 }
1707
1708 static uint count_lines (FILE *fd)
1709 {
1710 uint cnt = 0;
1711
1712 char *buf = (char *) mymalloc (BUFSIZ);
1713
1714 size_t nread_tmp = 0;
1715
1716 char *ptr = buf;
1717
1718 while (!feof (fd))
1719 {
1720 size_t nread = fread (buf, sizeof (char), BUFSIZ, fd);
1721 nread_tmp = nread;
1722
1723 if (nread < 1) continue;
1724
1725 ptr = buf;
1726
1727 do
1728 {
1729 if (*ptr++ == '\n') cnt++;
1730
1731 } while (nread--);
1732 }
1733
1734 // special case (if last line did not contain a newline char ... at the very end of the file)
1735
1736 if (nread_tmp > 3)
1737 {
1738 ptr -= 2;
1739
1740 if (*ptr != '\n')
1741 {
1742 ptr--;
1743
1744 if (*ptr != '\n') // needed ? different on windows systems?
1745 {
1746 cnt++;
1747 }
1748 }
1749 }
1750
1751 myfree (buf);
1752
1753 return cnt;
1754 }
1755
1756 static void clear_prompt ()
1757 {
1758 fputc ('\r', stdout);
1759
1760 for (size_t i = 0; i < strlen (PROMPT); i++)
1761 {
1762 fputc (' ', stdout);
1763 }
1764
1765 fputc ('\r', stdout);
1766
1767 fflush (stdout);
1768 }
1769
1770 static void gidd_to_pw_t (hc_device_param_t *device_param, const uint64_t gidd, pw_t *pw)
1771 {
1772 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1773 }
1774
1775 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1776 {
1777 char *outfile = data.outfile;
1778 uint quiet = data.quiet;
1779 FILE *pot_fp = data.pot_fp;
1780 uint loopback = data.loopback;
1781 uint debug_mode = data.debug_mode;
1782 char *debug_file = data.debug_file;
1783
1784 char debug_rule_buf[BLOCK_SIZE];
1785 int debug_rule_len = 0; // -1 error
1786 uint debug_plain_len = 0;
1787
1788 unsigned char debug_plain_ptr[BLOCK_SIZE];
1789
1790 // hash
1791
1792 char out_buf[4096]; memset (out_buf, 0, sizeof (out_buf));
1793
1794 ascii_digest (out_buf, salt_pos, digest_pos);
1795
1796 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1797
1798 // plain
1799
1800 plain_t plain;
1801
1802 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, idx * sizeof (plain_t), sizeof (plain_t), &plain, 0, NULL, NULL);
1803
1804 uint gidvid = plain.gidvid;
1805 uint il_pos = plain.il_pos;
1806
1807 uint64_t crackpos = device_param->words_off;
1808
1809 uint plain_buf[16];
1810
1811 unsigned char *plain_ptr = (unsigned char *) plain_buf;
1812 unsigned int plain_len = 0;
1813
1814 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1815 {
1816 uint64_t gidd = gidvid;
1817 uint64_t gidm = 0;
1818
1819 pw_t pw;
1820
1821 gidd_to_pw_t (device_param, gidd, &pw);
1822
1823 for (int i = 0, j = gidm; i < 16; i++, j++)
1824 {
1825 plain_buf[i] = pw.hi1[0][j];
1826 }
1827
1828 plain_len = pw.pw_len;
1829
1830 const uint off = device_param->innerloop_pos + il_pos;
1831
1832 if (debug_mode > 0)
1833 {
1834 debug_rule_len = 0;
1835
1836 // save rule
1837 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1838 {
1839 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1840
1841 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1842 }
1843
1844 // save plain
1845 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1846 {
1847 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1848
1849 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1850
1851 debug_plain_len = plain_len;
1852 }
1853 }
1854
1855 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1856
1857 crackpos += gidvid;
1858 crackpos *= data.kernel_rules_cnt;
1859 crackpos += device_param->innerloop_pos + il_pos;
1860
1861 if (plain_len > data.pw_max) plain_len = data.pw_max;
1862 }
1863 else if (data.attack_mode == ATTACK_MODE_COMBI)
1864 {
1865 uint64_t gidd = gidvid;
1866 uint64_t gidm = 0;
1867
1868 pw_t pw;
1869
1870 gidd_to_pw_t (device_param, gidd, &pw);
1871
1872 for (int i = 0, j = gidm; i < 16; i++, j++)
1873 {
1874 plain_buf[i] = pw.hi1[0][j];
1875 }
1876
1877 plain_len = pw.pw_len;
1878
1879 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1880 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1881
1882 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1883 {
1884 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1885 }
1886 else
1887 {
1888 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1889
1890 memcpy (plain_ptr, comb_buf, comb_len);
1891 }
1892
1893 plain_len += comb_len;
1894
1895 crackpos += gidvid;
1896 crackpos *= data.combs_cnt;
1897 crackpos += device_param->innerloop_pos + il_pos;
1898
1899 if (data.pw_max != PW_DICTMAX1)
1900 {
1901 if (plain_len > data.pw_max) plain_len = data.pw_max;
1902 }
1903 }
1904 else if (data.attack_mode == ATTACK_MODE_BF)
1905 {
1906 uint64_t l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1907 uint64_t r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1908
1909 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1910 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1911
1912 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1913 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1914
1915 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1916 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1917
1918 plain_len = data.css_cnt;
1919
1920 crackpos += gidvid;
1921 crackpos *= data.bfs_cnt;
1922 crackpos += device_param->innerloop_pos + il_pos;
1923 }
1924 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1925 {
1926 uint64_t gidd = gidvid;
1927 uint64_t gidm = 0;
1928
1929 pw_t pw;
1930
1931 gidd_to_pw_t (device_param, gidd, &pw);
1932
1933 for (int i = 0, j = gidm; i < 16; i++, j++)
1934 {
1935 plain_buf[i] = pw.hi1[0][j];
1936 }
1937
1938 plain_len = pw.pw_len;
1939
1940 uint64_t off = device_param->kernel_params_mp_buf64[3] + il_pos;
1941
1942 uint start = 0;
1943 uint stop = device_param->kernel_params_mp_buf32[4];
1944
1945 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
1946
1947 plain_len += start + stop;
1948
1949 crackpos += gidvid;
1950 crackpos *= data.combs_cnt;
1951 crackpos += device_param->innerloop_pos + il_pos;
1952
1953 if (data.pw_max != PW_DICTMAX1)
1954 {
1955 if (plain_len > data.pw_max) plain_len = data.pw_max;
1956 }
1957 }
1958 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1959 {
1960 uint64_t gidd = gidvid;
1961 uint64_t gidm = 0;
1962
1963 pw_t pw;
1964
1965 gidd_to_pw_t (device_param, gidd, &pw);
1966
1967 for (int i = 0, j = gidm; i < 16; i++, j++)
1968 {
1969 plain_buf[i] = pw.hi1[0][j];
1970 }
1971
1972 plain_len = pw.pw_len;
1973
1974 uint64_t off = device_param->kernel_params_mp_buf64[3] + il_pos;
1975
1976 uint start = 0;
1977 uint stop = device_param->kernel_params_mp_buf32[4];
1978
1979 memmove (plain_ptr + stop, plain_ptr, plain_len);
1980
1981 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
1982
1983 plain_len += start + stop;
1984
1985 crackpos += gidvid;
1986 crackpos *= data.combs_cnt;
1987 crackpos += device_param->innerloop_pos + il_pos;
1988
1989 if (data.pw_max != PW_DICTMAX1)
1990 {
1991 if (plain_len > data.pw_max) plain_len = data.pw_max;
1992 }
1993 }
1994
1995 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
1996 {
1997 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1998 {
1999 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2000 {
2001 plain_len = plain_len - data.salts_buf[0].salt_len;
2002 }
2003 }
2004
2005 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2006 {
2007 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2008 {
2009 plain_ptr[j] = plain_ptr[i];
2010 }
2011
2012 plain_len = plain_len / 2;
2013 }
2014 }
2015
2016 // if enabled, update also the potfile
2017
2018 if (pot_fp)
2019 {
2020 fprintf (pot_fp, "%s:", out_buf);
2021
2022 format_plain (pot_fp, plain_ptr, plain_len, 1);
2023
2024 fputc ('\n', pot_fp);
2025
2026 fflush (pot_fp);
2027 }
2028
2029 // outfile
2030
2031 FILE *out_fp = NULL;
2032
2033 if (outfile != NULL)
2034 {
2035 if ((out_fp = fopen (outfile, "ab")) == NULL)
2036 {
2037 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2038
2039 out_fp = stdout;
2040 }
2041 }
2042 else
2043 {
2044 out_fp = stdout;
2045
2046 if (quiet == 0) clear_prompt ();
2047 }
2048
2049 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2050
2051 if (outfile != NULL)
2052 {
2053 if (out_fp != stdout)
2054 {
2055 fclose (out_fp);
2056 }
2057 }
2058 else
2059 {
2060 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2061 {
2062 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2063 {
2064 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2065 if (quiet == 0) fflush (stdout);
2066 }
2067 }
2068 }
2069
2070 // loopback
2071
2072 if (loopback)
2073 {
2074 char *loopback_file = data.loopback_file;
2075
2076 FILE *fb_fp = NULL;
2077
2078 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2079 {
2080 format_plain (fb_fp, plain_ptr, plain_len, 1);
2081
2082 fputc ('\n', fb_fp);
2083
2084 fclose (fb_fp);
2085 }
2086 }
2087
2088 // (rule) debug mode
2089
2090 // the next check implies that:
2091 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2092 // - debug_mode > 0
2093
2094 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2095 {
2096 if (debug_rule_len < 0) debug_rule_len = 0;
2097
2098 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2099
2100 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2101
2102 if ((quiet == 0) && (debug_file == NULL))
2103 {
2104 fprintf (stdout, "%s", PROMPT);
2105 fflush (stdout);
2106 }
2107 }
2108 }
2109
2110 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2111 {
2112 salt_t *salt_buf = &data.salts_buf[salt_pos];
2113
2114 int found = 0;
2115
2116 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2117
2118 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2119
2120 if (found == 1)
2121 {
2122 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2123
2124 log_info_nn ("");
2125
2126 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);
2127
2128 uint cpt_cracked = 0;
2129
2130 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2131 {
2132 uint idx = salt_buf->digests_offset + digest_pos;
2133
2134 if (data.digests_shown_tmp[idx] == 0) continue;
2135
2136 if (data.digests_shown[idx] == 1) continue;
2137
2138 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2139 {
2140 data.digests_shown[idx] = 1;
2141
2142 data.digests_done++;
2143
2144 cpt_cracked++;
2145
2146 salt_buf->digests_done++;
2147
2148 if (salt_buf->digests_done == salt_buf->digests_cnt)
2149 {
2150 data.salts_shown[salt_pos] = 1;
2151
2152 data.salts_done++;
2153 }
2154 }
2155
2156 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2157
2158 check_hash (device_param, salt_pos, digest_pos);
2159 }
2160
2161 if (cpt_cracked > 0)
2162 {
2163 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2164 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2165
2166 data.cpt_pos++;
2167
2168 data.cpt_total += cpt_cracked;
2169
2170 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2171 }
2172
2173 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2174 {
2175 // we need to reset cracked state on the device
2176 // otherwise host thinks again and again the hash was cracked
2177 // and returns invalid password each time
2178
2179 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2180
2181 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);
2182 }
2183
2184 memset (device_param->result, 0, device_param->size_results);
2185
2186 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2187 }
2188 }
2189
2190 static void save_hash ()
2191 {
2192 char *hashfile = data.hashfile;
2193
2194 char new_hashfile[256];
2195 char old_hashfile[256];
2196
2197 memset (new_hashfile, 0, sizeof (new_hashfile));
2198 memset (old_hashfile, 0, sizeof (old_hashfile));
2199
2200 snprintf (new_hashfile, 255, "%s.new", hashfile);
2201 snprintf (old_hashfile, 255, "%s.old", hashfile);
2202
2203 unlink (new_hashfile);
2204
2205 char separator = data.separator;
2206
2207 FILE *fp = fopen (new_hashfile, "wb");
2208
2209 if (fp == NULL)
2210 {
2211 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2212
2213 exit (-1);
2214 }
2215
2216 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2217 {
2218 if (data.salts_shown[salt_pos] == 1) continue;
2219
2220 salt_t *salt_buf = &data.salts_buf[salt_pos];
2221
2222 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2223 {
2224 uint idx = salt_buf->digests_offset + digest_pos;
2225
2226 if (data.digests_shown[idx] == 1) continue;
2227
2228 if (data.hash_mode != 2500)
2229 {
2230 char out_buf[4096];
2231
2232 memset (out_buf, 0, sizeof (out_buf));
2233
2234 if (data.username == 1)
2235 {
2236 user_t *user = data.hash_info[idx]->user;
2237
2238 uint i;
2239
2240 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2241
2242 fputc (separator, fp);
2243 }
2244
2245 ascii_digest (out_buf, salt_pos, digest_pos);
2246
2247 fputs (out_buf, fp);
2248
2249 log_out (fp, "");
2250 }
2251 else
2252 {
2253 hccap_t hccap;
2254
2255 to_hccap_t (&hccap, salt_pos, digest_pos);
2256
2257 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2258 }
2259 }
2260 }
2261
2262 fflush (fp);
2263
2264 fclose (fp);
2265
2266 unlink (old_hashfile);
2267
2268 if (rename (hashfile, old_hashfile) != 0)
2269 {
2270 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2271
2272 exit (-1);
2273 }
2274
2275 unlink (hashfile);
2276
2277 if (rename (new_hashfile, hashfile) != 0)
2278 {
2279 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2280
2281 exit (-1);
2282 }
2283
2284 unlink (old_hashfile);
2285 }
2286
2287 static float find_kernel_blocks_div (const uint64_t total_left, const uint kernel_blocks_all)
2288 {
2289 // function called only in case kernel_blocks_all > words_left)
2290
2291 float kernel_blocks_div = (float) (total_left) / kernel_blocks_all;
2292
2293 kernel_blocks_div += kernel_blocks_div / 100;
2294
2295 uint32_t kernel_blocks_new = (uint32_t) (kernel_blocks_all * kernel_blocks_div);
2296
2297 while (kernel_blocks_new < total_left)
2298 {
2299 kernel_blocks_div += kernel_blocks_div / 100;
2300
2301 kernel_blocks_new = (uint32_t) (kernel_blocks_all * kernel_blocks_div);
2302 }
2303
2304 if (data.quiet == 0)
2305 {
2306 clear_prompt ();
2307
2308 log_info ("");
2309
2310 log_info ("INFO: approaching final keyspace, workload adjusted");
2311
2312 log_info ("");
2313
2314 fprintf (stdout, "%s", PROMPT);
2315
2316 fflush (stdout);
2317 }
2318
2319 if ((kernel_blocks_all * kernel_blocks_div) < 8) return 1;
2320
2321 return kernel_blocks_div;
2322 }
2323
2324 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num)
2325 {
2326 uint num_elements = num;
2327
2328 device_param->kernel_params_buf32[30] = data.combs_mode;
2329 device_param->kernel_params_buf32[31] = num;
2330
2331 uint kernel_threads = device_param->kernel_threads;
2332
2333 while (num_elements % kernel_threads) num_elements++;
2334
2335 cl_kernel kernel = NULL;
2336
2337 switch (kern_run)
2338 {
2339 case KERN_RUN_1: kernel = device_param->kernel1; break;
2340 case KERN_RUN_12: kernel = device_param->kernel12; break;
2341 case KERN_RUN_2: kernel = device_param->kernel2; break;
2342 case KERN_RUN_23: kernel = device_param->kernel23; break;
2343 case KERN_RUN_3: kernel = device_param->kernel3; break;
2344 }
2345
2346 hc_clSetKernelArg (kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2347 hc_clSetKernelArg (kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2348 hc_clSetKernelArg (kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2349 hc_clSetKernelArg (kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2350 hc_clSetKernelArg (kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2351 hc_clSetKernelArg (kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2352 hc_clSetKernelArg (kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2353 hc_clSetKernelArg (kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2354 hc_clSetKernelArg (kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2355 hc_clSetKernelArg (kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2356 hc_clSetKernelArg (kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2357
2358 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2359 {
2360 const size_t global_work_size[3] = { num_elements, 32, 1 };
2361 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2362
2363 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2364 }
2365 else
2366 {
2367 const size_t global_work_size[3] = { num_elements, 1, 1 };
2368 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2369
2370 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2371 }
2372
2373 hc_clFlush (device_param->command_queue);
2374
2375 hc_clFinish (device_param->command_queue);
2376 }
2377
2378 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2379 {
2380 uint num_elements = num;
2381
2382 switch (kern_run)
2383 {
2384 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2385 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2386 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2387 }
2388
2389 // causes problems with special threads like in bcrypt
2390 // const uint kernel_threads = device_param->kernel_threads;
2391
2392 const uint kernel_threads = KERNEL_THREADS;
2393
2394 while (num_elements % kernel_threads) num_elements++;
2395
2396 cl_kernel kernel = NULL;
2397
2398 switch (kern_run)
2399 {
2400 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2401 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2402 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2403 }
2404
2405 switch (kern_run)
2406 {
2407 case KERN_RUN_MP: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2408 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2409 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2410 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2411 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2412 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2413 break;
2414 case KERN_RUN_MP_R: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2415 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2416 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2417 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2418 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2419 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2420 break;
2421 case KERN_RUN_MP_L: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2422 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2423 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2424 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2425 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2426 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2427 hc_clSetKernelArg (kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2428 break;
2429 }
2430
2431 const size_t global_work_size[3] = { num_elements, 1, 1 };
2432 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2433
2434 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2435
2436 hc_clFlush (device_param->command_queue);
2437
2438 hc_clFinish (device_param->command_queue);
2439 }
2440
2441 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2442 {
2443 uint num_elements = num;
2444
2445 uint kernel_threads = device_param->kernel_threads;
2446
2447 while (num_elements % kernel_threads) num_elements++;
2448
2449 cl_kernel kernel = device_param->kernel_tb;
2450
2451 const size_t global_work_size[3] = { num_elements, 1, 1 };
2452 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2453
2454 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2455
2456 hc_clFlush (device_param->command_queue);
2457
2458 hc_clFinish (device_param->command_queue);
2459 }
2460
2461 static void run_kernel_tm (hc_device_param_t *device_param)
2462 {
2463 const uint num_elements = 1024; // fixed
2464
2465 const uint kernel_threads = 32;
2466
2467 cl_kernel kernel = device_param->kernel_tm;
2468
2469 const size_t global_work_size[3] = { num_elements, 1, 1 };
2470 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2471
2472 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2473
2474 hc_clFlush (device_param->command_queue);
2475
2476 hc_clFinish (device_param->command_queue);
2477 }
2478
2479 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2480 {
2481 uint num_elements = num;
2482
2483 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2484 device_param->kernel_params_amp_buf32[6] = num_elements;
2485
2486 // causes problems with special threads like in bcrypt
2487 // const uint kernel_threads = device_param->kernel_threads;
2488
2489 const uint kernel_threads = KERNEL_THREADS;
2490
2491 while (num_elements % kernel_threads) num_elements++;
2492
2493 cl_kernel kernel = device_param->kernel_amp;
2494
2495 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2496 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2497
2498 const size_t global_work_size[3] = { num_elements, 1, 1 };
2499 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2500
2501 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2502
2503 hc_clFlush (device_param->command_queue);
2504
2505 hc_clFinish (device_param->command_queue);
2506 }
2507
2508 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2509 {
2510 if (data.vendor_id == VENDOR_ID_AMD)
2511 {
2512 const cl_uchar zero = 0;
2513
2514 hc_clEnqueueFillBuffer (device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2515 }
2516
2517 if (data.vendor_id == VENDOR_ID_NV)
2518 {
2519 // NOTE: clEnqueueFillBuffer () always fails with -59
2520 // IOW, it's not supported by Nvidia ForceWare <= 352.21,
2521 // How's that possible, OpenCL 1.2 support is advertised??
2522 // We need to workaround...
2523
2524 #define FILLSZ 0x100000
2525
2526 char *tmp = (char *) mymalloc (FILLSZ);
2527
2528 memset (tmp, 0, FILLSZ);
2529
2530 for (uint i = 0; i < size; i += FILLSZ)
2531 {
2532 const int left = size - i;
2533
2534 const int fillsz = MIN (FILLSZ, left);
2535
2536 hc_clEnqueueWriteBuffer (device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2537 }
2538
2539 myfree (tmp);
2540 }
2541
2542 if (data.vendor_id == VENDOR_ID_GENERIC)
2543 {
2544 const cl_uchar zero = 0;
2545
2546 hc_clEnqueueFillBuffer (device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2547 }
2548 }
2549
2550 static int run_rule_engine (const int rule_len, const char *rule_buf)
2551 {
2552 if (rule_len == 0)
2553 {
2554 return 0;
2555 }
2556 else if (rule_len == 1)
2557 {
2558 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2559 }
2560
2561 return 1;
2562 }
2563
2564 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2565 {
2566 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2567 {
2568 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);
2569 }
2570 else if (data.attack_kern == ATTACK_KERN_COMBI)
2571 {
2572 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);
2573 }
2574 else if (data.attack_kern == ATTACK_KERN_BF)
2575 {
2576 const uint64_t off = device_param->words_off;
2577
2578 device_param->kernel_params_mp_l_buf64[3] = off;
2579
2580 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2581 }
2582 }
2583
2584 static void run_cracker (hc_device_param_t *device_param, const uint pw_cnt, const uint pws_cnt)
2585 {
2586 const uint kernel_loops = data.kernel_loops;
2587
2588 // init speed timer
2589
2590 uint speed_pos = device_param->speed_pos;
2591
2592 #ifdef _POSIX
2593 if (device_param->timer_speed.tv_sec == 0)
2594 {
2595 hc_timer_set (&device_param->timer_speed);
2596 }
2597 #endif
2598
2599 #ifdef _WIN
2600 if (device_param->timer_speed.QuadPart == 0)
2601 {
2602 hc_timer_set (&device_param->timer_speed);
2603 }
2604 #endif
2605
2606 // find higest password length, this is for optimization stuff
2607
2608 uint highest_pw_len = 0;
2609
2610 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2611 {
2612 }
2613 else if (data.attack_kern == ATTACK_KERN_COMBI)
2614 {
2615 }
2616 else if (data.attack_kern == ATTACK_KERN_BF)
2617 {
2618 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
2619 + device_param->kernel_params_mp_l_buf32[5];
2620 }
2621
2622 // bitslice optimization stuff
2623
2624 if (data.attack_mode == ATTACK_MODE_BF)
2625 {
2626 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2627 {
2628 run_kernel_tb (device_param, pws_cnt);
2629 }
2630 }
2631
2632 // iteration type
2633
2634 uint innerloop_step = 0;
2635 uint innerloop_cnt = 0;
2636
2637 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = kernel_loops;
2638 else innerloop_step = 1;
2639
2640 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
2641 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
2642 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
2643
2644 // loop start: most outer loop = salt iteration, then innerloops (if multi)
2645
2646 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2647 {
2648 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2649
2650 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2651
2652 if (data.devices_status == STATUS_CRACKED) break;
2653 if (data.devices_status == STATUS_ABORTED) break;
2654 if (data.devices_status == STATUS_QUIT) break;
2655 if (data.devices_status == STATUS_BYPASS) break;
2656
2657 if (data.salts_shown[salt_pos] == 1) continue;
2658
2659 salt_t *salt_buf = &data.salts_buf[salt_pos];
2660
2661 device_param->kernel_params_buf32[24] = salt_pos;
2662 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
2663 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
2664
2665 FILE *combs_fp = device_param->combs_fp;
2666
2667 if (data.attack_mode == ATTACK_MODE_COMBI)
2668 {
2669 rewind (combs_fp);
2670 }
2671
2672 // innerloops
2673
2674 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
2675 {
2676 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2677
2678 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2679
2680 if (data.devices_status == STATUS_CRACKED) break;
2681 if (data.devices_status == STATUS_ABORTED) break;
2682 if (data.devices_status == STATUS_QUIT) break;
2683 if (data.devices_status == STATUS_BYPASS) break;
2684
2685 uint innerloop_left = innerloop_cnt - innerloop_pos;
2686
2687 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
2688
2689 device_param->innerloop_pos = innerloop_pos;
2690 device_param->innerloop_left = innerloop_left;
2691
2692 device_param->kernel_params_buf32[27] = innerloop_left;
2693
2694 if (innerloop_left == 0) continue;
2695
2696 // initialize amplifiers
2697
2698 if (data.attack_mode == ATTACK_MODE_COMBI)
2699 {
2700 char line_buf[BUFSIZ];
2701
2702 uint i = 0;
2703
2704 while (i < innerloop_left)
2705 {
2706 if (feof (combs_fp)) break;
2707
2708 int line_len = fgetl (combs_fp, line_buf);
2709
2710 if (line_len >= PW_MAX1) continue;
2711
2712 line_len = convert_from_hex (line_buf, line_len);
2713
2714 char *line_buf_new = line_buf;
2715
2716 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
2717 {
2718 char rule_buf_out[BLOCK_SIZE];
2719
2720 memset (rule_buf_out, 0, sizeof (rule_buf_out));
2721
2722 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
2723
2724 if (rule_len_out < 0)
2725 {
2726 data.words_progress_rejected[salt_pos] += pw_cnt;
2727
2728 continue;
2729 }
2730
2731 line_len = rule_len_out;
2732
2733 line_buf_new = rule_buf_out;
2734 }
2735
2736 line_len = MIN (line_len, PW_DICTMAX);
2737
2738 char *ptr = (char *) device_param->combs_buf[i].i;
2739
2740 memcpy (ptr, line_buf_new, line_len);
2741
2742 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
2743
2744 if (data.opts_type & OPTS_TYPE_PT_UPPER)
2745 {
2746 uppercase (ptr, line_len);
2747 }
2748
2749 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2750 {
2751 if (data.opts_type & OPTS_TYPE_PT_ADD80)
2752 {
2753 ptr[line_len] = 0x80;
2754 }
2755
2756 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2757 {
2758 ptr[line_len] = 0x01;
2759 }
2760 }
2761
2762 device_param->combs_buf[i].pw_len = line_len;
2763
2764 i++;
2765 }
2766
2767 for (uint j = i; j < innerloop_left; j++)
2768 {
2769 device_param->combs_buf[j].i[0] = 0;
2770 device_param->combs_buf[j].i[1] = 0;
2771 device_param->combs_buf[j].i[2] = 0;
2772 device_param->combs_buf[j].i[3] = 0;
2773 device_param->combs_buf[j].i[4] = 0;
2774 device_param->combs_buf[j].i[5] = 0;
2775 device_param->combs_buf[j].i[6] = 0;
2776 device_param->combs_buf[j].i[7] = 0;
2777
2778 device_param->combs_buf[j].pw_len = 0;
2779 }
2780
2781 innerloop_left = i;
2782 }
2783 else if (data.attack_mode == ATTACK_MODE_BF)
2784 {
2785 uint64_t off = innerloop_pos;
2786
2787 device_param->kernel_params_mp_r_buf64[3] = off;
2788
2789 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
2790 }
2791 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2792 {
2793 uint64_t off = innerloop_pos;
2794
2795 device_param->kernel_params_mp_buf64[3] = off;
2796
2797 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2798 }
2799 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2800 {
2801 uint64_t off = innerloop_pos;
2802
2803 device_param->kernel_params_mp_buf64[3] = off;
2804
2805 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2806 }
2807
2808 // copy amplifiers
2809
2810 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2811 {
2812 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);
2813 }
2814 else if (data.attack_mode == ATTACK_MODE_COMBI)
2815 {
2816 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);
2817 }
2818 else if (data.attack_mode == ATTACK_MODE_BF)
2819 {
2820 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);
2821 }
2822 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2823 {
2824 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);
2825 }
2826 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2827 {
2828 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);
2829 }
2830
2831 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2832 {
2833 if (data.attack_mode == ATTACK_MODE_BF)
2834 {
2835 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2836 {
2837 const uint size_tm = 32 * sizeof (bs_word_t);
2838
2839 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2840
2841 run_kernel_tm (device_param);
2842
2843 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2844 }
2845 }
2846
2847 if (highest_pw_len < 16)
2848 {
2849 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2850 }
2851 else if (highest_pw_len < 32)
2852 {
2853 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2854 }
2855 else
2856 {
2857 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2858 }
2859 }
2860 else
2861 {
2862 run_kernel_amp (device_param, pws_cnt);
2863
2864 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2865
2866 if (data.opts_type & OPTS_TYPE_HOOK12)
2867 {
2868 run_kernel (KERN_RUN_12, device_param, pws_cnt);
2869 }
2870
2871 uint iter = salt_buf->salt_iter;
2872
2873 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
2874 {
2875 uint loop_left = iter - loop_pos;
2876
2877 loop_left = MIN (loop_left, kernel_loops);
2878
2879 device_param->kernel_params_buf32[25] = loop_pos;
2880 device_param->kernel_params_buf32[26] = loop_left;
2881
2882 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2883
2884 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2885
2886 if (data.devices_status == STATUS_CRACKED) break;
2887 if (data.devices_status == STATUS_ABORTED) break;
2888 if (data.devices_status == STATUS_QUIT) break;
2889 }
2890
2891 if (data.opts_type & OPTS_TYPE_HOOK23)
2892 {
2893 run_kernel (KERN_RUN_23, device_param, pws_cnt);
2894
2895 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2896
2897 // do something with data
2898
2899 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2900 }
2901
2902 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2903 }
2904
2905 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2906
2907 if (data.devices_status == STATUS_CRACKED) break;
2908 if (data.devices_status == STATUS_ABORTED) break;
2909 if (data.devices_status == STATUS_QUIT) break;
2910
2911 /**
2912 * result
2913 */
2914
2915 hc_thread_mutex_lock (mux_display);
2916
2917 check_cracked (device_param, salt_pos);
2918
2919 hc_thread_mutex_unlock (mux_display);
2920
2921 /**
2922 * progress
2923 */
2924
2925 uint64_t perf_sum_all = (uint64_t) pw_cnt * (uint64_t) innerloop_left;
2926
2927 hc_thread_mutex_lock (mux_counter);
2928
2929 data.words_progress_done[salt_pos] += perf_sum_all;
2930
2931 hc_thread_mutex_unlock (mux_counter);
2932
2933 /**
2934 * speed
2935 */
2936
2937 float speed_ms;
2938
2939 hc_timer_get (device_param->timer_speed, speed_ms);
2940
2941 hc_timer_set (&device_param->timer_speed);
2942
2943 hc_thread_mutex_lock (mux_display);
2944
2945 device_param->speed_cnt[speed_pos] = perf_sum_all;
2946
2947 device_param->speed_ms[speed_pos] = speed_ms;
2948
2949 device_param->speed_rec[speed_pos] = device_param->timer_speed;
2950
2951 hc_thread_mutex_unlock (mux_display);
2952
2953 speed_pos++;
2954
2955 if (speed_pos == SPEED_CACHE)
2956 {
2957 speed_pos = 0;
2958 }
2959 }
2960 }
2961
2962 device_param->speed_pos = speed_pos;
2963 }
2964
2965 static void load_segment (wl_data_t *wl_data, FILE *fd)
2966 {
2967 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
2968
2969 wl_data->pos = 0;
2970
2971 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
2972
2973 wl_data->buf[wl_data->cnt] = 0;
2974
2975 if (wl_data->cnt == 0) return;
2976
2977 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
2978
2979 while (!feof (fd))
2980 {
2981 if (wl_data->cnt == wl_data->avail)
2982 {
2983 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
2984
2985 wl_data->avail += wl_data->incr;
2986 }
2987
2988 const int c = fgetc (fd);
2989
2990 if (c == EOF) break;
2991
2992 wl_data->buf[wl_data->cnt] = (char) c;
2993
2994 wl_data->cnt++;
2995
2996 if (c == '\n') break;
2997 }
2998
2999 // ensure stream ends with a newline
3000
3001 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3002 {
3003 wl_data->cnt++;
3004
3005 wl_data->buf[wl_data->cnt - 1] = '\n';
3006 }
3007
3008 return;
3009 }
3010
3011 static void get_next_word_lm (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
3012 {
3013 char *ptr = buf;
3014
3015 for (uint32_t i = 0; i < sz; i++, ptr++)
3016 {
3017 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3018
3019 if (i == 7)
3020 {
3021 *off = i;
3022 *len = i;
3023
3024 return;
3025 }
3026
3027 if (*ptr != '\n') continue;
3028
3029 *off = i + 1;
3030
3031 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3032
3033 *len = i;
3034
3035 return;
3036 }
3037
3038 *off = sz;
3039 *len = sz;
3040 }
3041
3042 static void get_next_word_uc (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
3043 {
3044 char *ptr = buf;
3045
3046 for (uint32_t i = 0; i < sz; i++, ptr++)
3047 {
3048 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3049
3050 if (*ptr != '\n') continue;
3051
3052 *off = i + 1;
3053
3054 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3055
3056 *len = i;
3057
3058 return;
3059 }
3060
3061 *off = sz;
3062 *len = sz;
3063 }
3064
3065 static void get_next_word_std (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
3066 {
3067 char *ptr = buf;
3068
3069 for (uint32_t i = 0; i < sz; i++, ptr++)
3070 {
3071 if (*ptr != '\n') continue;
3072
3073 *off = i + 1;
3074
3075 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3076
3077 *len = i;
3078
3079 return;
3080 }
3081
3082 *off = sz;
3083 *len = sz;
3084 }
3085
3086 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3087 {
3088 while (wl_data->pos < wl_data->cnt)
3089 {
3090 uint off;
3091 uint len;
3092
3093 char *ptr = wl_data->buf + wl_data->pos;
3094
3095 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3096
3097 wl_data->pos += off;
3098
3099 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3100 {
3101 char rule_buf_out[BLOCK_SIZE];
3102
3103 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3104
3105 int rule_len_out = -1;
3106
3107 if (len < BLOCK_SIZE)
3108 {
3109 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3110 }
3111
3112 if (rule_len_out < 0)
3113 {
3114 continue;
3115 }
3116
3117 if (rule_len_out > PW_MAX)
3118 {
3119 continue;
3120 }
3121 }
3122 else
3123 {
3124 if (len > PW_MAX)
3125 {
3126 continue;
3127 }
3128 }
3129
3130 *out_buf = ptr;
3131 *out_len = len;
3132
3133 return;
3134 }
3135
3136 if (feof (fd))
3137 {
3138 fprintf (stderr, "bug!!\n");
3139
3140 return;
3141 }
3142
3143 load_segment (wl_data, fd);
3144
3145 get_next_word (wl_data, fd, out_buf, out_len);
3146 }
3147
3148 #ifdef _POSIX
3149 static uint64_t count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3150 #endif
3151
3152 #ifdef _WIN
3153 static uint64_t count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3154 #endif
3155 {
3156 hc_signal (NULL);
3157
3158 dictstat_t d;
3159
3160 d.cnt = 0;
3161
3162 #ifdef _POSIX
3163 fstat (fileno (fd), &d.stat);
3164 #endif
3165
3166 #ifdef _WIN
3167 _fstat64 (fileno (fd), &d.stat);
3168 #endif
3169
3170 d.stat.st_mode = 0;
3171 d.stat.st_nlink = 0;
3172 d.stat.st_uid = 0;
3173 d.stat.st_gid = 0;
3174 d.stat.st_rdev = 0;
3175 d.stat.st_atime = 0;
3176
3177 #ifdef _POSIX
3178 d.stat.st_blksize = 0;
3179 d.stat.st_blocks = 0;
3180 #endif
3181
3182 if (d.stat.st_size == 0) return 0;
3183
3184 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3185
3186 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3187 {
3188 if (d_cache)
3189 {
3190 uint64_t cnt = d_cache->cnt;
3191
3192 uint64_t keyspace = cnt;
3193
3194 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3195 {
3196 keyspace *= data.kernel_rules_cnt;
3197 }
3198 else if (data.attack_kern == ATTACK_KERN_COMBI)
3199 {
3200 keyspace *= data.combs_cnt;
3201 }
3202
3203 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);
3204 if (data.quiet == 0) log_info ("");
3205
3206 hc_signal (sigHandler_default);
3207
3208 return (keyspace);
3209 }
3210 }
3211
3212 time_t now = 0;
3213 time_t prev = 0;
3214
3215 uint64_t comp = 0;
3216 uint64_t cnt = 0;
3217 uint64_t cnt2 = 0;
3218
3219 while (!feof (fd))
3220 {
3221 load_segment (wl_data, fd);
3222
3223 comp += wl_data->cnt;
3224
3225 uint32_t i = 0;
3226
3227 while (i < wl_data->cnt)
3228 {
3229 uint32_t len;
3230 uint32_t off;
3231
3232 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3233
3234 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3235 {
3236 char rule_buf_out[BLOCK_SIZE];
3237
3238 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3239
3240 int rule_len_out = -1;
3241
3242 if (len < BLOCK_SIZE)
3243 {
3244 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3245 }
3246
3247 if (rule_len_out < 0)
3248 {
3249 len = PW_MAX1;
3250 }
3251 else
3252 {
3253 len = rule_len_out;
3254 }
3255 }
3256
3257 if (len < PW_MAX1)
3258 {
3259 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3260 {
3261 cnt += data.kernel_rules_cnt;
3262 }
3263 else if (data.attack_kern == ATTACK_KERN_COMBI)
3264 {
3265 cnt += data.combs_cnt;
3266 }
3267
3268 d.cnt++;
3269 }
3270
3271 i += off;
3272
3273 cnt2++;
3274 }
3275
3276 time (&now);
3277
3278 if ((now - prev) == 0) continue;
3279
3280 float percent = (float) comp / (float) d.stat.st_size;
3281
3282 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);
3283
3284 time (&prev);
3285 }
3286
3287 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);
3288 if (data.quiet == 0) log_info ("");
3289
3290 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3291
3292 hc_signal (sigHandler_default);
3293
3294 return (cnt);
3295 }
3296
3297 static void pw_transpose_to_hi1 (const pw_t *p1, pw_t *p2)
3298 {
3299 memcpy (p2->hi1, p1->hi1, 64 * sizeof (uint));
3300 }
3301
3302 static uint pw_add_to_hc1 (hc_device_param_t *device_param, const uint8_t *pw_buf, const uint pw_len)
3303 {
3304 if (data.devices_status == STATUS_BYPASS) return 0;
3305
3306 pw_cache_t *pw_cache = device_param->pw_caches + pw_len;
3307
3308 uint cache_cnt = pw_cache->cnt;
3309
3310 uint8_t *pw_hc1 = pw_cache->pw_buf.hc1[cache_cnt];
3311
3312 memcpy (pw_hc1, pw_buf, pw_len);
3313
3314 memset (pw_hc1 + pw_len, 0, 256 - pw_len);
3315
3316 uint pws_cnt = device_param->pws_cnt;
3317
3318 cache_cnt++;
3319
3320 pw_t *pw = device_param->pws_buf + pws_cnt;
3321
3322 device_param->pw_transpose (&pw_cache->pw_buf, pw);
3323
3324 pw->pw_len = pw_len;
3325
3326 pws_cnt++;
3327
3328 device_param->pws_cnt = pws_cnt;
3329 device_param->pw_cnt = pws_cnt * 1;
3330
3331 cache_cnt = 0;
3332
3333 pw_cache->cnt = cache_cnt;
3334
3335 return pws_cnt;
3336 }
3337
3338 static void *thread_monitor (void *p)
3339 {
3340 uint runtime_check = 0;
3341 uint remove_check = 0;
3342 uint status_check = 0;
3343 uint hwmon_check = 0;
3344 uint restore_check = 0;
3345
3346 uint restore_left = data.restore_timer;
3347 uint remove_left = data.remove_timer;
3348 uint status_left = data.status_timer;
3349
3350 // these variables are mainly used for fan control (AMD only)
3351
3352 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3353
3354 // temperature controller "loopback" values
3355
3356 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3357 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3358
3359 int temp_threshold = 1; // degrees celcius
3360
3361 int fan_speed_min = 15; // in percentage
3362 int fan_speed_max = 100;
3363
3364 time_t last_temp_check_time;
3365
3366 uint sleep_time = 1;
3367
3368 if (data.runtime)
3369 {
3370 runtime_check = 1;
3371 }
3372
3373 if (data.restore_timer)
3374 {
3375 restore_check = 1;
3376 }
3377
3378 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3379 {
3380 remove_check = 1;
3381 }
3382
3383 if (data.status == 1)
3384 {
3385 status_check = 1;
3386 }
3387
3388 if (data.gpu_temp_disable == 0)
3389 {
3390 time (&last_temp_check_time);
3391
3392 hwmon_check = 1;
3393 }
3394
3395 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (hwmon_check == 0) && (restore_check == 0))
3396 {
3397 return (p);
3398 }
3399
3400 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3401 {
3402 hc_sleep (sleep_time);
3403
3404 if (data.devices_status != STATUS_RUNNING) continue;
3405
3406 if (hwmon_check == 1)
3407 {
3408 hc_thread_mutex_lock (mux_adl);
3409
3410 time_t temp_check_time;
3411
3412 time (&temp_check_time);
3413
3414 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3415
3416 if (Ta == 0) Ta = 1;
3417
3418 for (uint i = 0; i < data.devices_cnt; i++)
3419 {
3420 const int temperature = hm_get_temperature_with_device_id (i);
3421
3422 if (temperature > (int) data.gpu_temp_abort)
3423 {
3424 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", i + 1);
3425
3426 if (data.devices_status != STATUS_QUIT) myabort ();
3427
3428 break;
3429 }
3430
3431 const int gpu_temp_retain = data.gpu_temp_retain;
3432
3433 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3434 {
3435 if (data.hm_device[i].fan_supported == 1)
3436 {
3437 int temp_cur = temperature;
3438
3439 int temp_diff_new = gpu_temp_retain - temp_cur;
3440
3441 temp_diff_sum[i] = temp_diff_sum[i] + temp_diff_new;
3442
3443 // calculate Ta value (time difference in seconds between the last check and this check)
3444
3445 last_temp_check_time = temp_check_time;
3446
3447 float Kp = 1.8;
3448 float Ki = 0.005;
3449 float Kd = 6;
3450
3451 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3452
3453 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);
3454
3455 if (abs (fan_diff_required) >= temp_threshold)
3456 {
3457 const int fan_speed_cur = hm_get_fanspeed_with_device_id (i);
3458
3459 int fan_speed_level = fan_speed_cur;
3460
3461 if (fan_speed_chgd[i] == 0) fan_speed_level = temp_cur;
3462
3463 int fan_speed_new = fan_speed_level - fan_diff_required;
3464
3465 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3466 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3467
3468 if (fan_speed_new != fan_speed_cur)
3469 {
3470 int freely_change_fan_speed = (fan_speed_chgd[i] == 1);
3471 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3472
3473 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3474 {
3475 hm_set_fanspeed_with_device_id_amd (i, fan_speed_new);
3476
3477 fan_speed_chgd[i] = 1;
3478 }
3479
3480 temp_diff_old[i] = temp_diff_new;
3481 }
3482 }
3483 }
3484 }
3485 }
3486
3487 hc_thread_mutex_unlock (mux_adl);
3488 }
3489
3490 if (restore_check == 1)
3491 {
3492 restore_left--;
3493
3494 if (restore_left == 0)
3495 {
3496 if (data.restore_disable == 0) cycle_restore ();
3497
3498 restore_left = data.restore_timer;
3499 }
3500 }
3501
3502 if ((runtime_check == 1) && (data.runtime_start > 0))
3503 {
3504 time_t runtime_cur;
3505
3506 time (&runtime_cur);
3507
3508 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3509
3510 if (runtime_left <= 0)
3511 {
3512 if (data.benchmark == 0)
3513 {
3514 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3515 }
3516
3517 if (data.devices_status != STATUS_QUIT) myabort ();
3518 }
3519 }
3520
3521 if (remove_check == 1)
3522 {
3523 remove_left--;
3524
3525 if (remove_left == 0)
3526 {
3527 if (data.digests_saved != data.digests_done)
3528 {
3529 data.digests_saved = data.digests_done;
3530
3531 save_hash ();
3532 }
3533
3534 remove_left = data.remove_timer;
3535 }
3536 }
3537
3538 if (status_check == 1)
3539 {
3540 status_left--;
3541
3542 if (status_left == 0)
3543 {
3544 hc_thread_mutex_lock (mux_display);
3545
3546 if (data.quiet == 0) clear_prompt ();
3547
3548 if (data.quiet == 0) log_info ("");
3549
3550 status_display ();
3551
3552 if (data.quiet == 0) log_info ("");
3553
3554 hc_thread_mutex_unlock (mux_display);
3555
3556 status_left = data.status_timer;
3557 }
3558 }
3559 }
3560
3561 myfree (fan_speed_chgd);
3562
3563 myfree (temp_diff_old);
3564 myfree (temp_diff_sum);
3565
3566 p = NULL;
3567
3568 return (p);
3569 }
3570
3571 static void *thread_outfile_remove (void *p)
3572 {
3573 // some hash-dependent constants
3574 char *outfile_dir = data.outfile_check_directory;
3575 uint dgst_size = data.dgst_size;
3576 uint isSalted = data.isSalted;
3577 uint esalt_size = data.esalt_size;
3578 uint hash_mode = data.hash_mode;
3579
3580 uint outfile_check_timer = data.outfile_check_timer;
3581
3582 char separator = data.separator;
3583
3584 // some hash-dependent functions
3585 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3586 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3587
3588 // buffers
3589 hash_t hash_buf;
3590
3591 memset (&hash_buf, 0, sizeof (hash_buf));
3592
3593 hash_buf.digest = mymalloc (dgst_size);
3594
3595 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3596
3597 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3598
3599 uint digest_buf[64];
3600
3601 outfile_data_t *out_info = NULL;
3602
3603 char **out_files = NULL;
3604
3605 time_t folder_mtime = 0;
3606
3607 int out_cnt = 0;
3608
3609 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3610
3611 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3612 {
3613 hc_sleep (1);
3614
3615 if (data.devices_status != STATUS_RUNNING) continue;
3616
3617 check_left--;
3618
3619 if (check_left == 0)
3620 {
3621 struct stat outfile_check_stat;
3622
3623 if (stat (outfile_dir, &outfile_check_stat) == 0)
3624 {
3625 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3626
3627 if (is_dir == 1)
3628 {
3629 if (outfile_check_stat.st_mtime > folder_mtime)
3630 {
3631 char **out_files_new = scan_directory (outfile_dir);
3632
3633 int out_cnt_new = count_dictionaries (out_files_new);
3634
3635 outfile_data_t *out_info_new = NULL;
3636
3637 if (out_cnt_new > 0)
3638 {
3639 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3640
3641 for (int i = 0; i < out_cnt_new; i++)
3642 {
3643 out_info_new[i].file_name = out_files_new[i];
3644
3645 // check if there are files that we have seen/checked before (and not changed)
3646
3647 for (int j = 0; j < out_cnt; j++)
3648 {
3649 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
3650 {
3651 struct stat outfile_stat;
3652
3653 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
3654 {
3655 if (outfile_stat.st_ctime == out_info[j].ctime)
3656 {
3657 out_info_new[i].ctime = out_info[j].ctime;
3658 out_info_new[i].seek = out_info[j].seek;
3659 }
3660 }
3661 }
3662 }
3663 }
3664 }
3665
3666 local_free (out_info);
3667 local_free (out_files);
3668
3669 out_files = out_files_new;
3670 out_cnt = out_cnt_new;
3671 out_info = out_info_new;
3672
3673 folder_mtime = outfile_check_stat.st_mtime;
3674 }
3675
3676 for (int j = 0; j < out_cnt; j++)
3677 {
3678 FILE *fp = fopen (out_info[j].file_name, "rb");
3679
3680 if (fp != NULL)
3681 {
3682 //hc_thread_mutex_lock (mux_display);
3683
3684 #ifdef _POSIX
3685 struct stat outfile_stat;
3686
3687 fstat (fileno (fp), &outfile_stat);
3688 #endif
3689
3690 #ifdef _WIN
3691 struct stat64 outfile_stat;
3692
3693 _fstat64 (fileno (fp), &outfile_stat);
3694 #endif
3695
3696 if (outfile_stat.st_ctime > out_info[j].ctime)
3697 {
3698 out_info[j].ctime = outfile_stat.st_ctime;
3699 out_info[j].seek = 0;
3700 }
3701
3702 fseek (fp, out_info[j].seek, SEEK_SET);
3703
3704 while (!feof (fp))
3705 {
3706 char line_buf[BUFSIZ];
3707
3708 memset (line_buf, 0, BUFSIZ);
3709
3710 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
3711
3712 if (ptr == NULL) break;
3713
3714 int line_len = strlen (line_buf);
3715
3716 if (line_len <= 0) continue;
3717
3718 int iter = MAX_CUT_TRIES;
3719
3720 for (uint i = line_len - 1; i && iter; i--, line_len--)
3721 {
3722 if (line_buf[i] != separator) continue;
3723
3724 int parser_status = PARSER_OK;
3725
3726 if ((hash_mode != 2500) && (hash_mode != 6800))
3727 {
3728 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
3729 }
3730
3731 uint found = 0;
3732
3733 if (parser_status == PARSER_OK)
3734 {
3735 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
3736 {
3737 if (data.salts_shown[salt_pos] == 1) continue;
3738
3739 salt_t *salt_buf = &data.salts_buf[salt_pos];
3740
3741 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
3742 {
3743 uint idx = salt_buf->digests_offset + digest_pos;
3744
3745 if (data.digests_shown[idx] == 1) continue;
3746
3747 uint cracked = 0;
3748
3749 if (hash_mode == 6800)
3750 {
3751 if (i == salt_buf->salt_len)
3752 {
3753 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3754 }
3755 }
3756 else if (hash_mode == 2500)
3757 {
3758 // BSSID : MAC1 : MAC2 (:plain)
3759 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
3760 {
3761 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3762
3763 if (!cracked) continue;
3764
3765 // now compare MAC1 and MAC2 too, since we have this additional info
3766 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
3767 char *mac2_pos = mac1_pos + 12 + 1;
3768
3769 wpa_t *wpas = (wpa_t *) data.esalts_buf;
3770 wpa_t *wpa = &wpas[salt_pos];
3771
3772 uint pke[25];
3773
3774 char *pke_ptr = (char *) pke;
3775
3776 for (uint i = 0; i < 25; i++)
3777 {
3778 pke[i] = byte_swap_32 (wpa->pke[i]);
3779 }
3780
3781 unsigned char mac1[6];
3782 unsigned char mac2[6];
3783
3784 memcpy (mac1, pke_ptr + 23, 6);
3785 memcpy (mac2, pke_ptr + 29, 6);
3786
3787 // compare hex string(s) vs binary MAC address(es)
3788
3789 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3790 {
3791 if (mac1[i] != (unsigned char) hex_to_char (&mac1_pos[j]))
3792 {
3793 cracked = 0;
3794 break;
3795 }
3796 }
3797
3798 // early skip ;)
3799 if (!cracked) continue;
3800
3801 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3802 {
3803 if (mac2[i] != (unsigned char) hex_to_char (&mac2_pos[j]))
3804 {
3805 cracked = 0;
3806 break;
3807 }
3808 }
3809 }
3810 }
3811 else
3812 {
3813 char *digests_buf_ptr = (char *) data.digests_buf;
3814
3815 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
3816
3817 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
3818 }
3819
3820 if (cracked == 1)
3821 {
3822 found = 1;
3823
3824 data.digests_shown[idx] = 1;
3825
3826 data.digests_done++;
3827
3828 salt_buf->digests_done++;
3829
3830 if (salt_buf->digests_done == salt_buf->digests_cnt)
3831 {
3832 data.salts_shown[salt_pos] = 1;
3833
3834 data.salts_done++;
3835
3836 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
3837 }
3838 }
3839 }
3840
3841 if (data.devices_status == STATUS_CRACKED) break;
3842 }
3843 }
3844
3845 if (found) break;
3846
3847 if (data.devices_status == STATUS_CRACKED) break;
3848
3849 iter--;
3850 }
3851
3852 if (data.devices_status == STATUS_CRACKED) break;
3853 }
3854
3855 out_info[j].seek = ftell (fp);
3856
3857 //hc_thread_mutex_unlock (mux_display);
3858
3859 fclose (fp);
3860 }
3861 }
3862 }
3863 }
3864
3865 check_left = outfile_check_timer;
3866 }
3867 }
3868
3869 if (esalt_size) local_free (hash_buf.esalt);
3870
3871 if (isSalted) local_free (hash_buf.salt);
3872
3873 local_free (hash_buf.digest);
3874
3875 local_free (out_info);
3876
3877 local_free (out_files);
3878
3879 p = NULL;
3880
3881 return (p);
3882 }
3883
3884 static uint get_work (hc_device_param_t *device_param, const uint64_t max)
3885 {
3886 hc_thread_mutex_lock (mux_dispatcher);
3887
3888 const uint64_t words_cur = data.words_cur;
3889 const uint64_t words_base = (data.limit == 0) ? data.words_base : data.limit;
3890
3891 device_param->words_off = words_cur;
3892
3893 const uint64_t words_left = words_base - words_cur;
3894
3895 if (data.kernel_blocks_all > words_left)
3896 {
3897 if (data.kernel_blocks_div == 0)
3898 {
3899 data.kernel_blocks_div = find_kernel_blocks_div (words_left, data.kernel_blocks_all);
3900 }
3901 }
3902
3903 if (data.kernel_blocks_div)
3904 {
3905 if (device_param->kernel_blocks == device_param->kernel_blocks_user)
3906 {
3907 const uint32_t kernel_blocks_new = (float) device_param->kernel_blocks * data.kernel_blocks_div;
3908 const uint32_t kernel_power_new = kernel_blocks_new;
3909
3910 if (kernel_blocks_new < device_param->kernel_blocks)
3911 {
3912 device_param->kernel_blocks = kernel_blocks_new;
3913 device_param->kernel_power = kernel_power_new;
3914 }
3915 }
3916 }
3917
3918 const uint kernel_blocks = device_param->kernel_blocks;
3919
3920 uint work = MIN (words_left, kernel_blocks);
3921
3922 work = MIN (work, max);
3923
3924 data.words_cur += work;
3925
3926 hc_thread_mutex_unlock (mux_dispatcher);
3927
3928 return work;
3929 }
3930
3931 static void *thread_calc_stdin (void *p)
3932 {
3933 hc_device_param_t *device_param = (hc_device_param_t *) p;
3934
3935 const uint attack_kern = data.attack_kern;
3936
3937 const uint kernel_blocks = device_param->kernel_blocks;
3938
3939 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3940 {
3941 hc_thread_mutex_lock (mux_dispatcher);
3942
3943 if (feof (stdin) != 0)
3944 {
3945 hc_thread_mutex_unlock (mux_dispatcher);
3946
3947 break;
3948 }
3949
3950 uint words_cur = 0;
3951
3952 while (words_cur < kernel_blocks)
3953 {
3954 char buf[BUFSIZ];
3955
3956 char *line_buf = fgets (buf, sizeof (buf), stdin);
3957
3958 if (line_buf == NULL) break;
3959
3960 uint line_len = in_superchop (line_buf);
3961
3962 line_len = convert_from_hex (line_buf, line_len);
3963
3964 // post-process rule engine
3965
3966 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3967 {
3968 char rule_buf_out[BLOCK_SIZE];
3969
3970 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3971
3972 int rule_len_out = -1;
3973
3974 if (line_len < BLOCK_SIZE)
3975 {
3976 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
3977 }
3978
3979 if (rule_len_out < 0) continue;
3980
3981 line_buf = rule_buf_out;
3982 line_len = rule_len_out;
3983 }
3984
3985 if (line_len > PW_MAX)
3986 {
3987 continue;
3988 }
3989
3990 if (attack_kern == ATTACK_KERN_STRAIGHT)
3991 {
3992 if ((line_len < data.pw_min) || (line_len > data.pw_max))
3993 {
3994 hc_thread_mutex_lock (mux_counter);
3995
3996 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3997 {
3998 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
3999 }
4000
4001 hc_thread_mutex_unlock (mux_counter);
4002
4003 continue;
4004 }
4005 }
4006 else if (attack_kern == ATTACK_KERN_COMBI)
4007 {
4008 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4009 // since we still need to combine the plains
4010
4011 if (line_len > data.pw_max)
4012 {
4013 hc_thread_mutex_lock (mux_counter);
4014
4015 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4016 {
4017 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4018 }
4019
4020 hc_thread_mutex_unlock (mux_counter);
4021
4022 continue;
4023 }
4024 }
4025
4026 device_param->pw_add (device_param, (uint8_t *) line_buf, line_len);
4027
4028 words_cur++;
4029
4030 if (data.devices_status == STATUS_CRACKED) break;
4031 if (data.devices_status == STATUS_ABORTED) break;
4032 if (data.devices_status == STATUS_QUIT) break;
4033 if (data.devices_status == STATUS_BYPASS) break;
4034 }
4035
4036 hc_thread_mutex_unlock (mux_dispatcher);
4037
4038 if (data.devices_status == STATUS_CRACKED) break;
4039 if (data.devices_status == STATUS_ABORTED) break;
4040 if (data.devices_status == STATUS_QUIT) break;
4041 if (data.devices_status == STATUS_BYPASS) break;
4042
4043 // we need 2 flushing because we have two independant caches and it can occur
4044 // that one buffer is already at threshold plus for that length also exists
4045 // more data in the 2nd buffer so it would overflow
4046
4047 // flush session 1
4048
4049 {
4050 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4051 {
4052 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4053
4054 const uint pw_cache_cnt = pw_cache->cnt;
4055
4056 if (pw_cache_cnt == 0) continue;
4057
4058 pw_cache->cnt = 0;
4059
4060 uint pws_cnt = device_param->pws_cnt;
4061
4062 pw_t *pw = device_param->pws_buf + pws_cnt;
4063
4064 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4065
4066 pw->pw_len = pw_len;
4067
4068 uint pw_cnt = device_param->pw_cnt;
4069
4070 pw_cnt += pw_cache_cnt;
4071
4072 device_param->pw_cnt = pw_cnt;
4073
4074 pws_cnt++;
4075
4076 device_param->pws_cnt = pws_cnt;
4077
4078 if (pws_cnt == device_param->kernel_power_user) break;
4079 }
4080
4081 const uint pw_cnt = device_param->pw_cnt;
4082 const uint pws_cnt = device_param->pws_cnt;
4083
4084 if (pws_cnt)
4085 {
4086 run_copy (device_param, pws_cnt);
4087
4088 run_cracker (device_param, pw_cnt, pws_cnt);
4089
4090 device_param->pw_cnt = 0;
4091 device_param->pws_cnt = 0;
4092 }
4093 }
4094
4095 // flush session 2
4096
4097 {
4098 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4099 {
4100 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4101
4102 const uint pw_cache_cnt = pw_cache->cnt;
4103
4104 if (pw_cache_cnt == 0) continue;
4105
4106 pw_cache->cnt = 0;
4107
4108 uint pws_cnt = device_param->pws_cnt;
4109
4110 pw_t *pw = device_param->pws_buf + pws_cnt;
4111
4112 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4113
4114 pw->pw_len = pw_len;
4115
4116 uint pw_cnt = device_param->pw_cnt;
4117
4118 pw_cnt += pw_cache_cnt;
4119
4120 device_param->pw_cnt = pw_cnt;
4121
4122 pws_cnt++;
4123
4124 device_param->pws_cnt = pws_cnt;
4125 }
4126
4127 const uint pw_cnt = device_param->pw_cnt;
4128 const uint pws_cnt = device_param->pws_cnt;
4129
4130 if (pws_cnt)
4131 {
4132 run_copy (device_param, pws_cnt);
4133
4134 run_cracker (device_param, pw_cnt, pws_cnt);
4135
4136 device_param->pw_cnt = 0;
4137 device_param->pws_cnt = 0;
4138 }
4139 }
4140 }
4141
4142 return NULL;
4143 }
4144
4145 static void *thread_calc (void *p)
4146 {
4147 hc_device_param_t *device_param = (hc_device_param_t *) p;
4148
4149 const uint attack_mode = data.attack_mode;
4150 const uint attack_kern = data.attack_kern;
4151
4152 if (attack_mode == ATTACK_MODE_BF)
4153 {
4154 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4155 {
4156 const uint work = get_work (device_param, -1);
4157
4158 if (work == 0) break;
4159
4160 const uint64_t words_off = device_param->words_off;
4161 const uint64_t words_fin = words_off + work;
4162
4163 const uint pw_cnt = work;
4164 const uint pws_cnt = work;
4165
4166 device_param->pw_cnt = pw_cnt;
4167 device_param->pws_cnt = pws_cnt;
4168
4169 if (pws_cnt)
4170 {
4171 run_copy (device_param, pws_cnt);
4172
4173 run_cracker (device_param, pw_cnt, pws_cnt);
4174
4175 device_param->pw_cnt = 0;
4176 device_param->pws_cnt = 0;
4177 }
4178
4179 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4180
4181 if (data.devices_status == STATUS_CRACKED) break;
4182 if (data.devices_status == STATUS_ABORTED) break;
4183 if (data.devices_status == STATUS_QUIT) break;
4184 if (data.devices_status == STATUS_BYPASS) break;
4185
4186 device_param->words_done = words_fin;
4187 }
4188 }
4189 else
4190 {
4191 const uint segment_size = data.segment_size;
4192
4193 char *dictfile = data.dictfile;
4194
4195 if (attack_mode == ATTACK_MODE_COMBI)
4196 {
4197 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4198 {
4199 dictfile = data.dictfile2;
4200 }
4201 }
4202
4203 FILE *fd = fopen (dictfile, "rb");
4204
4205 if (fd == NULL)
4206 {
4207 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4208
4209 return NULL;
4210 }
4211
4212 if (attack_mode == ATTACK_MODE_COMBI)
4213 {
4214 const uint combs_mode = data.combs_mode;
4215
4216 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4217 {
4218 const char *dictfilec = data.dictfile2;
4219
4220 FILE *combs_fp = fopen (dictfilec, "rb");
4221
4222 if (combs_fp == NULL)
4223 {
4224 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4225
4226 fclose (fd);
4227
4228 return NULL;
4229 }
4230
4231 device_param->combs_fp = combs_fp;
4232 }
4233 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4234 {
4235 const char *dictfilec = data.dictfile;
4236
4237 FILE *combs_fp = fopen (dictfilec, "rb");
4238
4239 if (combs_fp == NULL)
4240 {
4241 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4242
4243 fclose (fd);
4244
4245 return NULL;
4246 }
4247
4248 device_param->combs_fp = combs_fp;
4249 }
4250 }
4251
4252 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4253
4254 wl_data->buf = (char *) mymalloc (segment_size);
4255 wl_data->avail = segment_size;
4256 wl_data->incr = segment_size;
4257 wl_data->cnt = 0;
4258 wl_data->pos = 0;
4259
4260 uint64_t words_cur = 0;
4261
4262 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4263 {
4264 uint64_t words_off = 0;
4265 uint64_t words_fin = 0;
4266
4267 uint64_t max = -1;
4268
4269 while (max)
4270 {
4271 const uint work = get_work (device_param, max);
4272
4273 if (work == 0) break;
4274
4275 words_off = device_param->words_off;
4276 words_fin = words_off + work;
4277
4278 char *line_buf;
4279 uint line_len;
4280
4281 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4282
4283 max = 0;
4284
4285 for ( ; words_cur < words_fin; words_cur++)
4286 {
4287 get_next_word (wl_data, fd, &line_buf, &line_len);
4288
4289 line_len = convert_from_hex (line_buf, line_len);
4290
4291 // post-process rule engine
4292
4293 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4294 {
4295 char rule_buf_out[BLOCK_SIZE];
4296
4297 memset (rule_buf_out, 0, sizeof (rule_buf_out));
4298
4299 int rule_len_out = -1;
4300
4301 if (line_len < BLOCK_SIZE)
4302 {
4303 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4304 }
4305
4306 if (rule_len_out < 0) continue;
4307
4308 line_buf = rule_buf_out;
4309 line_len = rule_len_out;
4310 }
4311
4312 if (attack_kern == ATTACK_KERN_STRAIGHT)
4313 {
4314 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4315 {
4316 max++;
4317
4318 hc_thread_mutex_lock (mux_counter);
4319
4320 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4321 {
4322 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4323 }
4324
4325 hc_thread_mutex_unlock (mux_counter);
4326
4327 continue;
4328 }
4329 }
4330 else if (attack_kern == ATTACK_KERN_COMBI)
4331 {
4332 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4333 // since we still need to combine the plains
4334
4335 if (line_len > data.pw_max)
4336 {
4337 max++;
4338
4339 hc_thread_mutex_lock (mux_counter);
4340
4341 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4342 {
4343 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4344 }
4345
4346 hc_thread_mutex_unlock (mux_counter);
4347
4348 continue;
4349 }
4350 }
4351
4352 device_param->pw_add (device_param, (uint8_t *) line_buf, line_len);
4353
4354 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4355
4356 if (data.devices_status == STATUS_CRACKED) break;
4357 if (data.devices_status == STATUS_ABORTED) break;
4358 if (data.devices_status == STATUS_QUIT) break;
4359 if (data.devices_status == STATUS_BYPASS) break;
4360 }
4361
4362 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4363
4364 if (data.devices_status == STATUS_CRACKED) break;
4365 if (data.devices_status == STATUS_ABORTED) break;
4366 if (data.devices_status == STATUS_QUIT) break;
4367 if (data.devices_status == STATUS_BYPASS) break;
4368 }
4369
4370 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4371
4372 if (data.devices_status == STATUS_CRACKED) break;
4373 if (data.devices_status == STATUS_ABORTED) break;
4374 if (data.devices_status == STATUS_QUIT) break;
4375 if (data.devices_status == STATUS_BYPASS) break;
4376
4377 // we need 2 flushing because we have two independant caches and it can occur
4378 // that one buffer is already at threshold plus for that length also exists
4379 // more data in the 2nd buffer so it would overflow
4380
4381 //
4382 // flush session 1
4383 //
4384
4385 {
4386 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4387 {
4388 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4389
4390 const uint pw_cache_cnt = pw_cache->cnt;
4391
4392 if (pw_cache_cnt == 0) continue;
4393
4394 pw_cache->cnt = 0;
4395
4396 uint pws_cnt = device_param->pws_cnt;
4397
4398 pw_t *pw = device_param->pws_buf + pws_cnt;
4399
4400 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4401
4402 pw->pw_len = pw_len;
4403
4404 uint pw_cnt = device_param->pw_cnt;
4405
4406 pw_cnt += pw_cache_cnt;
4407
4408 device_param->pw_cnt = pw_cnt;
4409
4410 pws_cnt++;
4411
4412 device_param->pws_cnt = pws_cnt;
4413
4414 if (pws_cnt == device_param->kernel_power_user) break;
4415 }
4416
4417 const uint pw_cnt = device_param->pw_cnt;
4418 const uint pws_cnt = device_param->pws_cnt;
4419
4420 if (pws_cnt)
4421 {
4422 run_copy (device_param, pws_cnt);
4423
4424 run_cracker (device_param, pw_cnt, pws_cnt);
4425
4426 device_param->pw_cnt = 0;
4427 device_param->pws_cnt = 0;
4428 }
4429
4430 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4431
4432 if (data.devices_status == STATUS_CRACKED) break;
4433 if (data.devices_status == STATUS_ABORTED) break;
4434 if (data.devices_status == STATUS_QUIT) break;
4435 if (data.devices_status == STATUS_BYPASS) break;
4436 }
4437
4438 //
4439 // flush session 2
4440 //
4441
4442 {
4443 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4444 {
4445 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4446
4447 const uint pw_cache_cnt = pw_cache->cnt;
4448
4449 if (pw_cache_cnt == 0) continue;
4450
4451 pw_cache->cnt = 0;
4452
4453 uint pws_cnt = device_param->pws_cnt;
4454
4455 pw_t *pw = device_param->pws_buf + pws_cnt;
4456
4457 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4458
4459 pw->pw_len = pw_len;
4460
4461 uint pw_cnt = device_param->pw_cnt;
4462
4463 pw_cnt += pw_cache_cnt;
4464
4465 device_param->pw_cnt = pw_cnt;
4466
4467 pws_cnt++;
4468
4469 device_param->pws_cnt = pws_cnt;
4470 }
4471
4472 const uint pw_cnt = device_param->pw_cnt;
4473 const uint pws_cnt = device_param->pws_cnt;
4474
4475 if (pws_cnt)
4476 {
4477 run_copy (device_param, pws_cnt);
4478
4479 run_cracker (device_param, pw_cnt, pws_cnt);
4480
4481 device_param->pw_cnt = 0;
4482 device_param->pws_cnt = 0;
4483 }
4484
4485 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4486
4487 if (data.devices_status == STATUS_CRACKED) break;
4488 if (data.devices_status == STATUS_ABORTED) break;
4489 if (data.devices_status == STATUS_QUIT) break;
4490 if (data.devices_status == STATUS_BYPASS) break;
4491 }
4492
4493 if (words_fin == 0) break;
4494
4495 device_param->words_done = words_fin;
4496 }
4497
4498 if (attack_mode == ATTACK_MODE_COMBI)
4499 {
4500 fclose (device_param->combs_fp);
4501 }
4502
4503 free (wl_data->buf);
4504 free (wl_data);
4505
4506 fclose (fd);
4507 }
4508
4509 return NULL;
4510 }
4511
4512 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos, const uint kernel_loops)
4513 {
4514 salt_t *salt_buf = &data.salts_buf[salt_pos];
4515
4516 device_param->kernel_params_buf32[24] = salt_pos;
4517 device_param->kernel_params_buf32[27] = 1;
4518 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4519 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4520 device_param->kernel_params_buf32[30] = 0;
4521 device_param->kernel_params_buf32[31] = 1;
4522
4523 char *dictfile_old = data.dictfile;
4524 char *dictfile2_old = data.dictfile2;
4525 char *mask_old = data.mask;
4526
4527 const char *weak_hash_check = "weak-hash-check";
4528
4529 data.dictfile = (char *) weak_hash_check;
4530 data.dictfile2 = (char *) weak_hash_check;
4531 data.mask = (char *) weak_hash_check;
4532
4533 /**
4534 * run the kernel
4535 */
4536
4537 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4538 {
4539 run_kernel (KERN_RUN_1, device_param, 1);
4540 }
4541 else
4542 {
4543 run_kernel (KERN_RUN_1, device_param, 1);
4544
4545 const uint iter = salt_buf->salt_iter;
4546
4547 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
4548 {
4549 uint loop_left = iter - loop_pos;
4550
4551 loop_left = MIN (loop_left, kernel_loops);
4552
4553 device_param->kernel_params_buf32[25] = loop_pos;
4554 device_param->kernel_params_buf32[26] = loop_left;
4555
4556 run_kernel (KERN_RUN_2, device_param, 1);
4557 }
4558
4559 run_kernel (KERN_RUN_3, device_param, 1);
4560 }
4561
4562 /**
4563 * result
4564 */
4565
4566 check_cracked (device_param, salt_pos);
4567
4568 /**
4569 * cleanup
4570 */
4571
4572 device_param->kernel_params_buf32[24] = 0;
4573 device_param->kernel_params_buf32[25] = 0;
4574 device_param->kernel_params_buf32[26] = 0;
4575 device_param->kernel_params_buf32[27] = 0;
4576 device_param->kernel_params_buf32[28] = 0;
4577 device_param->kernel_params_buf32[29] = 0;
4578 device_param->kernel_params_buf32[30] = 0;
4579 device_param->kernel_params_buf32[31] = 0;
4580
4581 data.dictfile = dictfile_old;
4582 data.dictfile2 = dictfile2_old;
4583 data.mask = mask_old;
4584 }
4585
4586 // hlfmt hashcat
4587
4588 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4589 {
4590 if (data.username == 0)
4591 {
4592 *hashbuf_pos = line_buf;
4593 *hashbuf_len = line_len;
4594 }
4595 else
4596 {
4597 char *pos = line_buf;
4598 int len = line_len;
4599
4600 for (int i = 0; i < line_len; i++, pos++, len--)
4601 {
4602 if (line_buf[i] == data.separator)
4603 {
4604 pos++;
4605
4606 len--;
4607
4608 break;
4609 }
4610 }
4611
4612 *hashbuf_pos = pos;
4613 *hashbuf_len = len;
4614 }
4615 }
4616
4617 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4618 {
4619 char *pos = NULL;
4620 int len = 0;
4621
4622 int sep_cnt = 0;
4623
4624 for (int i = 0; i < line_len; i++)
4625 {
4626 if (line_buf[i] == data.separator)
4627 {
4628 sep_cnt++;
4629
4630 continue;
4631 }
4632
4633 if (sep_cnt == 0)
4634 {
4635 if (pos == NULL) pos = line_buf + i;
4636
4637 len++;
4638 }
4639 }
4640
4641 *userbuf_pos = pos;
4642 *userbuf_len = len;
4643 }
4644
4645 // hlfmt pwdump
4646
4647 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
4648 {
4649 int sep_cnt = 0;
4650
4651 int sep2_len = 0;
4652 int sep3_len = 0;
4653
4654 for (int i = 0; i < line_len; i++)
4655 {
4656 if (line_buf[i] == ':')
4657 {
4658 sep_cnt++;
4659
4660 continue;
4661 }
4662
4663 if (sep_cnt == 2) sep2_len++;
4664 if (sep_cnt == 3) sep3_len++;
4665 }
4666
4667 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4668
4669 return 0;
4670 }
4671
4672 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4673 {
4674 char *pos = NULL;
4675 int len = 0;
4676
4677 int sep_cnt = 0;
4678
4679 for (int i = 0; i < line_len; i++)
4680 {
4681 if (line_buf[i] == ':')
4682 {
4683 sep_cnt++;
4684
4685 continue;
4686 }
4687
4688 if (data.hash_mode == 1000)
4689 {
4690 if (sep_cnt == 3)
4691 {
4692 if (pos == NULL) pos = line_buf + i;
4693
4694 len++;
4695 }
4696 }
4697 else if (data.hash_mode == 3000)
4698 {
4699 if (sep_cnt == 2)
4700 {
4701 if (pos == NULL) pos = line_buf + i;
4702
4703 len++;
4704 }
4705 }
4706 }
4707
4708 *hashbuf_pos = pos;
4709 *hashbuf_len = len;
4710 }
4711
4712 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4713 {
4714 char *pos = NULL;
4715 int len = 0;
4716
4717 int sep_cnt = 0;
4718
4719 for (int i = 0; i < line_len; i++)
4720 {
4721 if (line_buf[i] == ':')
4722 {
4723 sep_cnt++;
4724
4725 continue;
4726 }
4727
4728 if (sep_cnt == 0)
4729 {
4730 if (pos == NULL) pos = line_buf + i;
4731
4732 len++;
4733 }
4734 }
4735
4736 *userbuf_pos = pos;
4737 *userbuf_len = len;
4738 }
4739
4740 // hlfmt passwd
4741
4742 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
4743 {
4744 int sep_cnt = 0;
4745
4746 char sep5_first = 0;
4747 char sep6_first = 0;
4748
4749 for (int i = 0; i < line_len; i++)
4750 {
4751 if (line_buf[i] == ':')
4752 {
4753 sep_cnt++;
4754
4755 continue;
4756 }
4757
4758 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
4759 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
4760 }
4761
4762 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
4763
4764 return 0;
4765 }
4766
4767 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4768 {
4769 char *pos = NULL;
4770 int len = 0;
4771
4772 int sep_cnt = 0;
4773
4774 for (int i = 0; i < line_len; i++)
4775 {
4776 if (line_buf[i] == ':')
4777 {
4778 sep_cnt++;
4779
4780 continue;
4781 }
4782
4783 if (sep_cnt == 1)
4784 {
4785 if (pos == NULL) pos = line_buf + i;
4786
4787 len++;
4788 }
4789 }
4790
4791 *hashbuf_pos = pos;
4792 *hashbuf_len = len;
4793 }
4794
4795 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4796 {
4797 char *pos = NULL;
4798 int len = 0;
4799
4800 int sep_cnt = 0;
4801
4802 for (int i = 0; i < line_len; i++)
4803 {
4804 if (line_buf[i] == ':')
4805 {
4806 sep_cnt++;
4807
4808 continue;
4809 }
4810
4811 if (sep_cnt == 0)
4812 {
4813 if (pos == NULL) pos = line_buf + i;
4814
4815 len++;
4816 }
4817 }
4818
4819 *userbuf_pos = pos;
4820 *userbuf_len = len;
4821 }
4822
4823 // hlfmt shadow
4824
4825 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
4826 {
4827 int sep_cnt = 0;
4828
4829 for (int i = 0; i < line_len; i++)
4830 {
4831 if (line_buf[i] == ':') sep_cnt++;
4832 }
4833
4834 if (sep_cnt == 8) return 1;
4835
4836 return 0;
4837 }
4838
4839 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4840 {
4841 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
4842 }
4843
4844 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4845 {
4846 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
4847 }
4848
4849 // hlfmt main
4850
4851 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4852 {
4853 switch (hashfile_format)
4854 {
4855 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4856 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4857 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4858 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4859 }
4860 }
4861
4862 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4863 {
4864 switch (hashfile_format)
4865 {
4866 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
4867 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
4868 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
4869 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
4870 }
4871 }
4872
4873 static uint hlfmt_detect (FILE *fp, uint max_check)
4874 {
4875 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
4876
4877 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
4878 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
4879
4880 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
4881
4882 uint num_check = 0;
4883
4884 while (!feof (fp))
4885 {
4886 char line_buf[BUFSIZ];
4887
4888 int line_len = fgetl (fp, line_buf);
4889
4890 if (line_len == 0) continue;
4891
4892 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
4893 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
4894 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
4895
4896 if (num_check == max_check) break;
4897
4898 num_check++;
4899 }
4900
4901 uint hashlist_format = HLFMT_HASHCAT;
4902
4903 for (int i = 1; i < HLFMTS_CNT; i++)
4904 {
4905 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
4906
4907 hashlist_format = i;
4908 }
4909
4910 free (formats_cnt);
4911
4912 return hashlist_format;
4913 }
4914
4915 /**
4916 * some further helper function
4917 */
4918
4919 // wrapper around mymalloc for ADL
4920
4921 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
4922 {
4923 return mymalloc (iSize);
4924 }
4925
4926 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)
4927 {
4928 uint64_t collisions = 0;
4929
4930 const uint dgst_pos0 = data.dgst_pos0;
4931 const uint dgst_pos1 = data.dgst_pos1;
4932 const uint dgst_pos2 = data.dgst_pos2;
4933 const uint dgst_pos3 = data.dgst_pos3;
4934
4935 memset (bitmap_a, 0, bitmap_size);
4936 memset (bitmap_b, 0, bitmap_size);
4937 memset (bitmap_c, 0, bitmap_size);
4938 memset (bitmap_d, 0, bitmap_size);
4939
4940 for (uint i = 0; i < digests_cnt; i++)
4941 {
4942 uint *digest_ptr = (uint *) digests_buf_ptr;
4943
4944 digests_buf_ptr += dgst_size;
4945
4946 const uint val0 = 1 << (digest_ptr[dgst_pos0] & 0x1f);
4947 const uint val1 = 1 << (digest_ptr[dgst_pos1] & 0x1f);
4948 const uint val2 = 1 << (digest_ptr[dgst_pos2] & 0x1f);
4949 const uint val3 = 1 << (digest_ptr[dgst_pos3] & 0x1f);
4950
4951 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
4952 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
4953 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
4954 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
4955
4956 if (bitmap_a[idx0] & val0) collisions++;
4957 if (bitmap_b[idx1] & val1) collisions++;
4958 if (bitmap_c[idx2] & val2) collisions++;
4959 if (bitmap_d[idx3] & val3) collisions++;
4960
4961 bitmap_a[idx0] |= val0;
4962 bitmap_b[idx1] |= val1;
4963 bitmap_c[idx2] |= val2;
4964 bitmap_d[idx3] |= val3;
4965
4966 if (collisions >= collisions_max) return 0x7fffffff;
4967 }
4968
4969 return collisions;
4970 }
4971
4972 /**
4973 * main
4974 */
4975
4976 int main (int argc, char **argv)
4977 {
4978 /**
4979 * To help users a bit
4980 */
4981
4982 char *compute = getenv ("COMPUTE");
4983
4984 if (compute)
4985 {
4986 char display[100];
4987
4988 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
4989
4990 putenv (display);
4991 }
4992 else
4993 {
4994 if (getenv ("DISPLAY") == NULL)
4995 putenv ((char *) "DISPLAY=:0");
4996 }
4997
4998 /*
4999 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5000 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5001
5002 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5003 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5004 */
5005
5006 /**
5007 * Real init
5008 */
5009
5010 memset (&data, 0, sizeof (hc_global_data_t));
5011
5012 time_t proc_start;
5013
5014 time (&proc_start);
5015
5016 data.proc_start = proc_start;
5017
5018 int myargc = argc;
5019 char **myargv = argv;
5020
5021 hc_thread_mutex_init (mux_dispatcher);
5022 hc_thread_mutex_init (mux_counter);
5023 hc_thread_mutex_init (mux_display);
5024 hc_thread_mutex_init (mux_adl);
5025
5026 /**
5027 * commandline parameters
5028 */
5029
5030 uint usage = USAGE;
5031 uint version = VERSION;
5032 uint quiet = QUIET;
5033 uint benchmark = BENCHMARK;
5034 uint benchmark_mode = BENCHMARK_MODE;
5035 uint show = SHOW;
5036 uint left = LEFT;
5037 uint username = USERNAME;
5038 uint remove = REMOVE;
5039 uint remove_timer = REMOVE_TIMER;
5040 uint64_t skip = SKIP;
5041 uint64_t limit = LIMIT;
5042 uint keyspace = KEYSPACE;
5043 uint potfile_disable = POTFILE_DISABLE;
5044 uint debug_mode = DEBUG_MODE;
5045 char *debug_file = NULL;
5046 char *induction_dir = NULL;
5047 char *outfile_check_dir = NULL;
5048 uint force = FORCE;
5049 uint runtime = RUNTIME;
5050 uint hash_mode = HASH_MODE;
5051 uint attack_mode = ATTACK_MODE;
5052 uint markov_disable = MARKOV_DISABLE;
5053 uint markov_classic = MARKOV_CLASSIC;
5054 uint markov_threshold = MARKOV_THRESHOLD;
5055 char *markov_hcstat = NULL;
5056 char *outfile = NULL;
5057 uint outfile_format = OUTFILE_FORMAT;
5058 uint outfile_autohex = OUTFILE_AUTOHEX;
5059 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5060 uint restore = RESTORE;
5061 uint restore_timer = RESTORE_TIMER;
5062 uint restore_disable = RESTORE_DISABLE;
5063 uint status = STATUS;
5064 uint status_timer = STATUS_TIMER;
5065 uint status_automat = STATUS_AUTOMAT;
5066 uint loopback = LOOPBACK;
5067 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5068 char *session = NULL;
5069 uint hex_charset = HEX_CHARSET;
5070 uint hex_salt = HEX_SALT;
5071 uint hex_wordlist = HEX_WORDLIST;
5072 uint rp_gen = RP_GEN;
5073 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5074 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5075 uint rp_gen_seed = RP_GEN_SEED;
5076 char *rule_buf_l = (char *) RULE_BUF_L;
5077 char *rule_buf_r = (char *) RULE_BUF_R;
5078 uint increment = INCREMENT;
5079 uint increment_min = INCREMENT_MIN;
5080 uint increment_max = INCREMENT_MAX;
5081 char *cpu_affinity = NULL;
5082 char *opencl_devices = NULL;
5083 char *opencl_platform = NULL;
5084 char *truecrypt_keyfiles = NULL;
5085 uint workload_profile = WORKLOAD_PROFILE;
5086 uint kernel_accel = KERNEL_ACCEL;
5087 uint kernel_loops = KERNEL_LOOPS;
5088 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5089 uint gpu_temp_abort = GPU_TEMP_ABORT;
5090 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5091 uint powertune_enable = POWERTUNE_ENABLE;
5092 uint logfile_disable = LOGFILE_DISABLE;
5093 uint segment_size = SEGMENT_SIZE;
5094 uint scrypt_tmto = SCRYPT_TMTO;
5095 char separator = SEPARATOR;
5096 uint bitmap_min = BITMAP_MIN;
5097 uint bitmap_max = BITMAP_MAX;
5098 char *custom_charset_1 = NULL;
5099 char *custom_charset_2 = NULL;
5100 char *custom_charset_3 = NULL;
5101 char *custom_charset_4 = NULL;
5102
5103 #define IDX_HELP 'h'
5104 #define IDX_VERSION 'V'
5105 #define IDX_VERSION_LOWER 'v'
5106 #define IDX_QUIET 0xff02
5107 #define IDX_SHOW 0xff03
5108 #define IDX_LEFT 0xff04
5109 #define IDX_REMOVE 0xff05
5110 #define IDX_REMOVE_TIMER 0xff37
5111 #define IDX_SKIP 's'
5112 #define IDX_LIMIT 'l'
5113 #define IDX_KEYSPACE 0xff35
5114 #define IDX_POTFILE_DISABLE 0xff06
5115 #define IDX_DEBUG_MODE 0xff43
5116 #define IDX_DEBUG_FILE 0xff44
5117 #define IDX_INDUCTION_DIR 0xff46
5118 #define IDX_OUTFILE_CHECK_DIR 0xff47
5119 #define IDX_USERNAME 0xff07
5120 #define IDX_FORCE 0xff08
5121 #define IDX_RUNTIME 0xff09
5122 #define IDX_BENCHMARK 'b'
5123 #define IDX_BENCHMARK_MODE 0xff32
5124 #define IDX_HASH_MODE 'm'
5125 #define IDX_ATTACK_MODE 'a'
5126 #define IDX_RP_FILE 'r'
5127 #define IDX_RP_GEN 'g'
5128 #define IDX_RP_GEN_FUNC_MIN 0xff10
5129 #define IDX_RP_GEN_FUNC_MAX 0xff11
5130 #define IDX_RP_GEN_SEED 0xff34
5131 #define IDX_RULE_BUF_L 'j'
5132 #define IDX_RULE_BUF_R 'k'
5133 #define IDX_INCREMENT 'i'
5134 #define IDX_INCREMENT_MIN 0xff12
5135 #define IDX_INCREMENT_MAX 0xff13
5136 #define IDX_OUTFILE 'o'
5137 #define IDX_OUTFILE_FORMAT 0xff14
5138 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5139 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5140 #define IDX_RESTORE 0xff15
5141 #define IDX_RESTORE_DISABLE 0xff27
5142 #define IDX_STATUS 0xff17
5143 #define IDX_STATUS_TIMER 0xff18
5144 #define IDX_STATUS_AUTOMAT 0xff50
5145 #define IDX_LOOPBACK 0xff38
5146 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5147 #define IDX_SESSION 0xff19
5148 #define IDX_HEX_CHARSET 0xff20
5149 #define IDX_HEX_SALT 0xff21
5150 #define IDX_HEX_WORDLIST 0xff40
5151 #define IDX_MARKOV_DISABLE 0xff22
5152 #define IDX_MARKOV_CLASSIC 0xff23
5153 #define IDX_MARKOV_THRESHOLD 't'
5154 #define IDX_MARKOV_HCSTAT 0xff24
5155 #define IDX_CPU_AFFINITY 0xff25
5156 #define IDX_OPENCL_DEVICES 'd'
5157 #define IDX_OPENCL_PLATFORM 0xff72
5158 #define IDX_WORKLOAD_PROFILE 'w'
5159 #define IDX_KERNEL_ACCEL 'n'
5160 #define IDX_KERNEL_LOOPS 'u'
5161 #define IDX_GPU_TEMP_DISABLE 0xff29
5162 #define IDX_GPU_TEMP_ABORT 0xff30
5163 #define IDX_GPU_TEMP_RETAIN 0xff31
5164 #define IDX_POWERTUNE_ENABLE 0xff41
5165 #define IDX_LOGFILE_DISABLE 0xff51
5166 #define IDX_TRUECRYPT_KEYFILES 0xff52
5167 #define IDX_SCRYPT_TMTO 0xff61
5168 #define IDX_SEGMENT_SIZE 'c'
5169 #define IDX_SEPARATOR 'p'
5170 #define IDX_BITMAP_MIN 0xff70
5171 #define IDX_BITMAP_MAX 0xff71
5172 #define IDX_CUSTOM_CHARSET_1 '1'
5173 #define IDX_CUSTOM_CHARSET_2 '2'
5174 #define IDX_CUSTOM_CHARSET_3 '3'
5175 #define IDX_CUSTOM_CHARSET_4 '4'
5176
5177 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5178
5179 struct option long_options[] =
5180 {
5181 {"help", no_argument, 0, IDX_HELP},
5182 {"version", no_argument, 0, IDX_VERSION},
5183 {"quiet", no_argument, 0, IDX_QUIET},
5184 {"show", no_argument, 0, IDX_SHOW},
5185 {"left", no_argument, 0, IDX_LEFT},
5186 {"username", no_argument, 0, IDX_USERNAME},
5187 {"remove", no_argument, 0, IDX_REMOVE},
5188 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5189 {"skip", required_argument, 0, IDX_SKIP},
5190 {"limit", required_argument, 0, IDX_LIMIT},
5191 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5192 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5193 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5194 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5195 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5196 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5197 {"force", no_argument, 0, IDX_FORCE},
5198 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5199 {"benchmark-mode", required_argument, 0, IDX_BENCHMARK_MODE},
5200 {"restore", no_argument, 0, IDX_RESTORE},
5201 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5202 {"status", no_argument, 0, IDX_STATUS},
5203 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5204 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5205 {"loopback", no_argument, 0, IDX_LOOPBACK},
5206 {"weak-hash-threshold",
5207 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5208 {"session", required_argument, 0, IDX_SESSION},
5209 {"runtime", required_argument, 0, IDX_RUNTIME},
5210 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5211 {"generate-rules-func-min",
5212 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5213 {"generate-rules-func-max",
5214 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5215 {"generate-rules-seed",
5216 required_argument, 0, IDX_RP_GEN_SEED},
5217 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5218 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5219 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5220 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5221 {"rules-file", required_argument, 0, IDX_RP_FILE},
5222 {"outfile", required_argument, 0, IDX_OUTFILE},
5223 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5224 {"outfile-autohex-disable",
5225 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5226 {"outfile-check-timer",
5227 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5228 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5229 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5230 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5231 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5232 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5233 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5234 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5235 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5236 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5237 {"opencl-platform", required_argument, 0, IDX_OPENCL_PLATFORM},
5238 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5239 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5240 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5241 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5242 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5243 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5244 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5245 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5246 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5247 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5248 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5249 // deprecated
5250 {"seperator", required_argument, 0, IDX_SEPARATOR},
5251 {"separator", required_argument, 0, IDX_SEPARATOR},
5252 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5253 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5254 {"increment", no_argument, 0, IDX_INCREMENT},
5255 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5256 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5257 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5258 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5259 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5260 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5261
5262 {0, 0, 0, 0}
5263 };
5264
5265 uint rp_files_cnt = 0;
5266
5267 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5268
5269 int option_index;
5270 int c;
5271
5272 optind = 1;
5273 optopt = 0;
5274 option_index = 0;
5275
5276 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5277 {
5278 switch (c)
5279 {
5280 case IDX_HELP: usage = 1; break;
5281 case IDX_VERSION:
5282 case IDX_VERSION_LOWER: version = 1; break;
5283 case IDX_RESTORE: restore = 1; break;
5284 case IDX_SESSION: session = optarg; break;
5285 case IDX_SHOW: show = 1; break;
5286 case IDX_LEFT: left = 1; break;
5287 case '?': return (-1);
5288 }
5289 }
5290
5291 if (optopt != 0)
5292 {
5293 log_error ("ERROR: Invalid argument specified");
5294
5295 return (-1);
5296 }
5297
5298 /**
5299 * exit functions
5300 */
5301
5302 if (version)
5303 {
5304 log_info (VERSION_TXT);
5305
5306 return (0);
5307 }
5308
5309 if (usage)
5310 {
5311 usage_big_print (PROGNAME);
5312
5313 return (0);
5314 }
5315
5316 /**
5317 * session needs to be set, always!
5318 */
5319
5320 if (session == NULL) session = (char *) PROGNAME;
5321
5322 /**
5323 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5324 */
5325
5326 char *exec_path = get_exec_path ();
5327
5328 #ifdef LINUX
5329
5330 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5331 char *resolved_exec_path = realpath (exec_path, NULL);
5332
5333 char *install_dir = get_install_dir (resolved_exec_path);
5334 char *profile_dir = NULL;
5335 char *session_dir = NULL;
5336 char *shared_dir = NULL;
5337
5338 if (strcmp (install_dir, resolved_install_folder) == 0)
5339 {
5340 struct passwd *pw = getpwuid (getuid ());
5341
5342 const char *homedir = pw->pw_dir;
5343
5344 profile_dir = get_profile_dir (homedir);
5345 session_dir = get_session_dir (profile_dir);
5346 shared_dir = strdup (SHARED_FOLDER);
5347
5348 mkdir (profile_dir, 0700);
5349 mkdir (session_dir, 0700);
5350 }
5351 else
5352 {
5353 profile_dir = install_dir;
5354 session_dir = install_dir;
5355 shared_dir = install_dir;
5356 }
5357
5358 myfree (resolved_install_folder);
5359 myfree (resolved_exec_path);
5360
5361 #else
5362
5363 char *install_dir = get_install_dir (exec_path);
5364 char *profile_dir = install_dir;
5365 char *session_dir = install_dir;
5366 char *shared_dir = install_dir;
5367
5368 #endif
5369
5370 data.install_dir = install_dir;
5371 data.profile_dir = profile_dir;
5372 data.session_dir = session_dir;
5373 data.shared_dir = shared_dir;
5374
5375 myfree (exec_path);
5376
5377 /**
5378 * session
5379 */
5380
5381 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5382
5383 data.session = session;
5384
5385 char *eff_restore_file = (char *) mymalloc (session_size);
5386 char *new_restore_file = (char *) mymalloc (session_size);
5387
5388 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5389 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5390
5391 data.eff_restore_file = eff_restore_file;
5392 data.new_restore_file = new_restore_file;
5393
5394 if (((show == 1) || (left == 1)) && (restore == 1))
5395 {
5396 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5397 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5398
5399 return (-1);
5400 }
5401
5402 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5403 if ((show == 1) || (left == 1))
5404 {
5405 restore_disable = 1;
5406
5407 restore = 0;
5408 }
5409
5410 data.restore_disable = restore_disable;
5411
5412 restore_data_t *rd = init_restore (argc, argv);
5413
5414 data.rd = rd;
5415
5416 /**
5417 * restore file
5418 */
5419
5420 if (restore == 1)
5421 {
5422 read_restore (eff_restore_file, rd);
5423
5424 if (rd->version_bin < RESTORE_MIN)
5425 {
5426 log_error ("ERROR: Incompatible restore-file version");
5427
5428 return (-1);
5429 }
5430
5431 myargc = rd->argc;
5432 myargv = rd->argv;
5433
5434 #ifdef _POSIX
5435 rd->pid = getpid ();
5436 #elif _WIN
5437 rd->pid = GetCurrentProcessId ();
5438 #endif
5439 }
5440
5441 uint hash_mode_chgd = 0;
5442 uint runtime_chgd = 0;
5443 uint kernel_loops_chgd = 0;
5444 uint kernel_accel_chgd = 0;
5445 uint attack_mode_chgd = 0;
5446 uint outfile_format_chgd = 0;
5447 uint rp_gen_seed_chgd = 0;
5448 uint remove_timer_chgd = 0;
5449 uint increment_min_chgd = 0;
5450 uint increment_max_chgd = 0;
5451 uint gpu_temp_abort_chgd = 0;
5452 uint gpu_temp_retain_chgd = 0;
5453
5454 optind = 1;
5455 optopt = 0;
5456 option_index = 0;
5457
5458 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5459 {
5460 switch (c)
5461 {
5462 //case IDX_HELP: usage = 1; break;
5463 //case IDX_VERSION: version = 1; break;
5464 //case IDX_RESTORE: restore = 1; break;
5465 case IDX_QUIET: quiet = 1; break;
5466 //case IDX_SHOW: show = 1; break;
5467 case IDX_SHOW: break;
5468 //case IDX_LEFT: left = 1; break;
5469 case IDX_LEFT: break;
5470 case IDX_USERNAME: username = 1; break;
5471 case IDX_REMOVE: remove = 1; break;
5472 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5473 remove_timer_chgd = 1; break;
5474 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5475 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5476 case IDX_DEBUG_FILE: debug_file = optarg; break;
5477 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5478 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5479 case IDX_FORCE: force = 1; break;
5480 case IDX_SKIP: skip = atoll (optarg); break;
5481 case IDX_LIMIT: limit = atoll (optarg); break;
5482 case IDX_KEYSPACE: keyspace = 1; break;
5483 case IDX_BENCHMARK: benchmark = 1; break;
5484 case IDX_BENCHMARK_MODE: benchmark_mode = atoi (optarg); break;
5485 case IDX_RESTORE: break;
5486 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5487 case IDX_STATUS: status = 1; break;
5488 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5489 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5490 case IDX_LOOPBACK: loopback = 1; break;
5491 case IDX_WEAK_HASH_THRESHOLD:
5492 weak_hash_threshold = atoi (optarg); break;
5493 //case IDX_SESSION: session = optarg; break;
5494 case IDX_SESSION: break;
5495 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5496 hash_mode_chgd = 1; break;
5497 case IDX_RUNTIME: runtime = atoi (optarg);
5498 runtime_chgd = 1; break;
5499 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5500 attack_mode_chgd = 1; break;
5501 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5502 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5503 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5504 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5505 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5506 rp_gen_seed_chgd = 1; break;
5507 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5508 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5509 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5510 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5511 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5512 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5513 case IDX_OUTFILE: outfile = optarg; break;
5514 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5515 outfile_format_chgd = 1; break;
5516 case IDX_OUTFILE_AUTOHEX_DISABLE:
5517 outfile_autohex = 0; break;
5518 case IDX_OUTFILE_CHECK_TIMER:
5519 outfile_check_timer = atoi (optarg); break;
5520 case IDX_HEX_CHARSET: hex_charset = 1; break;
5521 case IDX_HEX_SALT: hex_salt = 1; break;
5522 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5523 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5524 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5525 case IDX_OPENCL_PLATFORM: opencl_platform = optarg; break;
5526 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg); break;
5527 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5528 kernel_accel_chgd = 1; break;
5529 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5530 kernel_loops_chgd = 1; break;
5531 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5532 case IDX_GPU_TEMP_ABORT: gpu_temp_abort_chgd = 1;
5533 gpu_temp_abort = atoi (optarg); break;
5534 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain_chgd = 1;
5535 gpu_temp_retain = atoi (optarg); break;
5536 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5537 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5538 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5539 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5540 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5541 case IDX_SEPARATOR: separator = optarg[0]; break;
5542 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5543 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5544 case IDX_INCREMENT: increment = 1; break;
5545 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5546 increment_min_chgd = 1; break;
5547 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5548 increment_max_chgd = 1; break;
5549 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5550 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5551 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5552 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5553
5554 default:
5555 log_error ("ERROR: Invalid argument specified");
5556 return (-1);
5557 }
5558 }
5559
5560 if (optopt != 0)
5561 {
5562 log_error ("ERROR: Invalid argument specified");
5563
5564 return (-1);
5565 }
5566
5567 /**
5568 * Inform user things getting started,
5569 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5570 * - we do not need to check algorithm_pos
5571 */
5572
5573 if (quiet == 0)
5574 {
5575 if (benchmark == 1)
5576 {
5577 log_info ("%s v%.2f starting in benchmark-mode...", PROGNAME, (float) VERSION_BIN / 100);
5578
5579 log_info ("");
5580 }
5581 else if (restore == 1)
5582 {
5583 log_info ("%s v%.2f starting in restore-mode...", PROGNAME, (float) VERSION_BIN / 100);
5584
5585 log_info ("");
5586 }
5587 else
5588 {
5589 log_info ("%s v%.2f starting...", PROGNAME, (float) VERSION_BIN / 100);
5590
5591 log_info ("");
5592 }
5593 }
5594
5595 /**
5596 * sanity check
5597 */
5598
5599 if (attack_mode > 7)
5600 {
5601 log_error ("ERROR: Invalid attack-mode specified");
5602
5603 return (-1);
5604 }
5605
5606 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5607 {
5608 log_error ("ERROR: Invalid runtime specified");
5609
5610 return (-1);
5611 }
5612
5613 if (hash_mode_chgd && hash_mode > 12900) // just added to remove compiler warnings for hash_mode_chgd
5614 {
5615 log_error ("ERROR: Invalid hash-type specified");
5616
5617 return (-1);
5618 }
5619
5620 // renamed hash modes
5621
5622 if (hash_mode_chgd)
5623 {
5624 int n = -1;
5625
5626 switch (hash_mode)
5627 {
5628 case 123: n = 124;
5629 break;
5630 }
5631
5632 if (n >= 0)
5633 {
5634 log_error ("Old -m specified, use -m %d instead", n);
5635
5636 return (-1);
5637 }
5638 }
5639
5640 if (username == 1)
5641 {
5642 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5643 {
5644 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5645
5646 return (-1);
5647 }
5648 }
5649
5650 if (outfile_format > 16)
5651 {
5652 log_error ("ERROR: Invalid outfile-format specified");
5653
5654 return (-1);
5655 }
5656
5657 if (left == 1)
5658 {
5659 if (outfile_format_chgd == 1)
5660 {
5661 if (outfile_format > 1)
5662 {
5663 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5664
5665 return (-1);
5666 }
5667 }
5668 else
5669 {
5670 outfile_format = OUTFILE_FMT_HASH;
5671 }
5672 }
5673
5674 if (show == 1)
5675 {
5676 if (outfile_format_chgd == 1)
5677 {
5678 if ((outfile_format > 7) && (outfile_format < 16))
5679 {
5680 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
5681
5682 return (-1);
5683 }
5684 }
5685 }
5686
5687 if (increment_min < INCREMENT_MIN)
5688 {
5689 log_error ("ERROR: Invalid increment-min specified");
5690
5691 return (-1);
5692 }
5693
5694 if (increment_max > INCREMENT_MAX)
5695 {
5696 log_error ("ERROR: Invalid increment-max specified");
5697
5698 return (-1);
5699 }
5700
5701 if (increment_min > increment_max)
5702 {
5703 log_error ("ERROR: Invalid increment-min specified");
5704
5705 return (-1);
5706 }
5707
5708 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
5709 {
5710 log_error ("ERROR: increment is not allowed in attack-mode 0");
5711
5712 return (-1);
5713 }
5714
5715 if ((increment == 0) && (increment_min_chgd == 1))
5716 {
5717 log_error ("ERROR: increment-min is only supported together with increment switch");
5718
5719 return (-1);
5720 }
5721
5722 if ((increment == 0) && (increment_max_chgd == 1))
5723 {
5724 log_error ("ERROR: increment-max is only supported together with increment switch");
5725
5726 return (-1);
5727 }
5728
5729 if (rp_files_cnt && rp_gen)
5730 {
5731 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
5732
5733 return (-1);
5734 }
5735
5736 if (rp_files_cnt || rp_gen)
5737 {
5738 if (attack_mode != ATTACK_MODE_STRAIGHT)
5739 {
5740 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
5741
5742 return (-1);
5743 }
5744 }
5745
5746 if (rp_gen_func_min > rp_gen_func_max)
5747 {
5748 log_error ("ERROR: Invalid rp-gen-func-min specified");
5749
5750 return (-1);
5751 }
5752
5753 if (kernel_accel_chgd == 1)
5754 {
5755 if (workload_profile != WORKLOAD_PROFILE)
5756 {
5757 log_error ("ERROR: kernel-accel parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5758
5759 return (-1);
5760 }
5761
5762 if (kernel_accel < 1)
5763 {
5764 log_error ("ERROR: Invalid kernel-accel specified");
5765
5766 return (-1);
5767 }
5768
5769 if (kernel_accel > 800)
5770 {
5771 log_error ("ERROR: Invalid kernel-accel specified");
5772
5773 return (-1);
5774 }
5775 }
5776
5777 if (kernel_loops_chgd == 1)
5778 {
5779 if (workload_profile != WORKLOAD_PROFILE)
5780 {
5781 log_error ("ERROR: kernel-loops parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5782
5783 return (-1);
5784 }
5785
5786 if (kernel_loops < 1)
5787 {
5788 log_error ("ERROR: Invalid kernel-loops specified");
5789
5790 return (-1);
5791 }
5792
5793 if (kernel_loops > 1024)
5794 {
5795 log_error ("ERROR: Invalid kernel-loops specified");
5796
5797 return (-1);
5798 }
5799 }
5800
5801 if (benchmark == 1)
5802 {
5803 if (workload_profile != WORKLOAD_PROFILE)
5804 {
5805 log_error ("ERROR: Using the workload-profile in benchmark mode is not allowed");
5806
5807 return (-1);
5808 }
5809 }
5810
5811 if ((workload_profile < 1) || (workload_profile > 3))
5812 {
5813 log_error ("ERROR: workload-profile %i not available", workload_profile);
5814
5815 return (-1);
5816 }
5817
5818 if (show == 1 || left == 1)
5819 {
5820 attack_mode = ATTACK_MODE_NONE;
5821
5822 if (remove == 1)
5823 {
5824 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
5825
5826 return (-1);
5827 }
5828
5829 if (potfile_disable == 1)
5830 {
5831 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
5832
5833 return (-1);
5834 }
5835 }
5836
5837 uint attack_kern = ATTACK_KERN_NONE;
5838
5839 switch (attack_mode)
5840 {
5841 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
5842 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
5843 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
5844 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
5845 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
5846 }
5847
5848 if (benchmark == 0)
5849 {
5850 if (keyspace == 1)
5851 {
5852 int num_additional_params = 1;
5853
5854 if (attack_kern == ATTACK_KERN_COMBI)
5855 {
5856 num_additional_params = 2;
5857 }
5858
5859 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
5860
5861 if (keyspace_wordlist_specified == 0) optind--;
5862 }
5863
5864 if (attack_kern == ATTACK_KERN_NONE)
5865 {
5866 if ((optind + 1) != myargc)
5867 {
5868 usage_mini_print (myargv[0]);
5869
5870 return (-1);
5871 }
5872 }
5873 else if (attack_kern == ATTACK_KERN_STRAIGHT)
5874 {
5875 if ((optind + 1) > myargc)
5876 {
5877 usage_mini_print (myargv[0]);
5878
5879 return (-1);
5880 }
5881 }
5882 else if (attack_kern == ATTACK_KERN_COMBI)
5883 {
5884 if ((optind + 3) != myargc)
5885 {
5886 usage_mini_print (myargv[0]);
5887
5888 return (-1);
5889 }
5890 }
5891 else if (attack_kern == ATTACK_KERN_BF)
5892 {
5893 if ((optind + 1) > myargc)
5894 {
5895 usage_mini_print (myargv[0]);
5896
5897 return (-1);
5898 }
5899 }
5900 else
5901 {
5902 usage_mini_print (myargv[0]);
5903
5904 return (-1);
5905 }
5906 }
5907 else
5908 {
5909 if (myargv[optind] != 0)
5910 {
5911 log_error ("ERROR: Invalid argument for benchmark mode specified");
5912
5913 return (-1);
5914 }
5915
5916 if (attack_mode_chgd == 1)
5917 {
5918 if (attack_mode != ATTACK_MODE_BF)
5919 {
5920 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
5921
5922 return (-1);
5923 }
5924 }
5925
5926 if (benchmark_mode == 0)
5927 {
5928 // nothing to do
5929 }
5930 else if (benchmark_mode == 1)
5931 {
5932 if (kernel_accel_chgd == 1 || kernel_loops_chgd == 1)
5933 {
5934 log_error ("ERROR: Benchmark-mode 1 does not allow kernel-accel or kernel-loops changed");
5935
5936 return (-1);
5937 }
5938 }
5939 else
5940 {
5941 log_error ("ERROR: Benchmark-mode must be 0 or 1");
5942
5943 return (-1);
5944 }
5945 }
5946
5947 if (skip != 0 && limit != 0)
5948 {
5949 limit += skip;
5950 }
5951
5952 if (keyspace == 1)
5953 {
5954 if (show == 1)
5955 {
5956 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
5957
5958 return (-1);
5959 }
5960 else if (left == 1)
5961 {
5962 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
5963
5964 return (-1);
5965 }
5966
5967 potfile_disable = 1;
5968
5969 restore_disable = 1;
5970
5971 restore = 0;
5972
5973 weak_hash_threshold = 0;
5974
5975 quiet = 1;
5976 }
5977
5978 if (remove_timer_chgd == 1)
5979 {
5980 if (remove == 0)
5981 {
5982 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
5983
5984 return (-1);
5985 }
5986
5987 if (remove_timer < 1)
5988 {
5989 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
5990
5991 return (-1);
5992 }
5993 }
5994
5995 if (loopback == 1)
5996 {
5997 if (attack_mode == ATTACK_MODE_BF)
5998 {
5999 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6000
6001 return (-1);
6002 }
6003 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6004 {
6005 if ((rp_files_cnt == 0) && (rp_gen == 0))
6006 {
6007 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6008
6009 return (-1);
6010 }
6011 }
6012 }
6013
6014 if (debug_mode > 0)
6015 {
6016 if (attack_mode != ATTACK_MODE_STRAIGHT)
6017 {
6018 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6019
6020 return (-1);
6021 }
6022
6023 if ((rp_files_cnt == 0) && (rp_gen == 0))
6024 {
6025 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6026
6027 return (-1);
6028 }
6029 }
6030
6031 if (debug_mode > 4)
6032 {
6033 log_error ("ERROR: Invalid debug-mode specified");
6034
6035 return (-1);
6036 }
6037
6038 if (debug_file != NULL)
6039 {
6040 if (debug_mode < 1)
6041 {
6042 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6043
6044 return (-1);
6045 }
6046 }
6047
6048 if (induction_dir != NULL)
6049 {
6050 if (attack_mode == ATTACK_MODE_BF)
6051 {
6052 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6053
6054 return (-1);
6055 }
6056 }
6057
6058 /**
6059 * induction directory
6060 */
6061
6062 char *induction_directory = NULL;
6063
6064 if (attack_mode != ATTACK_MODE_BF)
6065 {
6066 if (induction_dir == NULL)
6067 {
6068 induction_directory = (char *) mymalloc (session_size);
6069
6070 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6071
6072 // create induction folder if it does not already exist
6073
6074 if (keyspace == 0)
6075 {
6076 if (rmdir (induction_directory) == -1)
6077 {
6078 if (errno == ENOENT)
6079 {
6080 // good, we can ignore
6081 }
6082 else if (errno == ENOTEMPTY)
6083 {
6084 char *induction_directory_mv = (char *) mymalloc (session_size);
6085
6086 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6087
6088 if (rename (induction_directory, induction_directory_mv) != 0)
6089 {
6090 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6091
6092 return (-1);
6093 }
6094 }
6095 else
6096 {
6097 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6098
6099 return (-1);
6100 }
6101 }
6102
6103 if (mkdir (induction_directory, 0700) == -1)
6104 {
6105 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6106
6107 return (-1);
6108 }
6109 }
6110 }
6111 else
6112 {
6113 induction_directory = induction_dir;
6114 }
6115 }
6116
6117 data.induction_directory = induction_directory;
6118
6119 /**
6120 * loopback
6121 */
6122
6123 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6124
6125 char *loopback_file = (char *) mymalloc (loopback_size);
6126
6127 /**
6128 * outfile-check directory
6129 */
6130
6131 char *outfile_check_directory = NULL;
6132
6133 if (outfile_check_dir == NULL)
6134 {
6135 outfile_check_directory = (char *) mymalloc (session_size);
6136
6137 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6138 }
6139 else
6140 {
6141 outfile_check_directory = outfile_check_dir;
6142 }
6143
6144 data.outfile_check_directory = outfile_check_directory;
6145
6146 if (keyspace == 0)
6147 {
6148 struct stat outfile_check_stat;
6149
6150 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6151 {
6152 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6153
6154 if (is_dir == 0)
6155 {
6156 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6157
6158 return (-1);
6159 }
6160 }
6161 else if (outfile_check_dir == NULL)
6162 {
6163 if (mkdir (outfile_check_directory, 0700) == -1)
6164 {
6165 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6166
6167 return (-1);
6168 }
6169 }
6170 }
6171
6172 /**
6173 * special other stuff
6174 */
6175
6176 if (hash_mode == 9710)
6177 {
6178 outfile_format = 5;
6179 outfile_format_chgd = 1;
6180 }
6181
6182 if (hash_mode == 9810)
6183 {
6184 outfile_format = 5;
6185 outfile_format_chgd = 1;
6186 }
6187
6188 if (hash_mode == 10410)
6189 {
6190 outfile_format = 5;
6191 outfile_format_chgd = 1;
6192 }
6193
6194 /**
6195 * store stuff
6196 */
6197
6198 data.hash_mode = hash_mode;
6199 data.restore = restore;
6200 data.restore_timer = restore_timer;
6201 data.restore_disable = restore_disable;
6202 data.status = status;
6203 data.status_timer = status_timer;
6204 data.status_automat = status_automat;
6205 data.loopback = loopback;
6206 data.runtime = runtime;
6207 data.remove = remove;
6208 data.remove_timer = remove_timer;
6209 data.debug_mode = debug_mode;
6210 data.debug_file = debug_file;
6211 data.username = username;
6212 data.quiet = quiet;
6213 data.outfile = outfile;
6214 data.outfile_format = outfile_format;
6215 data.outfile_autohex = outfile_autohex;
6216 data.hex_charset = hex_charset;
6217 data.hex_salt = hex_salt;
6218 data.hex_wordlist = hex_wordlist;
6219 data.separator = separator;
6220 data.rp_files = rp_files;
6221 data.rp_files_cnt = rp_files_cnt;
6222 data.rp_gen = rp_gen;
6223 data.rp_gen_seed = rp_gen_seed;
6224 data.force = force;
6225 data.benchmark = benchmark;
6226 data.skip = skip;
6227 data.limit = limit;
6228 data.powertune_enable = powertune_enable;
6229 data.logfile_disable = logfile_disable;
6230 data.truecrypt_keyfiles = truecrypt_keyfiles;
6231 data.scrypt_tmto = scrypt_tmto;
6232
6233 /**
6234 * cpu affinity
6235 */
6236
6237 if (cpu_affinity)
6238 {
6239 set_cpu_affinity (cpu_affinity);
6240 }
6241
6242 if (rp_gen_seed_chgd == 0)
6243 {
6244 srand (proc_start);
6245 }
6246 else
6247 {
6248 srand (rp_gen_seed);
6249 }
6250
6251 /**
6252 * logfile init
6253 */
6254
6255 if (logfile_disable == 0)
6256 {
6257 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6258
6259 char *logfile = (char *) mymalloc (logfile_size);
6260
6261 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6262
6263 data.logfile = logfile;
6264
6265 char *topid = logfile_generate_topid ();
6266
6267 data.topid = topid;
6268 }
6269
6270 // logfile_append() checks for logfile_disable internally to make it easier from here
6271
6272 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6273 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6274 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6275 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6276 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6277 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6278 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6279 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6280 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6281 #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));
6282
6283 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6284 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6285 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6286 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6287 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6288 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6289 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6290 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6291
6292 logfile_top_msg ("START");
6293
6294 logfile_top_uint (attack_mode);
6295 logfile_top_uint (attack_kern);
6296 logfile_top_uint (benchmark);
6297 logfile_top_uint (benchmark_mode);
6298 logfile_top_uint (bitmap_min);
6299 logfile_top_uint (bitmap_max);
6300 logfile_top_uint (debug_mode);
6301 logfile_top_uint (force);
6302 logfile_top_uint (kernel_accel);
6303 logfile_top_uint (kernel_loops);
6304 logfile_top_uint (gpu_temp_abort);
6305 logfile_top_uint (gpu_temp_disable);
6306 logfile_top_uint (gpu_temp_retain);
6307 logfile_top_uint (hash_mode);
6308 logfile_top_uint (hex_charset);
6309 logfile_top_uint (hex_salt);
6310 logfile_top_uint (hex_wordlist);
6311 logfile_top_uint (increment);
6312 logfile_top_uint (increment_max);
6313 logfile_top_uint (increment_min);
6314 logfile_top_uint (keyspace);
6315 logfile_top_uint (left);
6316 logfile_top_uint (logfile_disable);
6317 logfile_top_uint (loopback);
6318 logfile_top_uint (markov_classic);
6319 logfile_top_uint (markov_disable);
6320 logfile_top_uint (markov_threshold);
6321 logfile_top_uint (outfile_autohex);
6322 logfile_top_uint (outfile_check_timer);
6323 logfile_top_uint (outfile_format);
6324 logfile_top_uint (potfile_disable);
6325 logfile_top_uint (powertune_enable);
6326 logfile_top_uint (scrypt_tmto);
6327 logfile_top_uint (quiet);
6328 logfile_top_uint (remove);
6329 logfile_top_uint (remove_timer);
6330 logfile_top_uint (restore);
6331 logfile_top_uint (restore_disable);
6332 logfile_top_uint (restore_timer);
6333 logfile_top_uint (rp_gen);
6334 logfile_top_uint (rp_gen_func_max);
6335 logfile_top_uint (rp_gen_func_min);
6336 logfile_top_uint (rp_gen_seed);
6337 logfile_top_uint (runtime);
6338 logfile_top_uint (segment_size);
6339 logfile_top_uint (show);
6340 logfile_top_uint (status);
6341 logfile_top_uint (status_automat);
6342 logfile_top_uint (status_timer);
6343 logfile_top_uint (usage);
6344 logfile_top_uint (username);
6345 logfile_top_uint (version);
6346 logfile_top_uint (weak_hash_threshold);
6347 logfile_top_uint (workload_profile);
6348 logfile_top_uint64 (limit);
6349 logfile_top_uint64 (skip);
6350 logfile_top_char (separator);
6351 logfile_top_string (cpu_affinity);
6352 logfile_top_string (custom_charset_1);
6353 logfile_top_string (custom_charset_2);
6354 logfile_top_string (custom_charset_3);
6355 logfile_top_string (custom_charset_4);
6356 logfile_top_string (debug_file);
6357 logfile_top_string (opencl_devices);
6358 logfile_top_string (opencl_platform);
6359 logfile_top_string (induction_dir);
6360 logfile_top_string (markov_hcstat);
6361 logfile_top_string (outfile);
6362 logfile_top_string (outfile_check_dir);
6363 logfile_top_string (rule_buf_l);
6364 logfile_top_string (rule_buf_r);
6365 logfile_top_string (session);
6366 logfile_top_string (truecrypt_keyfiles);
6367
6368 /**
6369 * devices
6370 */
6371
6372 uint opencl_devicemask = devices_to_devicemask (opencl_devices);
6373
6374 /**
6375 * benchmark
6376 */
6377
6378 if (benchmark == 1)
6379 {
6380 /**
6381 * disable useless stuff for benchmark
6382 */
6383
6384 restore_timer = 0;
6385 status_timer = 0;
6386 restore_disable = 1;
6387 potfile_disable = 1;
6388 weak_hash_threshold = 0;
6389
6390 data.restore_timer = restore_timer;
6391 data.status_timer = status_timer;
6392 data.restore_disable = restore_disable;
6393
6394 if (benchmark_mode == 1)
6395 {
6396 markov_disable = 1;
6397 }
6398
6399 /**
6400 * force attack mode to be bruteforce
6401 */
6402
6403 attack_mode = ATTACK_MODE_BF;
6404 attack_kern = ATTACK_KERN_BF;
6405
6406 if (runtime_chgd == 0)
6407 {
6408 runtime = 4;
6409
6410 if (benchmark_mode == 1) runtime = 17;
6411
6412 data.runtime = runtime;
6413 }
6414 }
6415
6416 /**
6417 * config
6418 */
6419
6420 uint hash_type = 0;
6421 uint salt_type = 0;
6422 uint attack_exec = 0;
6423 uint opts_type = 0;
6424 uint kern_type = 0;
6425 uint dgst_size = 0;
6426 uint esalt_size = 0;
6427 uint opti_type = 0;
6428 uint dgst_pos0 = -1;
6429 uint dgst_pos1 = -1;
6430 uint dgst_pos2 = -1;
6431 uint dgst_pos3 = -1;
6432
6433 int (*parse_func) (char *, uint, hash_t *);
6434 int (*sort_by_digest) (const void *, const void *);
6435
6436 uint algorithm_pos = 0;
6437 uint algorithm_max = 1;
6438
6439 uint *algorithms = default_benchmark_algorithms;
6440
6441 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6442
6443 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6444 {
6445 /*
6446 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6447 * the following algos are skipped entirely
6448 */
6449
6450 if (algorithm_pos > 0)
6451 {
6452 local_free (rd);
6453
6454 rd = init_restore (argc, argv);
6455
6456 data.rd = rd;
6457 }
6458
6459 /**
6460 * update hash_mode in case of multihash benchmark
6461 */
6462
6463 if (benchmark == 1)
6464 {
6465 if (hash_mode_chgd == 0)
6466 {
6467 hash_mode = algorithms[algorithm_pos];
6468
6469 data.hash_mode = hash_mode;
6470 }
6471
6472 quiet = 1;
6473
6474 data.quiet = quiet;
6475 }
6476
6477 switch (hash_mode)
6478 {
6479 case 0: hash_type = HASH_TYPE_MD5;
6480 salt_type = SALT_TYPE_NONE;
6481 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6482 opts_type = OPTS_TYPE_PT_GENERATE_LE
6483 | OPTS_TYPE_PT_ADD80
6484 | OPTS_TYPE_PT_ADDBITS14;
6485 kern_type = KERN_TYPE_MD5;
6486 dgst_size = DGST_SIZE_4_4;
6487 parse_func = md5_parse_hash;
6488 sort_by_digest = sort_by_digest_4_4;
6489 opti_type = OPTI_TYPE_ZERO_BYTE
6490 | OPTI_TYPE_PRECOMPUTE_INIT
6491 | OPTI_TYPE_PRECOMPUTE_MERKLE
6492 | OPTI_TYPE_MEET_IN_MIDDLE
6493 | OPTI_TYPE_EARLY_SKIP
6494 | OPTI_TYPE_NOT_ITERATED
6495 | OPTI_TYPE_NOT_SALTED
6496 | OPTI_TYPE_RAW_HASH;
6497 dgst_pos0 = 0;
6498 dgst_pos1 = 3;
6499 dgst_pos2 = 2;
6500 dgst_pos3 = 1;
6501 break;
6502
6503 case 10: hash_type = HASH_TYPE_MD5;
6504 salt_type = SALT_TYPE_INTERN;
6505 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6506 opts_type = OPTS_TYPE_PT_GENERATE_LE
6507 | OPTS_TYPE_ST_ADD80
6508 | OPTS_TYPE_ST_ADDBITS14;
6509 kern_type = KERN_TYPE_MD5_PWSLT;
6510 dgst_size = DGST_SIZE_4_4;
6511 parse_func = md5s_parse_hash;
6512 sort_by_digest = sort_by_digest_4_4;
6513 opti_type = OPTI_TYPE_ZERO_BYTE
6514 | OPTI_TYPE_PRECOMPUTE_INIT
6515 | OPTI_TYPE_PRECOMPUTE_MERKLE
6516 | OPTI_TYPE_MEET_IN_MIDDLE
6517 | OPTI_TYPE_EARLY_SKIP
6518 | OPTI_TYPE_NOT_ITERATED
6519 | OPTI_TYPE_APPENDED_SALT
6520 | OPTI_TYPE_RAW_HASH;
6521 dgst_pos0 = 0;
6522 dgst_pos1 = 3;
6523 dgst_pos2 = 2;
6524 dgst_pos3 = 1;
6525 break;
6526
6527 case 11: hash_type = HASH_TYPE_MD5;
6528 salt_type = SALT_TYPE_INTERN;
6529 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6530 opts_type = OPTS_TYPE_PT_GENERATE_LE
6531 | OPTS_TYPE_ST_ADD80
6532 | OPTS_TYPE_ST_ADDBITS14;
6533 kern_type = KERN_TYPE_MD5_PWSLT;
6534 dgst_size = DGST_SIZE_4_4;
6535 parse_func = joomla_parse_hash;
6536 sort_by_digest = sort_by_digest_4_4;
6537 opti_type = OPTI_TYPE_ZERO_BYTE
6538 | OPTI_TYPE_PRECOMPUTE_INIT
6539 | OPTI_TYPE_PRECOMPUTE_MERKLE
6540 | OPTI_TYPE_MEET_IN_MIDDLE
6541 | OPTI_TYPE_EARLY_SKIP
6542 | OPTI_TYPE_NOT_ITERATED
6543 | OPTI_TYPE_APPENDED_SALT
6544 | OPTI_TYPE_RAW_HASH;
6545 dgst_pos0 = 0;
6546 dgst_pos1 = 3;
6547 dgst_pos2 = 2;
6548 dgst_pos3 = 1;
6549 break;
6550
6551 case 12: hash_type = HASH_TYPE_MD5;
6552 salt_type = SALT_TYPE_INTERN;
6553 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6554 opts_type = OPTS_TYPE_PT_GENERATE_LE
6555 | OPTS_TYPE_ST_ADD80
6556 | OPTS_TYPE_ST_ADDBITS14;
6557 kern_type = KERN_TYPE_MD5_PWSLT;
6558 dgst_size = DGST_SIZE_4_4;
6559 parse_func = postgresql_parse_hash;
6560 sort_by_digest = sort_by_digest_4_4;
6561 opti_type = OPTI_TYPE_ZERO_BYTE
6562 | OPTI_TYPE_PRECOMPUTE_INIT
6563 | OPTI_TYPE_PRECOMPUTE_MERKLE
6564 | OPTI_TYPE_MEET_IN_MIDDLE
6565 | OPTI_TYPE_EARLY_SKIP
6566 | OPTI_TYPE_NOT_ITERATED
6567 | OPTI_TYPE_APPENDED_SALT
6568 | OPTI_TYPE_RAW_HASH;
6569 dgst_pos0 = 0;
6570 dgst_pos1 = 3;
6571 dgst_pos2 = 2;
6572 dgst_pos3 = 1;
6573 break;
6574
6575 case 20: hash_type = HASH_TYPE_MD5;
6576 salt_type = SALT_TYPE_INTERN;
6577 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6578 opts_type = OPTS_TYPE_PT_GENERATE_LE
6579 | OPTS_TYPE_PT_ADD80
6580 | OPTS_TYPE_PT_ADDBITS14;
6581 kern_type = KERN_TYPE_MD5_SLTPW;
6582 dgst_size = DGST_SIZE_4_4;
6583 parse_func = md5s_parse_hash;
6584 sort_by_digest = sort_by_digest_4_4;
6585 opti_type = OPTI_TYPE_ZERO_BYTE
6586 | OPTI_TYPE_PRECOMPUTE_INIT
6587 | OPTI_TYPE_PRECOMPUTE_MERKLE
6588 | OPTI_TYPE_EARLY_SKIP
6589 | OPTI_TYPE_NOT_ITERATED
6590 | OPTI_TYPE_PREPENDED_SALT
6591 | OPTI_TYPE_RAW_HASH;
6592 dgst_pos0 = 0;
6593 dgst_pos1 = 3;
6594 dgst_pos2 = 2;
6595 dgst_pos3 = 1;
6596 break;
6597
6598 case 21: hash_type = HASH_TYPE_MD5;
6599 salt_type = SALT_TYPE_INTERN;
6600 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6601 opts_type = OPTS_TYPE_PT_GENERATE_LE
6602 | OPTS_TYPE_PT_ADD80
6603 | OPTS_TYPE_PT_ADDBITS14;
6604 kern_type = KERN_TYPE_MD5_SLTPW;
6605 dgst_size = DGST_SIZE_4_4;
6606 parse_func = osc_parse_hash;
6607 sort_by_digest = sort_by_digest_4_4;
6608 opti_type = OPTI_TYPE_ZERO_BYTE
6609 | OPTI_TYPE_PRECOMPUTE_INIT
6610 | OPTI_TYPE_PRECOMPUTE_MERKLE
6611 | OPTI_TYPE_EARLY_SKIP
6612 | OPTI_TYPE_NOT_ITERATED
6613 | OPTI_TYPE_PREPENDED_SALT
6614 | OPTI_TYPE_RAW_HASH;
6615 dgst_pos0 = 0;
6616 dgst_pos1 = 3;
6617 dgst_pos2 = 2;
6618 dgst_pos3 = 1;
6619 break;
6620
6621 case 22: hash_type = HASH_TYPE_MD5;
6622 salt_type = SALT_TYPE_EMBEDDED;
6623 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6624 opts_type = OPTS_TYPE_PT_GENERATE_LE
6625 | OPTS_TYPE_PT_ADD80
6626 | OPTS_TYPE_PT_ADDBITS14;
6627 kern_type = KERN_TYPE_MD5_SLTPW;
6628 dgst_size = DGST_SIZE_4_4;
6629 parse_func = netscreen_parse_hash;
6630 sort_by_digest = sort_by_digest_4_4;
6631 opti_type = OPTI_TYPE_ZERO_BYTE
6632 | OPTI_TYPE_PRECOMPUTE_INIT
6633 | OPTI_TYPE_PRECOMPUTE_MERKLE
6634 | OPTI_TYPE_EARLY_SKIP
6635 | OPTI_TYPE_NOT_ITERATED
6636 | OPTI_TYPE_PREPENDED_SALT
6637 | OPTI_TYPE_RAW_HASH;
6638 dgst_pos0 = 0;
6639 dgst_pos1 = 3;
6640 dgst_pos2 = 2;
6641 dgst_pos3 = 1;
6642 break;
6643
6644 case 23: hash_type = HASH_TYPE_MD5;
6645 salt_type = SALT_TYPE_EMBEDDED;
6646 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6647 opts_type = OPTS_TYPE_PT_GENERATE_LE
6648 | OPTS_TYPE_PT_ADD80
6649 | OPTS_TYPE_PT_ADDBITS14;
6650 kern_type = KERN_TYPE_MD5_SLTPW;
6651 dgst_size = DGST_SIZE_4_4;
6652 parse_func = skype_parse_hash;
6653 sort_by_digest = sort_by_digest_4_4;
6654 opti_type = OPTI_TYPE_ZERO_BYTE
6655 | OPTI_TYPE_PRECOMPUTE_INIT
6656 | OPTI_TYPE_PRECOMPUTE_MERKLE
6657 | OPTI_TYPE_EARLY_SKIP
6658 | OPTI_TYPE_NOT_ITERATED
6659 | OPTI_TYPE_PREPENDED_SALT
6660 | OPTI_TYPE_RAW_HASH;
6661 dgst_pos0 = 0;
6662 dgst_pos1 = 3;
6663 dgst_pos2 = 2;
6664 dgst_pos3 = 1;
6665 break;
6666
6667 case 30: hash_type = HASH_TYPE_MD5;
6668 salt_type = SALT_TYPE_INTERN;
6669 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6670 opts_type = OPTS_TYPE_PT_GENERATE_LE
6671 | OPTS_TYPE_PT_UNICODE
6672 | OPTS_TYPE_ST_ADD80
6673 | OPTS_TYPE_ST_ADDBITS14;
6674 kern_type = KERN_TYPE_MD5_PWUSLT;
6675 dgst_size = DGST_SIZE_4_4;
6676 parse_func = md5s_parse_hash;
6677 sort_by_digest = sort_by_digest_4_4;
6678 opti_type = OPTI_TYPE_ZERO_BYTE
6679 | OPTI_TYPE_PRECOMPUTE_INIT
6680 | OPTI_TYPE_PRECOMPUTE_MERKLE
6681 | OPTI_TYPE_MEET_IN_MIDDLE
6682 | OPTI_TYPE_EARLY_SKIP
6683 | OPTI_TYPE_NOT_ITERATED
6684 | OPTI_TYPE_APPENDED_SALT
6685 | OPTI_TYPE_RAW_HASH;
6686 dgst_pos0 = 0;
6687 dgst_pos1 = 3;
6688 dgst_pos2 = 2;
6689 dgst_pos3 = 1;
6690 break;
6691
6692 case 40: hash_type = HASH_TYPE_MD5;
6693 salt_type = SALT_TYPE_INTERN;
6694 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6695 opts_type = OPTS_TYPE_PT_GENERATE_LE
6696 | OPTS_TYPE_PT_ADD80
6697 | OPTS_TYPE_PT_ADDBITS14
6698 | OPTS_TYPE_PT_UNICODE;
6699 kern_type = KERN_TYPE_MD5_SLTPWU;
6700 dgst_size = DGST_SIZE_4_4;
6701 parse_func = md5s_parse_hash;
6702 sort_by_digest = sort_by_digest_4_4;
6703 opti_type = OPTI_TYPE_ZERO_BYTE
6704 | OPTI_TYPE_PRECOMPUTE_INIT
6705 | OPTI_TYPE_PRECOMPUTE_MERKLE
6706 | OPTI_TYPE_EARLY_SKIP
6707 | OPTI_TYPE_NOT_ITERATED
6708 | OPTI_TYPE_PREPENDED_SALT
6709 | OPTI_TYPE_RAW_HASH;
6710 dgst_pos0 = 0;
6711 dgst_pos1 = 3;
6712 dgst_pos2 = 2;
6713 dgst_pos3 = 1;
6714 break;
6715
6716 case 50: hash_type = HASH_TYPE_MD5;
6717 salt_type = SALT_TYPE_INTERN;
6718 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6719 opts_type = OPTS_TYPE_PT_GENERATE_LE
6720 | OPTS_TYPE_ST_ADD80
6721 | OPTS_TYPE_ST_ADDBITS14;
6722 kern_type = KERN_TYPE_HMACMD5_PW;
6723 dgst_size = DGST_SIZE_4_4;
6724 parse_func = hmacmd5_parse_hash;
6725 sort_by_digest = sort_by_digest_4_4;
6726 opti_type = OPTI_TYPE_ZERO_BYTE
6727 | OPTI_TYPE_NOT_ITERATED;
6728 dgst_pos0 = 0;
6729 dgst_pos1 = 3;
6730 dgst_pos2 = 2;
6731 dgst_pos3 = 1;
6732 break;
6733
6734 case 60: hash_type = HASH_TYPE_MD5;
6735 salt_type = SALT_TYPE_INTERN;
6736 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6737 opts_type = OPTS_TYPE_PT_GENERATE_LE
6738 | OPTS_TYPE_PT_ADD80
6739 | OPTS_TYPE_PT_ADDBITS14;
6740 kern_type = KERN_TYPE_HMACMD5_SLT;
6741 dgst_size = DGST_SIZE_4_4;
6742 parse_func = hmacmd5_parse_hash;
6743 sort_by_digest = sort_by_digest_4_4;
6744 opti_type = OPTI_TYPE_ZERO_BYTE
6745 | OPTI_TYPE_NOT_ITERATED;
6746 dgst_pos0 = 0;
6747 dgst_pos1 = 3;
6748 dgst_pos2 = 2;
6749 dgst_pos3 = 1;
6750 break;
6751
6752 case 100: hash_type = HASH_TYPE_SHA1;
6753 salt_type = SALT_TYPE_NONE;
6754 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6755 opts_type = OPTS_TYPE_PT_GENERATE_BE
6756 | OPTS_TYPE_PT_ADD80
6757 | OPTS_TYPE_PT_ADDBITS15;
6758 kern_type = KERN_TYPE_SHA1;
6759 dgst_size = DGST_SIZE_4_5;
6760 parse_func = sha1_parse_hash;
6761 sort_by_digest = sort_by_digest_4_5;
6762 opti_type = OPTI_TYPE_ZERO_BYTE
6763 | OPTI_TYPE_PRECOMPUTE_INIT
6764 | OPTI_TYPE_PRECOMPUTE_MERKLE
6765 | OPTI_TYPE_EARLY_SKIP
6766 | OPTI_TYPE_NOT_ITERATED
6767 | OPTI_TYPE_NOT_SALTED
6768 | OPTI_TYPE_RAW_HASH;
6769 dgst_pos0 = 3;
6770 dgst_pos1 = 4;
6771 dgst_pos2 = 2;
6772 dgst_pos3 = 1;
6773 break;
6774
6775 case 101: hash_type = HASH_TYPE_SHA1;
6776 salt_type = SALT_TYPE_NONE;
6777 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6778 opts_type = OPTS_TYPE_PT_GENERATE_BE
6779 | OPTS_TYPE_PT_ADD80
6780 | OPTS_TYPE_PT_ADDBITS15;
6781 kern_type = KERN_TYPE_SHA1;
6782 dgst_size = DGST_SIZE_4_5;
6783 parse_func = sha1b64_parse_hash;
6784 sort_by_digest = sort_by_digest_4_5;
6785 opti_type = OPTI_TYPE_ZERO_BYTE
6786 | OPTI_TYPE_PRECOMPUTE_INIT
6787 | OPTI_TYPE_PRECOMPUTE_MERKLE
6788 | OPTI_TYPE_EARLY_SKIP
6789 | OPTI_TYPE_NOT_ITERATED
6790 | OPTI_TYPE_NOT_SALTED
6791 | OPTI_TYPE_RAW_HASH;
6792 dgst_pos0 = 3;
6793 dgst_pos1 = 4;
6794 dgst_pos2 = 2;
6795 dgst_pos3 = 1;
6796 break;
6797
6798 case 110: hash_type = HASH_TYPE_SHA1;
6799 salt_type = SALT_TYPE_INTERN;
6800 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6801 opts_type = OPTS_TYPE_PT_GENERATE_BE
6802 | OPTS_TYPE_ST_ADD80
6803 | OPTS_TYPE_ST_ADDBITS15;
6804 kern_type = KERN_TYPE_SHA1_PWSLT;
6805 dgst_size = DGST_SIZE_4_5;
6806 parse_func = sha1s_parse_hash;
6807 sort_by_digest = sort_by_digest_4_5;
6808 opti_type = OPTI_TYPE_ZERO_BYTE
6809 | OPTI_TYPE_PRECOMPUTE_INIT
6810 | OPTI_TYPE_PRECOMPUTE_MERKLE
6811 | OPTI_TYPE_EARLY_SKIP
6812 | OPTI_TYPE_NOT_ITERATED
6813 | OPTI_TYPE_APPENDED_SALT
6814 | OPTI_TYPE_RAW_HASH;
6815 dgst_pos0 = 3;
6816 dgst_pos1 = 4;
6817 dgst_pos2 = 2;
6818 dgst_pos3 = 1;
6819 break;
6820
6821 case 111: hash_type = HASH_TYPE_SHA1;
6822 salt_type = SALT_TYPE_EMBEDDED;
6823 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6824 opts_type = OPTS_TYPE_PT_GENERATE_BE
6825 | OPTS_TYPE_ST_ADD80
6826 | OPTS_TYPE_ST_ADDBITS15;
6827 kern_type = KERN_TYPE_SHA1_PWSLT;
6828 dgst_size = DGST_SIZE_4_5;
6829 parse_func = sha1b64s_parse_hash;
6830 sort_by_digest = sort_by_digest_4_5;
6831 opti_type = OPTI_TYPE_ZERO_BYTE
6832 | OPTI_TYPE_PRECOMPUTE_INIT
6833 | OPTI_TYPE_PRECOMPUTE_MERKLE
6834 | OPTI_TYPE_EARLY_SKIP
6835 | OPTI_TYPE_NOT_ITERATED
6836 | OPTI_TYPE_APPENDED_SALT
6837 | OPTI_TYPE_RAW_HASH;
6838 dgst_pos0 = 3;
6839 dgst_pos1 = 4;
6840 dgst_pos2 = 2;
6841 dgst_pos3 = 1;
6842 break;
6843
6844 case 112: hash_type = HASH_TYPE_SHA1;
6845 salt_type = SALT_TYPE_INTERN;
6846 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6847 opts_type = OPTS_TYPE_PT_GENERATE_BE
6848 | OPTS_TYPE_ST_ADD80
6849 | OPTS_TYPE_ST_ADDBITS15
6850 | OPTS_TYPE_ST_HEX;
6851 kern_type = KERN_TYPE_SHA1_PWSLT;
6852 dgst_size = DGST_SIZE_4_5;
6853 parse_func = oracles_parse_hash;
6854 sort_by_digest = sort_by_digest_4_5;
6855 opti_type = OPTI_TYPE_ZERO_BYTE
6856 | OPTI_TYPE_PRECOMPUTE_INIT
6857 | OPTI_TYPE_PRECOMPUTE_MERKLE
6858 | OPTI_TYPE_EARLY_SKIP
6859 | OPTI_TYPE_NOT_ITERATED
6860 | OPTI_TYPE_APPENDED_SALT
6861 | OPTI_TYPE_RAW_HASH;
6862 dgst_pos0 = 3;
6863 dgst_pos1 = 4;
6864 dgst_pos2 = 2;
6865 dgst_pos3 = 1;
6866 break;
6867
6868 case 120: hash_type = HASH_TYPE_SHA1;
6869 salt_type = SALT_TYPE_INTERN;
6870 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6871 opts_type = OPTS_TYPE_PT_GENERATE_BE
6872 | OPTS_TYPE_PT_ADD80
6873 | OPTS_TYPE_PT_ADDBITS15;
6874 kern_type = KERN_TYPE_SHA1_SLTPW;
6875 dgst_size = DGST_SIZE_4_5;
6876 parse_func = sha1s_parse_hash;
6877 sort_by_digest = sort_by_digest_4_5;
6878 opti_type = OPTI_TYPE_ZERO_BYTE
6879 | OPTI_TYPE_PRECOMPUTE_INIT
6880 | OPTI_TYPE_PRECOMPUTE_MERKLE
6881 | OPTI_TYPE_EARLY_SKIP
6882 | OPTI_TYPE_NOT_ITERATED
6883 | OPTI_TYPE_PREPENDED_SALT
6884 | OPTI_TYPE_RAW_HASH;
6885 dgst_pos0 = 3;
6886 dgst_pos1 = 4;
6887 dgst_pos2 = 2;
6888 dgst_pos3 = 1;
6889 break;
6890
6891 case 121: hash_type = HASH_TYPE_SHA1;
6892 salt_type = SALT_TYPE_INTERN;
6893 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6894 opts_type = OPTS_TYPE_PT_GENERATE_BE
6895 | OPTS_TYPE_PT_ADD80
6896 | OPTS_TYPE_PT_ADDBITS15
6897 | OPTS_TYPE_ST_LOWER;
6898 kern_type = KERN_TYPE_SHA1_SLTPW;
6899 dgst_size = DGST_SIZE_4_5;
6900 parse_func = smf_parse_hash;
6901 sort_by_digest = sort_by_digest_4_5;
6902 opti_type = OPTI_TYPE_ZERO_BYTE
6903 | OPTI_TYPE_PRECOMPUTE_INIT
6904 | OPTI_TYPE_PRECOMPUTE_MERKLE
6905 | OPTI_TYPE_EARLY_SKIP
6906 | OPTI_TYPE_NOT_ITERATED
6907 | OPTI_TYPE_PREPENDED_SALT
6908 | OPTI_TYPE_RAW_HASH;
6909 dgst_pos0 = 3;
6910 dgst_pos1 = 4;
6911 dgst_pos2 = 2;
6912 dgst_pos3 = 1;
6913 break;
6914
6915 case 122: hash_type = HASH_TYPE_SHA1;
6916 salt_type = SALT_TYPE_EMBEDDED;
6917 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6918 opts_type = OPTS_TYPE_PT_GENERATE_BE
6919 | OPTS_TYPE_PT_ADD80
6920 | OPTS_TYPE_PT_ADDBITS15
6921 | OPTS_TYPE_ST_HEX;
6922 kern_type = KERN_TYPE_SHA1_SLTPW;
6923 dgst_size = DGST_SIZE_4_5;
6924 parse_func = osx1_parse_hash;
6925 sort_by_digest = sort_by_digest_4_5;
6926 opti_type = OPTI_TYPE_ZERO_BYTE
6927 | OPTI_TYPE_PRECOMPUTE_INIT
6928 | OPTI_TYPE_PRECOMPUTE_MERKLE
6929 | OPTI_TYPE_EARLY_SKIP
6930 | OPTI_TYPE_NOT_ITERATED
6931 | OPTI_TYPE_PREPENDED_SALT
6932 | OPTI_TYPE_RAW_HASH;
6933 dgst_pos0 = 3;
6934 dgst_pos1 = 4;
6935 dgst_pos2 = 2;
6936 dgst_pos3 = 1;
6937 break;
6938
6939 case 124: hash_type = HASH_TYPE_SHA1;
6940 salt_type = SALT_TYPE_EMBEDDED;
6941 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6942 opts_type = OPTS_TYPE_PT_GENERATE_BE
6943 | OPTS_TYPE_PT_ADD80
6944 | OPTS_TYPE_PT_ADDBITS15;
6945 kern_type = KERN_TYPE_SHA1_SLTPW;
6946 dgst_size = DGST_SIZE_4_5;
6947 parse_func = djangosha1_parse_hash;
6948 sort_by_digest = sort_by_digest_4_5;
6949 opti_type = OPTI_TYPE_ZERO_BYTE
6950 | OPTI_TYPE_PRECOMPUTE_INIT
6951 | OPTI_TYPE_PRECOMPUTE_MERKLE
6952 | OPTI_TYPE_EARLY_SKIP
6953 | OPTI_TYPE_NOT_ITERATED
6954 | OPTI_TYPE_PREPENDED_SALT
6955 | OPTI_TYPE_RAW_HASH;
6956 dgst_pos0 = 3;
6957 dgst_pos1 = 4;
6958 dgst_pos2 = 2;
6959 dgst_pos3 = 1;
6960 break;
6961
6962 case 130: hash_type = HASH_TYPE_SHA1;
6963 salt_type = SALT_TYPE_INTERN;
6964 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6965 opts_type = OPTS_TYPE_PT_GENERATE_BE
6966 | OPTS_TYPE_PT_UNICODE
6967 | OPTS_TYPE_ST_ADD80
6968 | OPTS_TYPE_ST_ADDBITS15;
6969 kern_type = KERN_TYPE_SHA1_PWUSLT;
6970 dgst_size = DGST_SIZE_4_5;
6971 parse_func = sha1s_parse_hash;
6972 sort_by_digest = sort_by_digest_4_5;
6973 opti_type = OPTI_TYPE_ZERO_BYTE
6974 | OPTI_TYPE_PRECOMPUTE_INIT
6975 | OPTI_TYPE_PRECOMPUTE_MERKLE
6976 | OPTI_TYPE_EARLY_SKIP
6977 | OPTI_TYPE_NOT_ITERATED
6978 | OPTI_TYPE_APPENDED_SALT
6979 | OPTI_TYPE_RAW_HASH;
6980 dgst_pos0 = 3;
6981 dgst_pos1 = 4;
6982 dgst_pos2 = 2;
6983 dgst_pos3 = 1;
6984 break;
6985
6986 case 131: hash_type = HASH_TYPE_SHA1;
6987 salt_type = SALT_TYPE_EMBEDDED;
6988 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6989 opts_type = OPTS_TYPE_PT_GENERATE_BE
6990 | OPTS_TYPE_PT_UNICODE
6991 | OPTS_TYPE_PT_UPPER
6992 | OPTS_TYPE_ST_ADD80
6993 | OPTS_TYPE_ST_ADDBITS15
6994 | OPTS_TYPE_ST_HEX;
6995 kern_type = KERN_TYPE_SHA1_PWUSLT;
6996 dgst_size = DGST_SIZE_4_5;
6997 parse_func = mssql2000_parse_hash;
6998 sort_by_digest = sort_by_digest_4_5;
6999 opti_type = OPTI_TYPE_ZERO_BYTE
7000 | OPTI_TYPE_PRECOMPUTE_INIT
7001 | OPTI_TYPE_PRECOMPUTE_MERKLE
7002 | OPTI_TYPE_EARLY_SKIP
7003 | OPTI_TYPE_NOT_ITERATED
7004 | OPTI_TYPE_APPENDED_SALT
7005 | OPTI_TYPE_RAW_HASH;
7006 dgst_pos0 = 3;
7007 dgst_pos1 = 4;
7008 dgst_pos2 = 2;
7009 dgst_pos3 = 1;
7010 break;
7011
7012 case 132: hash_type = HASH_TYPE_SHA1;
7013 salt_type = SALT_TYPE_EMBEDDED;
7014 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7015 opts_type = OPTS_TYPE_PT_GENERATE_BE
7016 | OPTS_TYPE_PT_UNICODE
7017 | OPTS_TYPE_ST_ADD80
7018 | OPTS_TYPE_ST_ADDBITS15
7019 | OPTS_TYPE_ST_HEX;
7020 kern_type = KERN_TYPE_SHA1_PWUSLT;
7021 dgst_size = DGST_SIZE_4_5;
7022 parse_func = mssql2005_parse_hash;
7023 sort_by_digest = sort_by_digest_4_5;
7024 opti_type = OPTI_TYPE_ZERO_BYTE
7025 | OPTI_TYPE_PRECOMPUTE_INIT
7026 | OPTI_TYPE_PRECOMPUTE_MERKLE
7027 | OPTI_TYPE_EARLY_SKIP
7028 | OPTI_TYPE_NOT_ITERATED
7029 | OPTI_TYPE_APPENDED_SALT
7030 | OPTI_TYPE_RAW_HASH;
7031 dgst_pos0 = 3;
7032 dgst_pos1 = 4;
7033 dgst_pos2 = 2;
7034 dgst_pos3 = 1;
7035 break;
7036
7037 case 133: hash_type = HASH_TYPE_SHA1;
7038 salt_type = SALT_TYPE_EMBEDDED;
7039 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7040 opts_type = OPTS_TYPE_PT_GENERATE_BE
7041 | OPTS_TYPE_PT_UNICODE
7042 | OPTS_TYPE_ST_ADD80
7043 | OPTS_TYPE_ST_ADDBITS15;
7044 kern_type = KERN_TYPE_SHA1_PWUSLT;
7045 dgst_size = DGST_SIZE_4_5;
7046 parse_func = peoplesoft_parse_hash;
7047 sort_by_digest = sort_by_digest_4_5;
7048 opti_type = OPTI_TYPE_ZERO_BYTE
7049 | OPTI_TYPE_PRECOMPUTE_INIT
7050 | OPTI_TYPE_PRECOMPUTE_MERKLE
7051 | OPTI_TYPE_EARLY_SKIP
7052 | OPTI_TYPE_NOT_ITERATED
7053 | OPTI_TYPE_APPENDED_SALT
7054 | OPTI_TYPE_RAW_HASH;
7055 dgst_pos0 = 3;
7056 dgst_pos1 = 4;
7057 dgst_pos2 = 2;
7058 dgst_pos3 = 1;
7059 break;
7060
7061 case 140: hash_type = HASH_TYPE_SHA1;
7062 salt_type = SALT_TYPE_INTERN;
7063 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7064 opts_type = OPTS_TYPE_PT_GENERATE_BE
7065 | OPTS_TYPE_PT_ADD80
7066 | OPTS_TYPE_PT_ADDBITS15
7067 | OPTS_TYPE_PT_UNICODE;
7068 kern_type = KERN_TYPE_SHA1_SLTPWU;
7069 dgst_size = DGST_SIZE_4_5;
7070 parse_func = sha1s_parse_hash;
7071 sort_by_digest = sort_by_digest_4_5;
7072 opti_type = OPTI_TYPE_ZERO_BYTE
7073 | OPTI_TYPE_PRECOMPUTE_INIT
7074 | OPTI_TYPE_PRECOMPUTE_MERKLE
7075 | OPTI_TYPE_EARLY_SKIP
7076 | OPTI_TYPE_NOT_ITERATED
7077 | OPTI_TYPE_PREPENDED_SALT
7078 | OPTI_TYPE_RAW_HASH;
7079 dgst_pos0 = 3;
7080 dgst_pos1 = 4;
7081 dgst_pos2 = 2;
7082 dgst_pos3 = 1;
7083 break;
7084
7085 case 141: hash_type = HASH_TYPE_SHA1;
7086 salt_type = SALT_TYPE_EMBEDDED;
7087 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7088 opts_type = OPTS_TYPE_PT_GENERATE_BE
7089 | OPTS_TYPE_PT_ADD80
7090 | OPTS_TYPE_PT_ADDBITS15
7091 | OPTS_TYPE_PT_UNICODE
7092 | OPTS_TYPE_ST_BASE64;
7093 kern_type = KERN_TYPE_SHA1_SLTPWU;
7094 dgst_size = DGST_SIZE_4_5;
7095 parse_func = episerver_parse_hash;
7096 sort_by_digest = sort_by_digest_4_5;
7097 opti_type = OPTI_TYPE_ZERO_BYTE
7098 | OPTI_TYPE_PRECOMPUTE_INIT
7099 | OPTI_TYPE_PRECOMPUTE_MERKLE
7100 | OPTI_TYPE_EARLY_SKIP
7101 | OPTI_TYPE_NOT_ITERATED
7102 | OPTI_TYPE_PREPENDED_SALT
7103 | OPTI_TYPE_RAW_HASH;
7104 dgst_pos0 = 3;
7105 dgst_pos1 = 4;
7106 dgst_pos2 = 2;
7107 dgst_pos3 = 1;
7108 break;
7109
7110 case 150: hash_type = HASH_TYPE_SHA1;
7111 salt_type = SALT_TYPE_INTERN;
7112 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7113 opts_type = OPTS_TYPE_PT_GENERATE_BE
7114 | OPTS_TYPE_ST_ADD80
7115 | OPTS_TYPE_ST_ADDBITS15;
7116 kern_type = KERN_TYPE_HMACSHA1_PW;
7117 dgst_size = DGST_SIZE_4_5;
7118 parse_func = hmacsha1_parse_hash;
7119 sort_by_digest = sort_by_digest_4_5;
7120 opti_type = OPTI_TYPE_ZERO_BYTE
7121 | OPTI_TYPE_NOT_ITERATED;
7122 dgst_pos0 = 3;
7123 dgst_pos1 = 4;
7124 dgst_pos2 = 2;
7125 dgst_pos3 = 1;
7126 break;
7127
7128 case 160: hash_type = HASH_TYPE_SHA1;
7129 salt_type = SALT_TYPE_INTERN;
7130 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7131 opts_type = OPTS_TYPE_PT_GENERATE_BE
7132 | OPTS_TYPE_PT_ADD80
7133 | OPTS_TYPE_PT_ADDBITS15;
7134 kern_type = KERN_TYPE_HMACSHA1_SLT;
7135 dgst_size = DGST_SIZE_4_5;
7136 parse_func = hmacsha1_parse_hash;
7137 sort_by_digest = sort_by_digest_4_5;
7138 opti_type = OPTI_TYPE_ZERO_BYTE
7139 | OPTI_TYPE_NOT_ITERATED;
7140 dgst_pos0 = 3;
7141 dgst_pos1 = 4;
7142 dgst_pos2 = 2;
7143 dgst_pos3 = 1;
7144 break;
7145
7146 case 190: hash_type = HASH_TYPE_SHA1;
7147 salt_type = SALT_TYPE_NONE;
7148 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7149 opts_type = OPTS_TYPE_PT_GENERATE_BE
7150 | OPTS_TYPE_PT_ADD80
7151 | OPTS_TYPE_PT_ADDBITS15;
7152 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7153 dgst_size = DGST_SIZE_4_5;
7154 parse_func = sha1linkedin_parse_hash;
7155 sort_by_digest = sort_by_digest_4_5;
7156 opti_type = OPTI_TYPE_ZERO_BYTE
7157 | OPTI_TYPE_PRECOMPUTE_INIT
7158 | OPTI_TYPE_EARLY_SKIP
7159 | OPTI_TYPE_NOT_ITERATED
7160 | OPTI_TYPE_NOT_SALTED;
7161 dgst_pos0 = 0;
7162 dgst_pos1 = 4;
7163 dgst_pos2 = 3;
7164 dgst_pos3 = 2;
7165 break;
7166
7167 case 200: hash_type = HASH_TYPE_MYSQL;
7168 salt_type = SALT_TYPE_NONE;
7169 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7170 opts_type = 0;
7171 kern_type = KERN_TYPE_MYSQL;
7172 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7173 parse_func = mysql323_parse_hash;
7174 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7175 opti_type = OPTI_TYPE_ZERO_BYTE;
7176 dgst_pos0 = 0;
7177 dgst_pos1 = 1;
7178 dgst_pos2 = 2;
7179 dgst_pos3 = 3;
7180 break;
7181
7182 case 300: hash_type = HASH_TYPE_SHA1;
7183 salt_type = SALT_TYPE_NONE;
7184 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7185 opts_type = OPTS_TYPE_PT_GENERATE_BE
7186 | OPTS_TYPE_PT_ADD80
7187 | OPTS_TYPE_PT_ADDBITS15;
7188 kern_type = KERN_TYPE_MYSQL41;
7189 dgst_size = DGST_SIZE_4_5;
7190 parse_func = sha1_parse_hash;
7191 sort_by_digest = sort_by_digest_4_5;
7192 opti_type = OPTI_TYPE_ZERO_BYTE
7193 | OPTI_TYPE_PRECOMPUTE_INIT
7194 | OPTI_TYPE_PRECOMPUTE_MERKLE
7195 | OPTI_TYPE_EARLY_SKIP
7196 | OPTI_TYPE_NOT_ITERATED
7197 | OPTI_TYPE_NOT_SALTED;
7198 dgst_pos0 = 3;
7199 dgst_pos1 = 4;
7200 dgst_pos2 = 2;
7201 dgst_pos3 = 1;
7202 break;
7203
7204 case 400: hash_type = HASH_TYPE_MD5;
7205 salt_type = SALT_TYPE_EMBEDDED;
7206 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7207 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7208 kern_type = KERN_TYPE_PHPASS;
7209 dgst_size = DGST_SIZE_4_4;
7210 parse_func = phpass_parse_hash;
7211 sort_by_digest = sort_by_digest_4_4;
7212 opti_type = OPTI_TYPE_ZERO_BYTE;
7213 dgst_pos0 = 0;
7214 dgst_pos1 = 1;
7215 dgst_pos2 = 2;
7216 dgst_pos3 = 3;
7217 break;
7218
7219 case 500: hash_type = HASH_TYPE_MD5;
7220 salt_type = SALT_TYPE_EMBEDDED;
7221 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7222 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7223 kern_type = KERN_TYPE_MD5CRYPT;
7224 dgst_size = DGST_SIZE_4_4;
7225 parse_func = md5crypt_parse_hash;
7226 sort_by_digest = sort_by_digest_4_4;
7227 opti_type = OPTI_TYPE_ZERO_BYTE;
7228 dgst_pos0 = 0;
7229 dgst_pos1 = 1;
7230 dgst_pos2 = 2;
7231 dgst_pos3 = 3;
7232 break;
7233
7234 case 501: hash_type = HASH_TYPE_MD5;
7235 salt_type = SALT_TYPE_EMBEDDED;
7236 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7237 opts_type = OPTS_TYPE_PT_GENERATE_LE
7238 | OPTS_TYPE_HASH_COPY;
7239 kern_type = KERN_TYPE_MD5CRYPT;
7240 dgst_size = DGST_SIZE_4_4;
7241 parse_func = juniper_parse_hash;
7242 sort_by_digest = sort_by_digest_4_4;
7243 opti_type = OPTI_TYPE_ZERO_BYTE;
7244 dgst_pos0 = 0;
7245 dgst_pos1 = 1;
7246 dgst_pos2 = 2;
7247 dgst_pos3 = 3;
7248 break;
7249
7250 case 900: hash_type = HASH_TYPE_MD4;
7251 salt_type = SALT_TYPE_NONE;
7252 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7253 opts_type = OPTS_TYPE_PT_GENERATE_LE
7254 | OPTS_TYPE_PT_ADD80
7255 | OPTS_TYPE_PT_ADDBITS14;
7256 kern_type = KERN_TYPE_MD4;
7257 dgst_size = DGST_SIZE_4_4;
7258 parse_func = md4_parse_hash;
7259 sort_by_digest = sort_by_digest_4_4;
7260 opti_type = OPTI_TYPE_ZERO_BYTE
7261 | OPTI_TYPE_PRECOMPUTE_INIT
7262 | OPTI_TYPE_PRECOMPUTE_MERKLE
7263 | OPTI_TYPE_MEET_IN_MIDDLE
7264 | OPTI_TYPE_EARLY_SKIP
7265 | OPTI_TYPE_NOT_ITERATED
7266 | OPTI_TYPE_NOT_SALTED
7267 | OPTI_TYPE_RAW_HASH;
7268 dgst_pos0 = 0;
7269 dgst_pos1 = 3;
7270 dgst_pos2 = 2;
7271 dgst_pos3 = 1;
7272 break;
7273
7274 case 1000: hash_type = HASH_TYPE_MD4;
7275 salt_type = SALT_TYPE_NONE;
7276 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7277 opts_type = OPTS_TYPE_PT_GENERATE_LE
7278 | OPTS_TYPE_PT_ADD80
7279 | OPTS_TYPE_PT_ADDBITS14
7280 | OPTS_TYPE_PT_UNICODE;
7281 kern_type = KERN_TYPE_MD4_PWU;
7282 dgst_size = DGST_SIZE_4_4;
7283 parse_func = md4_parse_hash;
7284 sort_by_digest = sort_by_digest_4_4;
7285 opti_type = OPTI_TYPE_ZERO_BYTE
7286 | OPTI_TYPE_PRECOMPUTE_INIT
7287 | OPTI_TYPE_PRECOMPUTE_MERKLE
7288 | OPTI_TYPE_MEET_IN_MIDDLE
7289 | OPTI_TYPE_EARLY_SKIP
7290 | OPTI_TYPE_NOT_ITERATED
7291 | OPTI_TYPE_NOT_SALTED
7292 | OPTI_TYPE_RAW_HASH;
7293 dgst_pos0 = 0;
7294 dgst_pos1 = 3;
7295 dgst_pos2 = 2;
7296 dgst_pos3 = 1;
7297 break;
7298
7299 case 1100: hash_type = HASH_TYPE_MD4;
7300 salt_type = SALT_TYPE_INTERN;
7301 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7302 opts_type = OPTS_TYPE_PT_GENERATE_LE
7303 | OPTS_TYPE_PT_ADD80
7304 | OPTS_TYPE_PT_ADDBITS14
7305 | OPTS_TYPE_PT_UNICODE
7306 | OPTS_TYPE_ST_ADD80
7307 | OPTS_TYPE_ST_UNICODE
7308 | OPTS_TYPE_ST_LOWER;
7309 kern_type = KERN_TYPE_MD44_PWUSLT;
7310 dgst_size = DGST_SIZE_4_4;
7311 parse_func = dcc_parse_hash;
7312 sort_by_digest = sort_by_digest_4_4;
7313 opti_type = OPTI_TYPE_ZERO_BYTE
7314 | OPTI_TYPE_PRECOMPUTE_INIT
7315 | OPTI_TYPE_PRECOMPUTE_MERKLE
7316 | OPTI_TYPE_EARLY_SKIP
7317 | OPTI_TYPE_NOT_ITERATED;
7318 dgst_pos0 = 0;
7319 dgst_pos1 = 3;
7320 dgst_pos2 = 2;
7321 dgst_pos3 = 1;
7322 break;
7323
7324 case 1400: hash_type = HASH_TYPE_SHA256;
7325 salt_type = SALT_TYPE_NONE;
7326 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7327 opts_type = OPTS_TYPE_PT_GENERATE_BE
7328 | OPTS_TYPE_PT_ADD80
7329 | OPTS_TYPE_PT_ADDBITS15;
7330 kern_type = KERN_TYPE_SHA256;
7331 dgst_size = DGST_SIZE_4_8;
7332 parse_func = sha256_parse_hash;
7333 sort_by_digest = sort_by_digest_4_8;
7334 opti_type = OPTI_TYPE_ZERO_BYTE
7335 | OPTI_TYPE_PRECOMPUTE_INIT
7336 | OPTI_TYPE_PRECOMPUTE_MERKLE
7337 | OPTI_TYPE_EARLY_SKIP
7338 | OPTI_TYPE_NOT_ITERATED
7339 | OPTI_TYPE_NOT_SALTED
7340 | OPTI_TYPE_RAW_HASH;
7341 dgst_pos0 = 3;
7342 dgst_pos1 = 7;
7343 dgst_pos2 = 2;
7344 dgst_pos3 = 6;
7345 break;
7346
7347 case 1410: hash_type = HASH_TYPE_SHA256;
7348 salt_type = SALT_TYPE_INTERN;
7349 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7350 opts_type = OPTS_TYPE_PT_GENERATE_BE
7351 | OPTS_TYPE_ST_ADD80
7352 | OPTS_TYPE_ST_ADDBITS15;
7353 kern_type = KERN_TYPE_SHA256_PWSLT;
7354 dgst_size = DGST_SIZE_4_8;
7355 parse_func = sha256s_parse_hash;
7356 sort_by_digest = sort_by_digest_4_8;
7357 opti_type = OPTI_TYPE_ZERO_BYTE
7358 | OPTI_TYPE_PRECOMPUTE_INIT
7359 | OPTI_TYPE_PRECOMPUTE_MERKLE
7360 | OPTI_TYPE_EARLY_SKIP
7361 | OPTI_TYPE_NOT_ITERATED
7362 | OPTI_TYPE_APPENDED_SALT
7363 | OPTI_TYPE_RAW_HASH;
7364 dgst_pos0 = 3;
7365 dgst_pos1 = 7;
7366 dgst_pos2 = 2;
7367 dgst_pos3 = 6;
7368 break;
7369
7370 case 1420: hash_type = HASH_TYPE_SHA256;
7371 salt_type = SALT_TYPE_INTERN;
7372 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7373 opts_type = OPTS_TYPE_PT_GENERATE_BE
7374 | OPTS_TYPE_PT_ADD80
7375 | OPTS_TYPE_PT_ADDBITS15;
7376 kern_type = KERN_TYPE_SHA256_SLTPW;
7377 dgst_size = DGST_SIZE_4_8;
7378 parse_func = sha256s_parse_hash;
7379 sort_by_digest = sort_by_digest_4_8;
7380 opti_type = OPTI_TYPE_ZERO_BYTE
7381 | OPTI_TYPE_PRECOMPUTE_INIT
7382 | OPTI_TYPE_PRECOMPUTE_MERKLE
7383 | OPTI_TYPE_EARLY_SKIP
7384 | OPTI_TYPE_NOT_ITERATED
7385 | OPTI_TYPE_PREPENDED_SALT
7386 | OPTI_TYPE_RAW_HASH;
7387 dgst_pos0 = 3;
7388 dgst_pos1 = 7;
7389 dgst_pos2 = 2;
7390 dgst_pos3 = 6;
7391 break;
7392
7393 case 1421: hash_type = HASH_TYPE_SHA256;
7394 salt_type = SALT_TYPE_EMBEDDED;
7395 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7396 opts_type = OPTS_TYPE_PT_GENERATE_BE
7397 | OPTS_TYPE_PT_ADD80
7398 | OPTS_TYPE_PT_ADDBITS15;
7399 kern_type = KERN_TYPE_SHA256_SLTPW;
7400 dgst_size = DGST_SIZE_4_8;
7401 parse_func = hmailserver_parse_hash;
7402 sort_by_digest = sort_by_digest_4_8;
7403 opti_type = OPTI_TYPE_ZERO_BYTE
7404 | OPTI_TYPE_PRECOMPUTE_INIT
7405 | OPTI_TYPE_PRECOMPUTE_MERKLE
7406 | OPTI_TYPE_EARLY_SKIP
7407 | OPTI_TYPE_NOT_ITERATED
7408 | OPTI_TYPE_PREPENDED_SALT
7409 | OPTI_TYPE_RAW_HASH;
7410 dgst_pos0 = 3;
7411 dgst_pos1 = 7;
7412 dgst_pos2 = 2;
7413 dgst_pos3 = 6;
7414 break;
7415
7416 case 1430: hash_type = HASH_TYPE_SHA256;
7417 salt_type = SALT_TYPE_INTERN;
7418 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7419 opts_type = OPTS_TYPE_PT_GENERATE_BE
7420 | OPTS_TYPE_PT_UNICODE
7421 | OPTS_TYPE_ST_ADD80
7422 | OPTS_TYPE_ST_ADDBITS15;
7423 kern_type = KERN_TYPE_SHA256_PWUSLT;
7424 dgst_size = DGST_SIZE_4_8;
7425 parse_func = sha256s_parse_hash;
7426 sort_by_digest = sort_by_digest_4_8;
7427 opti_type = OPTI_TYPE_ZERO_BYTE
7428 | OPTI_TYPE_PRECOMPUTE_INIT
7429 | OPTI_TYPE_PRECOMPUTE_MERKLE
7430 | OPTI_TYPE_EARLY_SKIP
7431 | OPTI_TYPE_NOT_ITERATED
7432 | OPTI_TYPE_APPENDED_SALT
7433 | OPTI_TYPE_RAW_HASH;
7434 dgst_pos0 = 3;
7435 dgst_pos1 = 7;
7436 dgst_pos2 = 2;
7437 dgst_pos3 = 6;
7438 break;
7439
7440 case 1440: hash_type = HASH_TYPE_SHA256;
7441 salt_type = SALT_TYPE_INTERN;
7442 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7443 opts_type = OPTS_TYPE_PT_GENERATE_BE
7444 | OPTS_TYPE_PT_ADD80
7445 | OPTS_TYPE_PT_ADDBITS15
7446 | OPTS_TYPE_PT_UNICODE;
7447 kern_type = KERN_TYPE_SHA256_SLTPWU;
7448 dgst_size = DGST_SIZE_4_8;
7449 parse_func = sha256s_parse_hash;
7450 sort_by_digest = sort_by_digest_4_8;
7451 opti_type = OPTI_TYPE_ZERO_BYTE
7452 | OPTI_TYPE_PRECOMPUTE_INIT
7453 | OPTI_TYPE_PRECOMPUTE_MERKLE
7454 | OPTI_TYPE_EARLY_SKIP
7455 | OPTI_TYPE_NOT_ITERATED
7456 | OPTI_TYPE_PREPENDED_SALT
7457 | OPTI_TYPE_RAW_HASH;
7458 dgst_pos0 = 3;
7459 dgst_pos1 = 7;
7460 dgst_pos2 = 2;
7461 dgst_pos3 = 6;
7462 break;
7463
7464 case 1441: hash_type = HASH_TYPE_SHA256;
7465 salt_type = SALT_TYPE_EMBEDDED;
7466 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7467 opts_type = OPTS_TYPE_PT_GENERATE_BE
7468 | OPTS_TYPE_PT_ADD80
7469 | OPTS_TYPE_PT_ADDBITS15
7470 | OPTS_TYPE_PT_UNICODE
7471 | OPTS_TYPE_ST_BASE64;
7472 kern_type = KERN_TYPE_SHA256_SLTPWU;
7473 dgst_size = DGST_SIZE_4_8;
7474 parse_func = episerver4_parse_hash;
7475 sort_by_digest = sort_by_digest_4_8;
7476 opti_type = OPTI_TYPE_ZERO_BYTE
7477 | OPTI_TYPE_PRECOMPUTE_INIT
7478 | OPTI_TYPE_PRECOMPUTE_MERKLE
7479 | OPTI_TYPE_EARLY_SKIP
7480 | OPTI_TYPE_NOT_ITERATED
7481 | OPTI_TYPE_PREPENDED_SALT
7482 | OPTI_TYPE_RAW_HASH;
7483 dgst_pos0 = 3;
7484 dgst_pos1 = 7;
7485 dgst_pos2 = 2;
7486 dgst_pos3 = 6;
7487 break;
7488
7489 case 1450: hash_type = HASH_TYPE_SHA256;
7490 salt_type = SALT_TYPE_INTERN;
7491 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7492 opts_type = OPTS_TYPE_PT_GENERATE_BE
7493 | OPTS_TYPE_ST_ADD80;
7494 kern_type = KERN_TYPE_HMACSHA256_PW;
7495 dgst_size = DGST_SIZE_4_8;
7496 parse_func = hmacsha256_parse_hash;
7497 sort_by_digest = sort_by_digest_4_8;
7498 opti_type = OPTI_TYPE_ZERO_BYTE
7499 | OPTI_TYPE_NOT_ITERATED;
7500 dgst_pos0 = 3;
7501 dgst_pos1 = 7;
7502 dgst_pos2 = 2;
7503 dgst_pos3 = 6;
7504 break;
7505
7506 case 1460: hash_type = HASH_TYPE_SHA256;
7507 salt_type = SALT_TYPE_INTERN;
7508 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7509 opts_type = OPTS_TYPE_PT_GENERATE_BE
7510 | OPTS_TYPE_PT_ADD80
7511 | OPTS_TYPE_PT_ADDBITS15;
7512 kern_type = KERN_TYPE_HMACSHA256_SLT;
7513 dgst_size = DGST_SIZE_4_8;
7514 parse_func = hmacsha256_parse_hash;
7515 sort_by_digest = sort_by_digest_4_8;
7516 opti_type = OPTI_TYPE_ZERO_BYTE
7517 | OPTI_TYPE_NOT_ITERATED;
7518 dgst_pos0 = 3;
7519 dgst_pos1 = 7;
7520 dgst_pos2 = 2;
7521 dgst_pos3 = 6;
7522 break;
7523
7524 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7525 salt_type = SALT_TYPE_EMBEDDED;
7526 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7527 opts_type = OPTS_TYPE_PT_GENERATE_LE
7528 | OPTS_TYPE_PT_BITSLICE;
7529 kern_type = KERN_TYPE_DESCRYPT;
7530 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7531 parse_func = descrypt_parse_hash;
7532 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7533 opti_type = OPTI_TYPE_ZERO_BYTE
7534 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7535 dgst_pos0 = 0;
7536 dgst_pos1 = 1;
7537 dgst_pos2 = 2;
7538 dgst_pos3 = 3;
7539 break;
7540
7541 case 1600: hash_type = HASH_TYPE_MD5;
7542 salt_type = SALT_TYPE_EMBEDDED;
7543 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7544 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7545 kern_type = KERN_TYPE_APR1CRYPT;
7546 dgst_size = DGST_SIZE_4_4;
7547 parse_func = md5apr1_parse_hash;
7548 sort_by_digest = sort_by_digest_4_4;
7549 opti_type = OPTI_TYPE_ZERO_BYTE;
7550 dgst_pos0 = 0;
7551 dgst_pos1 = 1;
7552 dgst_pos2 = 2;
7553 dgst_pos3 = 3;
7554 break;
7555
7556 case 1700: hash_type = HASH_TYPE_SHA512;
7557 salt_type = SALT_TYPE_NONE;
7558 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7559 opts_type = OPTS_TYPE_PT_GENERATE_BE
7560 | OPTS_TYPE_PT_ADD80
7561 | OPTS_TYPE_PT_ADDBITS15;
7562 kern_type = KERN_TYPE_SHA512;
7563 dgst_size = DGST_SIZE_8_8;
7564 parse_func = sha512_parse_hash;
7565 sort_by_digest = sort_by_digest_8_8;
7566 opti_type = OPTI_TYPE_ZERO_BYTE
7567 | OPTI_TYPE_PRECOMPUTE_INIT
7568 | OPTI_TYPE_PRECOMPUTE_MERKLE
7569 | OPTI_TYPE_EARLY_SKIP
7570 | OPTI_TYPE_NOT_ITERATED
7571 | OPTI_TYPE_NOT_SALTED
7572 | OPTI_TYPE_RAW_HASH;
7573 dgst_pos0 = 14;
7574 dgst_pos1 = 15;
7575 dgst_pos2 = 6;
7576 dgst_pos3 = 7;
7577 break;
7578
7579 case 1710: hash_type = HASH_TYPE_SHA512;
7580 salt_type = SALT_TYPE_INTERN;
7581 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7582 opts_type = OPTS_TYPE_PT_GENERATE_BE
7583 | OPTS_TYPE_ST_ADD80
7584 | OPTS_TYPE_ST_ADDBITS15;
7585 kern_type = KERN_TYPE_SHA512_PWSLT;
7586 dgst_size = DGST_SIZE_8_8;
7587 parse_func = sha512s_parse_hash;
7588 sort_by_digest = sort_by_digest_8_8;
7589 opti_type = OPTI_TYPE_ZERO_BYTE
7590 | OPTI_TYPE_PRECOMPUTE_INIT
7591 | OPTI_TYPE_PRECOMPUTE_MERKLE
7592 | OPTI_TYPE_EARLY_SKIP
7593 | OPTI_TYPE_NOT_ITERATED
7594 | OPTI_TYPE_APPENDED_SALT
7595 | OPTI_TYPE_RAW_HASH;
7596 dgst_pos0 = 14;
7597 dgst_pos1 = 15;
7598 dgst_pos2 = 6;
7599 dgst_pos3 = 7;
7600 break;
7601
7602 case 1711: hash_type = HASH_TYPE_SHA512;
7603 salt_type = SALT_TYPE_EMBEDDED;
7604 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7605 opts_type = OPTS_TYPE_PT_GENERATE_BE
7606 | OPTS_TYPE_ST_ADD80
7607 | OPTS_TYPE_ST_ADDBITS15;
7608 kern_type = KERN_TYPE_SHA512_PWSLT;
7609 dgst_size = DGST_SIZE_8_8;
7610 parse_func = sha512b64s_parse_hash;
7611 sort_by_digest = sort_by_digest_8_8;
7612 opti_type = OPTI_TYPE_ZERO_BYTE
7613 | OPTI_TYPE_PRECOMPUTE_INIT
7614 | OPTI_TYPE_PRECOMPUTE_MERKLE
7615 | OPTI_TYPE_EARLY_SKIP
7616 | OPTI_TYPE_NOT_ITERATED
7617 | OPTI_TYPE_APPENDED_SALT
7618 | OPTI_TYPE_RAW_HASH;
7619 dgst_pos0 = 14;
7620 dgst_pos1 = 15;
7621 dgst_pos2 = 6;
7622 dgst_pos3 = 7;
7623 break;
7624
7625 case 1720: hash_type = HASH_TYPE_SHA512;
7626 salt_type = SALT_TYPE_INTERN;
7627 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7628 opts_type = OPTS_TYPE_PT_GENERATE_BE
7629 | OPTS_TYPE_PT_ADD80
7630 | OPTS_TYPE_PT_ADDBITS15;
7631 kern_type = KERN_TYPE_SHA512_SLTPW;
7632 dgst_size = DGST_SIZE_8_8;
7633 parse_func = sha512s_parse_hash;
7634 sort_by_digest = sort_by_digest_8_8;
7635 opti_type = OPTI_TYPE_ZERO_BYTE
7636 | OPTI_TYPE_PRECOMPUTE_INIT
7637 | OPTI_TYPE_PRECOMPUTE_MERKLE
7638 | OPTI_TYPE_EARLY_SKIP
7639 | OPTI_TYPE_NOT_ITERATED
7640 | OPTI_TYPE_PREPENDED_SALT
7641 | OPTI_TYPE_RAW_HASH;
7642 dgst_pos0 = 14;
7643 dgst_pos1 = 15;
7644 dgst_pos2 = 6;
7645 dgst_pos3 = 7;
7646 break;
7647
7648 case 1722: hash_type = HASH_TYPE_SHA512;
7649 salt_type = SALT_TYPE_EMBEDDED;
7650 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7651 opts_type = OPTS_TYPE_PT_GENERATE_BE
7652 | OPTS_TYPE_PT_ADD80
7653 | OPTS_TYPE_PT_ADDBITS15
7654 | OPTS_TYPE_ST_HEX;
7655 kern_type = KERN_TYPE_SHA512_SLTPW;
7656 dgst_size = DGST_SIZE_8_8;
7657 parse_func = osx512_parse_hash;
7658 sort_by_digest = sort_by_digest_8_8;
7659 opti_type = OPTI_TYPE_ZERO_BYTE
7660 | OPTI_TYPE_PRECOMPUTE_INIT
7661 | OPTI_TYPE_PRECOMPUTE_MERKLE
7662 | OPTI_TYPE_EARLY_SKIP
7663 | OPTI_TYPE_NOT_ITERATED
7664 | OPTI_TYPE_PREPENDED_SALT
7665 | OPTI_TYPE_RAW_HASH;
7666 dgst_pos0 = 14;
7667 dgst_pos1 = 15;
7668 dgst_pos2 = 6;
7669 dgst_pos3 = 7;
7670 break;
7671
7672 case 1730: hash_type = HASH_TYPE_SHA512;
7673 salt_type = SALT_TYPE_INTERN;
7674 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7675 opts_type = OPTS_TYPE_PT_GENERATE_BE
7676 | OPTS_TYPE_PT_UNICODE
7677 | OPTS_TYPE_ST_ADD80
7678 | OPTS_TYPE_ST_ADDBITS15;
7679 kern_type = KERN_TYPE_SHA512_PWSLTU;
7680 dgst_size = DGST_SIZE_8_8;
7681 parse_func = sha512s_parse_hash;
7682 sort_by_digest = sort_by_digest_8_8;
7683 opti_type = OPTI_TYPE_ZERO_BYTE
7684 | OPTI_TYPE_PRECOMPUTE_INIT
7685 | OPTI_TYPE_PRECOMPUTE_MERKLE
7686 | OPTI_TYPE_EARLY_SKIP
7687 | OPTI_TYPE_NOT_ITERATED
7688 | OPTI_TYPE_APPENDED_SALT
7689 | OPTI_TYPE_RAW_HASH;
7690 dgst_pos0 = 14;
7691 dgst_pos1 = 15;
7692 dgst_pos2 = 6;
7693 dgst_pos3 = 7;
7694 break;
7695
7696 case 1731: hash_type = HASH_TYPE_SHA512;
7697 salt_type = SALT_TYPE_EMBEDDED;
7698 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7699 opts_type = OPTS_TYPE_PT_GENERATE_BE
7700 | OPTS_TYPE_PT_UNICODE
7701 | OPTS_TYPE_ST_ADD80
7702 | OPTS_TYPE_ST_ADDBITS15
7703 | OPTS_TYPE_ST_HEX;
7704 kern_type = KERN_TYPE_SHA512_PWSLTU;
7705 dgst_size = DGST_SIZE_8_8;
7706 parse_func = mssql2012_parse_hash;
7707 sort_by_digest = sort_by_digest_8_8;
7708 opti_type = OPTI_TYPE_ZERO_BYTE
7709 | OPTI_TYPE_PRECOMPUTE_INIT
7710 | OPTI_TYPE_PRECOMPUTE_MERKLE
7711 | OPTI_TYPE_EARLY_SKIP
7712 | OPTI_TYPE_NOT_ITERATED
7713 | OPTI_TYPE_APPENDED_SALT
7714 | OPTI_TYPE_RAW_HASH;
7715 dgst_pos0 = 14;
7716 dgst_pos1 = 15;
7717 dgst_pos2 = 6;
7718 dgst_pos3 = 7;
7719 break;
7720
7721 case 1740: hash_type = HASH_TYPE_SHA512;
7722 salt_type = SALT_TYPE_INTERN;
7723 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7724 opts_type = OPTS_TYPE_PT_GENERATE_BE
7725 | OPTS_TYPE_PT_ADD80
7726 | OPTS_TYPE_PT_ADDBITS15
7727 | OPTS_TYPE_PT_UNICODE;
7728 kern_type = KERN_TYPE_SHA512_SLTPWU;
7729 dgst_size = DGST_SIZE_8_8;
7730 parse_func = sha512s_parse_hash;
7731 sort_by_digest = sort_by_digest_8_8;
7732 opti_type = OPTI_TYPE_ZERO_BYTE
7733 | OPTI_TYPE_PRECOMPUTE_INIT
7734 | OPTI_TYPE_PRECOMPUTE_MERKLE
7735 | OPTI_TYPE_EARLY_SKIP
7736 | OPTI_TYPE_NOT_ITERATED
7737 | OPTI_TYPE_PREPENDED_SALT
7738 | OPTI_TYPE_RAW_HASH;
7739 dgst_pos0 = 14;
7740 dgst_pos1 = 15;
7741 dgst_pos2 = 6;
7742 dgst_pos3 = 7;
7743 break;
7744
7745 case 1750: hash_type = HASH_TYPE_SHA512;
7746 salt_type = SALT_TYPE_INTERN;
7747 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7748 opts_type = OPTS_TYPE_PT_GENERATE_BE
7749 | OPTS_TYPE_ST_ADD80;
7750 kern_type = KERN_TYPE_HMACSHA512_PW;
7751 dgst_size = DGST_SIZE_8_8;
7752 parse_func = hmacsha512_parse_hash;
7753 sort_by_digest = sort_by_digest_8_8;
7754 opti_type = OPTI_TYPE_ZERO_BYTE
7755 | OPTI_TYPE_NOT_ITERATED;
7756 dgst_pos0 = 14;
7757 dgst_pos1 = 15;
7758 dgst_pos2 = 6;
7759 dgst_pos3 = 7;
7760 break;
7761
7762 case 1760: hash_type = HASH_TYPE_SHA512;
7763 salt_type = SALT_TYPE_INTERN;
7764 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7765 opts_type = OPTS_TYPE_PT_GENERATE_BE
7766 | OPTS_TYPE_PT_ADD80
7767 | OPTS_TYPE_PT_ADDBITS15;
7768 kern_type = KERN_TYPE_HMACSHA512_SLT;
7769 dgst_size = DGST_SIZE_8_8;
7770 parse_func = hmacsha512_parse_hash;
7771 sort_by_digest = sort_by_digest_8_8;
7772 opti_type = OPTI_TYPE_ZERO_BYTE
7773 | OPTI_TYPE_NOT_ITERATED;
7774 dgst_pos0 = 14;
7775 dgst_pos1 = 15;
7776 dgst_pos2 = 6;
7777 dgst_pos3 = 7;
7778 break;
7779
7780 case 1800: hash_type = HASH_TYPE_SHA512;
7781 salt_type = SALT_TYPE_EMBEDDED;
7782 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7783 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7784 kern_type = KERN_TYPE_SHA512CRYPT;
7785 dgst_size = DGST_SIZE_8_8;
7786 parse_func = sha512crypt_parse_hash;
7787 sort_by_digest = sort_by_digest_8_8;
7788 opti_type = OPTI_TYPE_ZERO_BYTE;
7789 dgst_pos0 = 0;
7790 dgst_pos1 = 1;
7791 dgst_pos2 = 2;
7792 dgst_pos3 = 3;
7793 break;
7794
7795 case 2100: hash_type = HASH_TYPE_DCC2;
7796 salt_type = SALT_TYPE_EMBEDDED;
7797 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7798 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
7799 | OPTS_TYPE_ST_LOWER
7800 | OPTS_TYPE_ST_UNICODE;
7801 kern_type = KERN_TYPE_DCC2;
7802 dgst_size = DGST_SIZE_4_4;
7803 parse_func = dcc2_parse_hash;
7804 sort_by_digest = sort_by_digest_4_4;
7805 opti_type = OPTI_TYPE_ZERO_BYTE;
7806 dgst_pos0 = 0;
7807 dgst_pos1 = 1;
7808 dgst_pos2 = 2;
7809 dgst_pos3 = 3;
7810 break;
7811
7812 case 2400: hash_type = HASH_TYPE_MD5;
7813 salt_type = SALT_TYPE_NONE;
7814 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7815 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7816 kern_type = KERN_TYPE_MD5PIX;
7817 dgst_size = DGST_SIZE_4_4;
7818 parse_func = md5pix_parse_hash;
7819 sort_by_digest = sort_by_digest_4_4;
7820 opti_type = OPTI_TYPE_ZERO_BYTE
7821 | OPTI_TYPE_PRECOMPUTE_INIT
7822 | OPTI_TYPE_PRECOMPUTE_MERKLE
7823 | OPTI_TYPE_EARLY_SKIP
7824 | OPTI_TYPE_NOT_ITERATED
7825 | OPTI_TYPE_NOT_SALTED;
7826 dgst_pos0 = 0;
7827 dgst_pos1 = 3;
7828 dgst_pos2 = 2;
7829 dgst_pos3 = 1;
7830 break;
7831
7832 case 2410: hash_type = HASH_TYPE_MD5;
7833 salt_type = SALT_TYPE_INTERN;
7834 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7835 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7836 kern_type = KERN_TYPE_MD5ASA;
7837 dgst_size = DGST_SIZE_4_4;
7838 parse_func = md5asa_parse_hash;
7839 sort_by_digest = sort_by_digest_4_4;
7840 opti_type = OPTI_TYPE_ZERO_BYTE
7841 | OPTI_TYPE_PRECOMPUTE_INIT
7842 | OPTI_TYPE_PRECOMPUTE_MERKLE
7843 | OPTI_TYPE_EARLY_SKIP
7844 | OPTI_TYPE_NOT_ITERATED;
7845 dgst_pos0 = 0;
7846 dgst_pos1 = 3;
7847 dgst_pos2 = 2;
7848 dgst_pos3 = 1;
7849 break;
7850
7851 case 2500: hash_type = HASH_TYPE_WPA;
7852 salt_type = SALT_TYPE_EMBEDDED;
7853 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7854 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7855 kern_type = KERN_TYPE_WPA;
7856 dgst_size = DGST_SIZE_4_4;
7857 parse_func = wpa_parse_hash;
7858 sort_by_digest = sort_by_digest_4_4;
7859 opti_type = OPTI_TYPE_ZERO_BYTE;
7860 dgst_pos0 = 0;
7861 dgst_pos1 = 1;
7862 dgst_pos2 = 2;
7863 dgst_pos3 = 3;
7864 break;
7865
7866 case 2600: hash_type = HASH_TYPE_MD5;
7867 salt_type = SALT_TYPE_VIRTUAL;
7868 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7869 opts_type = OPTS_TYPE_PT_GENERATE_LE
7870 | OPTS_TYPE_PT_ADD80
7871 | OPTS_TYPE_PT_ADDBITS14
7872 | OPTS_TYPE_ST_ADD80;
7873 kern_type = KERN_TYPE_MD55_PWSLT1;
7874 dgst_size = DGST_SIZE_4_4;
7875 parse_func = md5md5_parse_hash;
7876 sort_by_digest = sort_by_digest_4_4;
7877 opti_type = OPTI_TYPE_ZERO_BYTE
7878 | OPTI_TYPE_PRECOMPUTE_INIT
7879 | OPTI_TYPE_PRECOMPUTE_MERKLE
7880 | OPTI_TYPE_EARLY_SKIP;
7881 dgst_pos0 = 0;
7882 dgst_pos1 = 3;
7883 dgst_pos2 = 2;
7884 dgst_pos3 = 1;
7885 break;
7886
7887 case 2611: 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 | OPTS_TYPE_PT_ADD80
7892 | OPTS_TYPE_PT_ADDBITS14
7893 | OPTS_TYPE_ST_ADD80;
7894 kern_type = KERN_TYPE_MD55_PWSLT1;
7895 dgst_size = DGST_SIZE_4_4;
7896 parse_func = vb3_parse_hash;
7897 sort_by_digest = sort_by_digest_4_4;
7898 opti_type = OPTI_TYPE_ZERO_BYTE
7899 | OPTI_TYPE_PRECOMPUTE_INIT
7900 | OPTI_TYPE_PRECOMPUTE_MERKLE
7901 | OPTI_TYPE_EARLY_SKIP;
7902 dgst_pos0 = 0;
7903 dgst_pos1 = 3;
7904 dgst_pos2 = 2;
7905 dgst_pos3 = 1;
7906 break;
7907
7908 case 2612: hash_type = HASH_TYPE_MD5;
7909 salt_type = SALT_TYPE_EMBEDDED;
7910 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7911 opts_type = OPTS_TYPE_PT_GENERATE_LE
7912 | OPTS_TYPE_PT_ADD80
7913 | OPTS_TYPE_PT_ADDBITS14
7914 | OPTS_TYPE_ST_ADD80
7915 | OPTS_TYPE_ST_HEX;
7916 kern_type = KERN_TYPE_MD55_PWSLT1;
7917 dgst_size = DGST_SIZE_4_4;
7918 parse_func = phps_parse_hash;
7919 sort_by_digest = sort_by_digest_4_4;
7920 opti_type = OPTI_TYPE_ZERO_BYTE
7921 | OPTI_TYPE_PRECOMPUTE_INIT
7922 | OPTI_TYPE_PRECOMPUTE_MERKLE
7923 | OPTI_TYPE_EARLY_SKIP;
7924 dgst_pos0 = 0;
7925 dgst_pos1 = 3;
7926 dgst_pos2 = 2;
7927 dgst_pos3 = 1;
7928 break;
7929
7930 case 2711: hash_type = HASH_TYPE_MD5;
7931 salt_type = SALT_TYPE_INTERN;
7932 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7933 opts_type = OPTS_TYPE_PT_GENERATE_LE
7934 | OPTS_TYPE_PT_ADD80
7935 | OPTS_TYPE_PT_ADDBITS14
7936 | OPTS_TYPE_ST_ADD80;
7937 kern_type = KERN_TYPE_MD55_PWSLT2;
7938 dgst_size = DGST_SIZE_4_4;
7939 parse_func = vb30_parse_hash;
7940 sort_by_digest = sort_by_digest_4_4;
7941 opti_type = OPTI_TYPE_ZERO_BYTE
7942 | OPTI_TYPE_PRECOMPUTE_INIT
7943 | OPTI_TYPE_EARLY_SKIP;
7944 dgst_pos0 = 0;
7945 dgst_pos1 = 3;
7946 dgst_pos2 = 2;
7947 dgst_pos3 = 1;
7948 break;
7949
7950 case 2811: hash_type = HASH_TYPE_MD5;
7951 salt_type = SALT_TYPE_INTERN;
7952 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7953 opts_type = OPTS_TYPE_PT_GENERATE_LE
7954 | OPTS_TYPE_PT_ADD80
7955 | OPTS_TYPE_PT_ADDBITS14;
7956 kern_type = KERN_TYPE_MD55_SLTPW;
7957 dgst_size = DGST_SIZE_4_4;
7958 parse_func = ipb2_parse_hash;
7959 sort_by_digest = sort_by_digest_4_4;
7960 opti_type = OPTI_TYPE_ZERO_BYTE
7961 | OPTI_TYPE_PRECOMPUTE_INIT
7962 | OPTI_TYPE_EARLY_SKIP;
7963 dgst_pos0 = 0;
7964 dgst_pos1 = 3;
7965 dgst_pos2 = 2;
7966 dgst_pos3 = 1;
7967 break;
7968
7969 case 3000: hash_type = HASH_TYPE_LM;
7970 salt_type = SALT_TYPE_NONE;
7971 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7972 opts_type = OPTS_TYPE_PT_GENERATE_LE
7973 | OPTS_TYPE_PT_UPPER
7974 | OPTS_TYPE_PT_BITSLICE;
7975 kern_type = KERN_TYPE_LM;
7976 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7977 parse_func = lm_parse_hash;
7978 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7979 opti_type = OPTI_TYPE_ZERO_BYTE
7980 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7981 dgst_pos0 = 0;
7982 dgst_pos1 = 1;
7983 dgst_pos2 = 2;
7984 dgst_pos3 = 3;
7985 break;
7986
7987 case 3100: hash_type = HASH_TYPE_ORACLEH;
7988 salt_type = SALT_TYPE_INTERN;
7989 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7990 opts_type = OPTS_TYPE_PT_GENERATE_LE
7991 | OPTS_TYPE_PT_UPPER
7992 | OPTS_TYPE_ST_UPPER;
7993 kern_type = KERN_TYPE_ORACLEH;
7994 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7995 parse_func = oracleh_parse_hash;
7996 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7997 opti_type = OPTI_TYPE_ZERO_BYTE;
7998 dgst_pos0 = 0;
7999 dgst_pos1 = 1;
8000 dgst_pos2 = 2;
8001 dgst_pos3 = 3;
8002 break;
8003
8004 case 3200: hash_type = HASH_TYPE_BCRYPT;
8005 salt_type = SALT_TYPE_EMBEDDED;
8006 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8007 opts_type = OPTS_TYPE_PT_GENERATE_LE
8008 | OPTS_TYPE_ST_GENERATE_LE;
8009 kern_type = KERN_TYPE_BCRYPT;
8010 dgst_size = DGST_SIZE_4_6;
8011 parse_func = bcrypt_parse_hash;
8012 sort_by_digest = sort_by_digest_4_6;
8013 opti_type = OPTI_TYPE_ZERO_BYTE;
8014 dgst_pos0 = 0;
8015 dgst_pos1 = 1;
8016 dgst_pos2 = 2;
8017 dgst_pos3 = 3;
8018 break;
8019
8020 case 3710: hash_type = HASH_TYPE_MD5;
8021 salt_type = SALT_TYPE_INTERN;
8022 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8023 opts_type = OPTS_TYPE_PT_GENERATE_LE
8024 | OPTS_TYPE_PT_ADD80
8025 | OPTS_TYPE_PT_ADDBITS14;
8026 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8027 dgst_size = DGST_SIZE_4_4;
8028 parse_func = md5s_parse_hash;
8029 sort_by_digest = sort_by_digest_4_4;
8030 opti_type = OPTI_TYPE_ZERO_BYTE
8031 | OPTI_TYPE_PRECOMPUTE_INIT
8032 | OPTI_TYPE_PRECOMPUTE_MERKLE
8033 | OPTI_TYPE_EARLY_SKIP;
8034 dgst_pos0 = 0;
8035 dgst_pos1 = 3;
8036 dgst_pos2 = 2;
8037 dgst_pos3 = 1;
8038 break;
8039
8040 case 3711: hash_type = HASH_TYPE_MD5;
8041 salt_type = SALT_TYPE_EMBEDDED;
8042 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8043 opts_type = OPTS_TYPE_PT_GENERATE_LE
8044 | OPTS_TYPE_PT_ADD80
8045 | OPTS_TYPE_PT_ADDBITS14;
8046 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8047 dgst_size = DGST_SIZE_4_4;
8048 parse_func = mediawiki_b_parse_hash;
8049 sort_by_digest = sort_by_digest_4_4;
8050 opti_type = OPTI_TYPE_ZERO_BYTE
8051 | OPTI_TYPE_PRECOMPUTE_INIT
8052 | OPTI_TYPE_PRECOMPUTE_MERKLE
8053 | OPTI_TYPE_EARLY_SKIP;
8054 dgst_pos0 = 0;
8055 dgst_pos1 = 3;
8056 dgst_pos2 = 2;
8057 dgst_pos3 = 1;
8058 break;
8059
8060 case 3800: hash_type = HASH_TYPE_MD5;
8061 salt_type = SALT_TYPE_INTERN;
8062 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8063 opts_type = OPTS_TYPE_PT_GENERATE_LE
8064 | OPTS_TYPE_ST_ADDBITS14;
8065 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8066 dgst_size = DGST_SIZE_4_4;
8067 parse_func = md5s_parse_hash;
8068 sort_by_digest = sort_by_digest_4_4;
8069 opti_type = OPTI_TYPE_ZERO_BYTE
8070 | OPTI_TYPE_PRECOMPUTE_INIT
8071 | OPTI_TYPE_PRECOMPUTE_MERKLE
8072 | OPTI_TYPE_EARLY_SKIP
8073 | OPTI_TYPE_NOT_ITERATED
8074 | OPTI_TYPE_RAW_HASH;
8075 dgst_pos0 = 0;
8076 dgst_pos1 = 3;
8077 dgst_pos2 = 2;
8078 dgst_pos3 = 1;
8079 break;
8080
8081 case 4300: hash_type = HASH_TYPE_MD5;
8082 salt_type = SALT_TYPE_VIRTUAL;
8083 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8084 opts_type = OPTS_TYPE_PT_GENERATE_LE
8085 | OPTS_TYPE_PT_ADD80
8086 | OPTS_TYPE_PT_ADDBITS14
8087 | OPTS_TYPE_ST_ADD80;
8088 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8089 dgst_size = DGST_SIZE_4_4;
8090 parse_func = md5md5_parse_hash;
8091 sort_by_digest = sort_by_digest_4_4;
8092 opti_type = OPTI_TYPE_ZERO_BYTE
8093 | OPTI_TYPE_PRECOMPUTE_INIT
8094 | OPTI_TYPE_PRECOMPUTE_MERKLE
8095 | OPTI_TYPE_EARLY_SKIP;
8096 dgst_pos0 = 0;
8097 dgst_pos1 = 3;
8098 dgst_pos2 = 2;
8099 dgst_pos3 = 1;
8100 break;
8101
8102
8103 case 4400: hash_type = HASH_TYPE_MD5;
8104 salt_type = SALT_TYPE_NONE;
8105 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8106 opts_type = OPTS_TYPE_PT_GENERATE_BE
8107 | OPTS_TYPE_PT_ADD80
8108 | OPTS_TYPE_PT_ADDBITS15;
8109 kern_type = KERN_TYPE_MD5_SHA1;
8110 dgst_size = DGST_SIZE_4_4;
8111 parse_func = md5_parse_hash;
8112 sort_by_digest = sort_by_digest_4_4;
8113 opti_type = OPTI_TYPE_ZERO_BYTE
8114 | OPTI_TYPE_PRECOMPUTE_INIT
8115 | OPTI_TYPE_PRECOMPUTE_MERKLE
8116 | OPTI_TYPE_EARLY_SKIP
8117 | OPTI_TYPE_NOT_ITERATED
8118 | OPTI_TYPE_NOT_SALTED
8119 | OPTI_TYPE_RAW_HASH;
8120 dgst_pos0 = 0;
8121 dgst_pos1 = 3;
8122 dgst_pos2 = 2;
8123 dgst_pos3 = 1;
8124 break;
8125
8126 case 4500: hash_type = HASH_TYPE_SHA1;
8127 salt_type = SALT_TYPE_NONE;
8128 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8129 opts_type = OPTS_TYPE_PT_GENERATE_BE
8130 | OPTS_TYPE_PT_ADD80
8131 | OPTS_TYPE_PT_ADDBITS15;
8132 kern_type = KERN_TYPE_SHA11;
8133 dgst_size = DGST_SIZE_4_5;
8134 parse_func = sha1_parse_hash;
8135 sort_by_digest = sort_by_digest_4_5;
8136 opti_type = OPTI_TYPE_ZERO_BYTE
8137 | OPTI_TYPE_PRECOMPUTE_INIT
8138 | OPTI_TYPE_PRECOMPUTE_MERKLE
8139 | OPTI_TYPE_EARLY_SKIP
8140 | OPTI_TYPE_NOT_SALTED;
8141 dgst_pos0 = 3;
8142 dgst_pos1 = 4;
8143 dgst_pos2 = 2;
8144 dgst_pos3 = 1;
8145 break;
8146
8147 case 4700: hash_type = HASH_TYPE_SHA1;
8148 salt_type = SALT_TYPE_NONE;
8149 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8150 opts_type = OPTS_TYPE_PT_GENERATE_LE
8151 | OPTS_TYPE_PT_ADD80
8152 | OPTS_TYPE_PT_ADDBITS14;
8153 kern_type = KERN_TYPE_SHA1_MD5;
8154 dgst_size = DGST_SIZE_4_5;
8155 parse_func = sha1_parse_hash;
8156 sort_by_digest = sort_by_digest_4_5;
8157 opti_type = OPTI_TYPE_ZERO_BYTE
8158 | OPTI_TYPE_PRECOMPUTE_INIT
8159 | OPTI_TYPE_PRECOMPUTE_MERKLE
8160 | OPTI_TYPE_EARLY_SKIP
8161 | OPTI_TYPE_NOT_ITERATED
8162 | OPTI_TYPE_NOT_SALTED
8163 | OPTI_TYPE_RAW_HASH;
8164 dgst_pos0 = 3;
8165 dgst_pos1 = 4;
8166 dgst_pos2 = 2;
8167 dgst_pos3 = 1;
8168 break;
8169
8170 case 4800: hash_type = HASH_TYPE_MD5;
8171 salt_type = SALT_TYPE_EMBEDDED;
8172 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8173 opts_type = OPTS_TYPE_PT_GENERATE_LE
8174 | OPTS_TYPE_PT_ADDBITS14;
8175 kern_type = KERN_TYPE_MD5_CHAP;
8176 dgst_size = DGST_SIZE_4_4;
8177 parse_func = chap_parse_hash;
8178 sort_by_digest = sort_by_digest_4_4;
8179 opti_type = OPTI_TYPE_ZERO_BYTE
8180 | OPTI_TYPE_PRECOMPUTE_INIT
8181 | OPTI_TYPE_PRECOMPUTE_MERKLE
8182 | OPTI_TYPE_MEET_IN_MIDDLE
8183 | OPTI_TYPE_EARLY_SKIP
8184 | OPTI_TYPE_NOT_ITERATED
8185 | OPTI_TYPE_RAW_HASH;
8186 dgst_pos0 = 0;
8187 dgst_pos1 = 3;
8188 dgst_pos2 = 2;
8189 dgst_pos3 = 1;
8190 break;
8191
8192 case 4900: hash_type = HASH_TYPE_SHA1;
8193 salt_type = SALT_TYPE_INTERN;
8194 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8195 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8196 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8197 dgst_size = DGST_SIZE_4_5;
8198 parse_func = sha1s_parse_hash;
8199 sort_by_digest = sort_by_digest_4_5;
8200 opti_type = OPTI_TYPE_ZERO_BYTE
8201 | OPTI_TYPE_PRECOMPUTE_INIT
8202 | OPTI_TYPE_PRECOMPUTE_MERKLE
8203 | OPTI_TYPE_EARLY_SKIP;
8204 dgst_pos0 = 3;
8205 dgst_pos1 = 4;
8206 dgst_pos2 = 2;
8207 dgst_pos3 = 1;
8208 break;
8209
8210 case 5000: hash_type = HASH_TYPE_KECCAK;
8211 salt_type = SALT_TYPE_EMBEDDED;
8212 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8213 opts_type = OPTS_TYPE_PT_GENERATE_LE
8214 | OPTS_TYPE_PT_ADD01;
8215 kern_type = KERN_TYPE_KECCAK;
8216 dgst_size = DGST_SIZE_8_25;
8217 parse_func = keccak_parse_hash;
8218 sort_by_digest = sort_by_digest_8_25;
8219 opti_type = OPTI_TYPE_ZERO_BYTE
8220 | OPTI_TYPE_RAW_HASH;
8221 dgst_pos0 = 2;
8222 dgst_pos1 = 3;
8223 dgst_pos2 = 4;
8224 dgst_pos3 = 5;
8225 break;
8226
8227 case 5100: hash_type = HASH_TYPE_MD5H;
8228 salt_type = SALT_TYPE_NONE;
8229 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8230 opts_type = OPTS_TYPE_PT_GENERATE_LE
8231 | OPTS_TYPE_PT_ADD80
8232 | OPTS_TYPE_PT_ADDBITS14;
8233 kern_type = KERN_TYPE_MD5H;
8234 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8235 parse_func = md5half_parse_hash;
8236 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8237 opti_type = OPTI_TYPE_ZERO_BYTE
8238 | OPTI_TYPE_RAW_HASH;
8239 dgst_pos0 = 0;
8240 dgst_pos1 = 1;
8241 dgst_pos2 = 2;
8242 dgst_pos3 = 3;
8243 break;
8244
8245 case 5200: hash_type = HASH_TYPE_SHA256;
8246 salt_type = SALT_TYPE_EMBEDDED;
8247 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8248 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8249 kern_type = KERN_TYPE_PSAFE3;
8250 dgst_size = DGST_SIZE_4_8;
8251 parse_func = psafe3_parse_hash;
8252 sort_by_digest = sort_by_digest_4_8;
8253 opti_type = OPTI_TYPE_ZERO_BYTE;
8254 dgst_pos0 = 0;
8255 dgst_pos1 = 1;
8256 dgst_pos2 = 2;
8257 dgst_pos3 = 3;
8258 break;
8259
8260 case 5300: hash_type = HASH_TYPE_MD5;
8261 salt_type = SALT_TYPE_EMBEDDED;
8262 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8263 opts_type = OPTS_TYPE_PT_GENERATE_LE
8264 | OPTS_TYPE_ST_ADD80;
8265 kern_type = KERN_TYPE_IKEPSK_MD5;
8266 dgst_size = DGST_SIZE_4_4;
8267 parse_func = ikepsk_md5_parse_hash;
8268 sort_by_digest = sort_by_digest_4_4;
8269 opti_type = OPTI_TYPE_ZERO_BYTE;
8270 dgst_pos0 = 0;
8271 dgst_pos1 = 3;
8272 dgst_pos2 = 2;
8273 dgst_pos3 = 1;
8274 break;
8275
8276 case 5400: hash_type = HASH_TYPE_SHA1;
8277 salt_type = SALT_TYPE_EMBEDDED;
8278 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8279 opts_type = OPTS_TYPE_PT_GENERATE_BE
8280 | OPTS_TYPE_ST_ADD80;
8281 kern_type = KERN_TYPE_IKEPSK_SHA1;
8282 dgst_size = DGST_SIZE_4_5;
8283 parse_func = ikepsk_sha1_parse_hash;
8284 sort_by_digest = sort_by_digest_4_5;
8285 opti_type = OPTI_TYPE_ZERO_BYTE;
8286 dgst_pos0 = 3;
8287 dgst_pos1 = 4;
8288 dgst_pos2 = 2;
8289 dgst_pos3 = 1;
8290 break;
8291
8292 case 5500: hash_type = HASH_TYPE_NETNTLM;
8293 salt_type = SALT_TYPE_EMBEDDED;
8294 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8295 opts_type = OPTS_TYPE_PT_GENERATE_LE
8296 | OPTS_TYPE_PT_ADD80
8297 | OPTS_TYPE_PT_ADDBITS14
8298 | OPTS_TYPE_PT_UNICODE
8299 | OPTS_TYPE_ST_HEX;
8300 kern_type = KERN_TYPE_NETNTLMv1;
8301 dgst_size = DGST_SIZE_4_4;
8302 parse_func = netntlmv1_parse_hash;
8303 sort_by_digest = sort_by_digest_4_4;
8304 opti_type = OPTI_TYPE_ZERO_BYTE
8305 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8306 dgst_pos0 = 0;
8307 dgst_pos1 = 1;
8308 dgst_pos2 = 2;
8309 dgst_pos3 = 3;
8310 break;
8311
8312 case 5600: hash_type = HASH_TYPE_MD5;
8313 salt_type = SALT_TYPE_EMBEDDED;
8314 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8315 opts_type = OPTS_TYPE_PT_GENERATE_LE
8316 | OPTS_TYPE_PT_ADD80
8317 | OPTS_TYPE_PT_ADDBITS14
8318 | OPTS_TYPE_PT_UNICODE;
8319 kern_type = KERN_TYPE_NETNTLMv2;
8320 dgst_size = DGST_SIZE_4_4;
8321 parse_func = netntlmv2_parse_hash;
8322 sort_by_digest = sort_by_digest_4_4;
8323 opti_type = OPTI_TYPE_ZERO_BYTE;
8324 dgst_pos0 = 0;
8325 dgst_pos1 = 3;
8326 dgst_pos2 = 2;
8327 dgst_pos3 = 1;
8328 break;
8329
8330 case 5700: hash_type = HASH_TYPE_SHA256;
8331 salt_type = SALT_TYPE_NONE;
8332 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8333 opts_type = OPTS_TYPE_PT_GENERATE_BE
8334 | OPTS_TYPE_PT_ADD80
8335 | OPTS_TYPE_PT_ADDBITS15;
8336 kern_type = KERN_TYPE_SHA256;
8337 dgst_size = DGST_SIZE_4_8;
8338 parse_func = cisco4_parse_hash;
8339 sort_by_digest = sort_by_digest_4_8;
8340 opti_type = OPTI_TYPE_ZERO_BYTE
8341 | OPTI_TYPE_PRECOMPUTE_INIT
8342 | OPTI_TYPE_PRECOMPUTE_MERKLE
8343 | OPTI_TYPE_EARLY_SKIP
8344 | OPTI_TYPE_NOT_ITERATED
8345 | OPTI_TYPE_NOT_SALTED
8346 | OPTI_TYPE_RAW_HASH;
8347 dgst_pos0 = 3;
8348 dgst_pos1 = 7;
8349 dgst_pos2 = 2;
8350 dgst_pos3 = 6;
8351 break;
8352
8353 case 5800: hash_type = HASH_TYPE_SHA1;
8354 salt_type = SALT_TYPE_INTERN;
8355 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8356 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8357 | OPTS_TYPE_ST_ADD80;
8358 kern_type = KERN_TYPE_ANDROIDPIN;
8359 dgst_size = DGST_SIZE_4_5;
8360 parse_func = androidpin_parse_hash;
8361 sort_by_digest = sort_by_digest_4_5;
8362 opti_type = OPTI_TYPE_ZERO_BYTE;
8363 dgst_pos0 = 0;
8364 dgst_pos1 = 1;
8365 dgst_pos2 = 2;
8366 dgst_pos3 = 3;
8367 break;
8368
8369 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8370 salt_type = SALT_TYPE_NONE;
8371 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8372 opts_type = OPTS_TYPE_PT_GENERATE_LE
8373 | OPTS_TYPE_PT_ADD80;
8374 kern_type = KERN_TYPE_RIPEMD160;
8375 dgst_size = DGST_SIZE_4_5;
8376 parse_func = ripemd160_parse_hash;
8377 sort_by_digest = sort_by_digest_4_5;
8378 opti_type = OPTI_TYPE_ZERO_BYTE;
8379 dgst_pos0 = 0;
8380 dgst_pos1 = 1;
8381 dgst_pos2 = 2;
8382 dgst_pos3 = 3;
8383 break;
8384
8385 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
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 kern_type = KERN_TYPE_WHIRLPOOL;
8391 dgst_size = DGST_SIZE_4_16;
8392 parse_func = whirlpool_parse_hash;
8393 sort_by_digest = sort_by_digest_4_16;
8394 opti_type = OPTI_TYPE_ZERO_BYTE;
8395 dgst_pos0 = 0;
8396 dgst_pos1 = 1;
8397 dgst_pos2 = 2;
8398 dgst_pos3 = 3;
8399 break;
8400
8401 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8402 salt_type = SALT_TYPE_EMBEDDED;
8403 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8404 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8405 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8406 dgst_size = DGST_SIZE_4_5;
8407 parse_func = truecrypt_parse_hash_2k;
8408 sort_by_digest = sort_by_digest_4_5;
8409 opti_type = OPTI_TYPE_ZERO_BYTE;
8410 dgst_pos0 = 0;
8411 dgst_pos1 = 1;
8412 dgst_pos2 = 2;
8413 dgst_pos3 = 3;
8414 break;
8415
8416 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8417 salt_type = SALT_TYPE_EMBEDDED;
8418 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8419 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8420 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8421 dgst_size = DGST_SIZE_4_5;
8422 parse_func = truecrypt_parse_hash_2k;
8423 sort_by_digest = sort_by_digest_4_5;
8424 opti_type = OPTI_TYPE_ZERO_BYTE;
8425 dgst_pos0 = 0;
8426 dgst_pos1 = 1;
8427 dgst_pos2 = 2;
8428 dgst_pos3 = 3;
8429 break;
8430
8431 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8432 salt_type = SALT_TYPE_EMBEDDED;
8433 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8434 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8435 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8436 dgst_size = DGST_SIZE_4_5;
8437 parse_func = truecrypt_parse_hash_2k;
8438 sort_by_digest = sort_by_digest_4_5;
8439 opti_type = OPTI_TYPE_ZERO_BYTE;
8440 dgst_pos0 = 0;
8441 dgst_pos1 = 1;
8442 dgst_pos2 = 2;
8443 dgst_pos3 = 3;
8444 break;
8445
8446 case 6221: hash_type = HASH_TYPE_SHA512;
8447 salt_type = SALT_TYPE_EMBEDDED;
8448 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8449 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8450 kern_type = KERN_TYPE_TCSHA512_XTS512;
8451 dgst_size = DGST_SIZE_8_8;
8452 parse_func = truecrypt_parse_hash_1k;
8453 sort_by_digest = sort_by_digest_8_8;
8454 opti_type = OPTI_TYPE_ZERO_BYTE;
8455 dgst_pos0 = 0;
8456 dgst_pos1 = 1;
8457 dgst_pos2 = 2;
8458 dgst_pos3 = 3;
8459 break;
8460
8461 case 6222: hash_type = HASH_TYPE_SHA512;
8462 salt_type = SALT_TYPE_EMBEDDED;
8463 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8464 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8465 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8466 dgst_size = DGST_SIZE_8_8;
8467 parse_func = truecrypt_parse_hash_1k;
8468 sort_by_digest = sort_by_digest_8_8;
8469 opti_type = OPTI_TYPE_ZERO_BYTE;
8470 dgst_pos0 = 0;
8471 dgst_pos1 = 1;
8472 dgst_pos2 = 2;
8473 dgst_pos3 = 3;
8474 break;
8475
8476 case 6223: hash_type = HASH_TYPE_SHA512;
8477 salt_type = SALT_TYPE_EMBEDDED;
8478 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8479 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8480 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8481 dgst_size = DGST_SIZE_8_8;
8482 parse_func = truecrypt_parse_hash_1k;
8483 sort_by_digest = sort_by_digest_8_8;
8484 opti_type = OPTI_TYPE_ZERO_BYTE;
8485 dgst_pos0 = 0;
8486 dgst_pos1 = 1;
8487 dgst_pos2 = 2;
8488 dgst_pos3 = 3;
8489 break;
8490
8491 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8492 salt_type = SALT_TYPE_EMBEDDED;
8493 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8494 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8495 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8496 dgst_size = DGST_SIZE_4_8;
8497 parse_func = truecrypt_parse_hash_1k;
8498 sort_by_digest = sort_by_digest_4_8;
8499 opti_type = OPTI_TYPE_ZERO_BYTE;
8500 dgst_pos0 = 0;
8501 dgst_pos1 = 1;
8502 dgst_pos2 = 2;
8503 dgst_pos3 = 3;
8504 break;
8505
8506 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8507 salt_type = SALT_TYPE_EMBEDDED;
8508 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8509 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8510 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8511 dgst_size = DGST_SIZE_4_8;
8512 parse_func = truecrypt_parse_hash_1k;
8513 sort_by_digest = sort_by_digest_4_8;
8514 opti_type = OPTI_TYPE_ZERO_BYTE;
8515 dgst_pos0 = 0;
8516 dgst_pos1 = 1;
8517 dgst_pos2 = 2;
8518 dgst_pos3 = 3;
8519 break;
8520
8521 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8522 salt_type = SALT_TYPE_EMBEDDED;
8523 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8524 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8525 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8526 dgst_size = DGST_SIZE_4_8;
8527 parse_func = truecrypt_parse_hash_1k;
8528 sort_by_digest = sort_by_digest_4_8;
8529 opti_type = OPTI_TYPE_ZERO_BYTE;
8530 dgst_pos0 = 0;
8531 dgst_pos1 = 1;
8532 dgst_pos2 = 2;
8533 dgst_pos3 = 3;
8534 break;
8535
8536 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8537 salt_type = SALT_TYPE_EMBEDDED;
8538 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8539 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8540 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8541 dgst_size = DGST_SIZE_4_5;
8542 parse_func = truecrypt_parse_hash_1k;
8543 sort_by_digest = sort_by_digest_4_5;
8544 opti_type = OPTI_TYPE_ZERO_BYTE;
8545 dgst_pos0 = 0;
8546 dgst_pos1 = 1;
8547 dgst_pos2 = 2;
8548 dgst_pos3 = 3;
8549 break;
8550
8551 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8552 salt_type = SALT_TYPE_EMBEDDED;
8553 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8554 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8555 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8556 dgst_size = DGST_SIZE_4_5;
8557 parse_func = truecrypt_parse_hash_1k;
8558 sort_by_digest = sort_by_digest_4_5;
8559 opti_type = OPTI_TYPE_ZERO_BYTE;
8560 dgst_pos0 = 0;
8561 dgst_pos1 = 1;
8562 dgst_pos2 = 2;
8563 dgst_pos3 = 3;
8564 break;
8565
8566 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8567 salt_type = SALT_TYPE_EMBEDDED;
8568 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8569 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8570 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8571 dgst_size = DGST_SIZE_4_5;
8572 parse_func = truecrypt_parse_hash_1k;
8573 sort_by_digest = sort_by_digest_4_5;
8574 opti_type = OPTI_TYPE_ZERO_BYTE;
8575 dgst_pos0 = 0;
8576 dgst_pos1 = 1;
8577 dgst_pos2 = 2;
8578 dgst_pos3 = 3;
8579 break;
8580
8581 case 6300: hash_type = HASH_TYPE_MD5;
8582 salt_type = SALT_TYPE_EMBEDDED;
8583 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8584 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8585 kern_type = KERN_TYPE_MD5AIX;
8586 dgst_size = DGST_SIZE_4_4;
8587 parse_func = md5aix_parse_hash;
8588 sort_by_digest = sort_by_digest_4_4;
8589 opti_type = OPTI_TYPE_ZERO_BYTE;
8590 dgst_pos0 = 0;
8591 dgst_pos1 = 1;
8592 dgst_pos2 = 2;
8593 dgst_pos3 = 3;
8594 break;
8595
8596 case 6400: hash_type = HASH_TYPE_SHA256;
8597 salt_type = SALT_TYPE_EMBEDDED;
8598 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8599 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8600 kern_type = KERN_TYPE_SHA256AIX;
8601 dgst_size = DGST_SIZE_4_8;
8602 parse_func = sha256aix_parse_hash;
8603 sort_by_digest = sort_by_digest_4_8;
8604 opti_type = OPTI_TYPE_ZERO_BYTE;
8605 dgst_pos0 = 0;
8606 dgst_pos1 = 1;
8607 dgst_pos2 = 2;
8608 dgst_pos3 = 3;
8609 break;
8610
8611 case 6500: hash_type = HASH_TYPE_SHA512;
8612 salt_type = SALT_TYPE_EMBEDDED;
8613 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8614 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8615 kern_type = KERN_TYPE_SHA512AIX;
8616 dgst_size = DGST_SIZE_8_8;
8617 parse_func = sha512aix_parse_hash;
8618 sort_by_digest = sort_by_digest_8_8;
8619 opti_type = OPTI_TYPE_ZERO_BYTE;
8620 dgst_pos0 = 0;
8621 dgst_pos1 = 1;
8622 dgst_pos2 = 2;
8623 dgst_pos3 = 3;
8624 break;
8625
8626 case 6600: hash_type = HASH_TYPE_AES;
8627 salt_type = SALT_TYPE_EMBEDDED;
8628 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8629 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8630 kern_type = KERN_TYPE_AGILEKEY;
8631 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8632 parse_func = agilekey_parse_hash;
8633 sort_by_digest = sort_by_digest_4_5;
8634 opti_type = OPTI_TYPE_ZERO_BYTE;
8635 dgst_pos0 = 0;
8636 dgst_pos1 = 1;
8637 dgst_pos2 = 2;
8638 dgst_pos3 = 3;
8639 break;
8640
8641 case 6700: hash_type = HASH_TYPE_SHA1;
8642 salt_type = SALT_TYPE_EMBEDDED;
8643 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8644 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8645 kern_type = KERN_TYPE_SHA1AIX;
8646 dgst_size = DGST_SIZE_4_5;
8647 parse_func = sha1aix_parse_hash;
8648 sort_by_digest = sort_by_digest_4_5;
8649 opti_type = OPTI_TYPE_ZERO_BYTE;
8650 dgst_pos0 = 0;
8651 dgst_pos1 = 1;
8652 dgst_pos2 = 2;
8653 dgst_pos3 = 3;
8654 break;
8655
8656 case 6800: hash_type = HASH_TYPE_AES;
8657 salt_type = SALT_TYPE_EMBEDDED;
8658 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8659 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8660 kern_type = KERN_TYPE_LASTPASS;
8661 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
8662 parse_func = lastpass_parse_hash;
8663 sort_by_digest = sort_by_digest_4_8;
8664 opti_type = OPTI_TYPE_ZERO_BYTE;
8665 dgst_pos0 = 0;
8666 dgst_pos1 = 1;
8667 dgst_pos2 = 2;
8668 dgst_pos3 = 3;
8669 break;
8670
8671 case 6900: hash_type = HASH_TYPE_GOST;
8672 salt_type = SALT_TYPE_NONE;
8673 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8674 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8675 kern_type = KERN_TYPE_GOST;
8676 dgst_size = DGST_SIZE_4_8;
8677 parse_func = gost_parse_hash;
8678 sort_by_digest = sort_by_digest_4_8;
8679 opti_type = OPTI_TYPE_ZERO_BYTE;
8680 dgst_pos0 = 0;
8681 dgst_pos1 = 1;
8682 dgst_pos2 = 2;
8683 dgst_pos3 = 3;
8684 break;
8685
8686 case 7100: hash_type = HASH_TYPE_SHA512;
8687 salt_type = SALT_TYPE_EMBEDDED;
8688 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8689 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8690 kern_type = KERN_TYPE_PBKDF2_SHA512;
8691 dgst_size = DGST_SIZE_8_16;
8692 parse_func = sha512osx_parse_hash;
8693 sort_by_digest = sort_by_digest_8_16;
8694 opti_type = OPTI_TYPE_ZERO_BYTE;
8695 dgst_pos0 = 0;
8696 dgst_pos1 = 1;
8697 dgst_pos2 = 2;
8698 dgst_pos3 = 3;
8699 break;
8700
8701 case 7200: hash_type = HASH_TYPE_SHA512;
8702 salt_type = SALT_TYPE_EMBEDDED;
8703 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8704 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8705 kern_type = KERN_TYPE_PBKDF2_SHA512;
8706 dgst_size = DGST_SIZE_8_16;
8707 parse_func = sha512grub_parse_hash;
8708 sort_by_digest = sort_by_digest_8_16;
8709 opti_type = OPTI_TYPE_ZERO_BYTE;
8710 dgst_pos0 = 0;
8711 dgst_pos1 = 1;
8712 dgst_pos2 = 2;
8713 dgst_pos3 = 3;
8714 break;
8715
8716 case 7300: hash_type = HASH_TYPE_SHA1;
8717 salt_type = SALT_TYPE_EMBEDDED;
8718 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8719 opts_type = OPTS_TYPE_PT_GENERATE_BE
8720 | OPTS_TYPE_ST_ADD80
8721 | OPTS_TYPE_ST_ADDBITS15;
8722 kern_type = KERN_TYPE_RAKP;
8723 dgst_size = DGST_SIZE_4_5;
8724 parse_func = rakp_parse_hash;
8725 sort_by_digest = sort_by_digest_4_5;
8726 opti_type = OPTI_TYPE_ZERO_BYTE
8727 | OPTI_TYPE_NOT_ITERATED;
8728 dgst_pos0 = 3;
8729 dgst_pos1 = 4;
8730 dgst_pos2 = 2;
8731 dgst_pos3 = 1;
8732 break;
8733
8734 case 7400: hash_type = HASH_TYPE_SHA256;
8735 salt_type = SALT_TYPE_EMBEDDED;
8736 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8737 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8738 kern_type = KERN_TYPE_SHA256CRYPT;
8739 dgst_size = DGST_SIZE_4_8;
8740 parse_func = sha256crypt_parse_hash;
8741 sort_by_digest = sort_by_digest_4_8;
8742 opti_type = OPTI_TYPE_ZERO_BYTE;
8743 dgst_pos0 = 0;
8744 dgst_pos1 = 1;
8745 dgst_pos2 = 2;
8746 dgst_pos3 = 3;
8747 break;
8748
8749 case 7500: hash_type = HASH_TYPE_KRB5PA;
8750 salt_type = SALT_TYPE_EMBEDDED;
8751 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8752 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8753 kern_type = KERN_TYPE_KRB5PA;
8754 dgst_size = DGST_SIZE_4_4;
8755 parse_func = krb5pa_parse_hash;
8756 sort_by_digest = sort_by_digest_4_4;
8757 opti_type = OPTI_TYPE_ZERO_BYTE
8758 | OPTI_TYPE_NOT_ITERATED;
8759 dgst_pos0 = 3;
8760 dgst_pos1 = 7;
8761 dgst_pos2 = 2;
8762 dgst_pos3 = 6;
8763 break;
8764
8765 case 7600: hash_type = HASH_TYPE_SHA1;
8766 salt_type = SALT_TYPE_INTERN;
8767 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8768 opts_type = OPTS_TYPE_PT_GENERATE_BE
8769 | OPTS_TYPE_PT_ADD80
8770 | OPTS_TYPE_PT_ADDBITS15;
8771 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
8772 dgst_size = DGST_SIZE_4_5;
8773 parse_func = redmine_parse_hash;
8774 sort_by_digest = sort_by_digest_4_5;
8775 opti_type = OPTI_TYPE_ZERO_BYTE
8776 | OPTI_TYPE_PRECOMPUTE_INIT
8777 | OPTI_TYPE_EARLY_SKIP
8778 | OPTI_TYPE_NOT_ITERATED
8779 | OPTI_TYPE_PREPENDED_SALT;
8780 dgst_pos0 = 3;
8781 dgst_pos1 = 4;
8782 dgst_pos2 = 2;
8783 dgst_pos3 = 1;
8784 break;
8785
8786 case 7700: hash_type = HASH_TYPE_SAPB;
8787 salt_type = SALT_TYPE_EMBEDDED;
8788 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8789 opts_type = OPTS_TYPE_PT_GENERATE_LE
8790 | OPTS_TYPE_PT_UPPER
8791 | OPTS_TYPE_ST_UPPER;
8792 kern_type = KERN_TYPE_SAPB;
8793 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8794 parse_func = sapb_parse_hash;
8795 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8796 opti_type = OPTI_TYPE_ZERO_BYTE
8797 | OPTI_TYPE_PRECOMPUTE_INIT
8798 | OPTI_TYPE_NOT_ITERATED;
8799 dgst_pos0 = 0;
8800 dgst_pos1 = 1;
8801 dgst_pos2 = 2;
8802 dgst_pos3 = 3;
8803 break;
8804
8805 case 7800: hash_type = HASH_TYPE_SAPG;
8806 salt_type = SALT_TYPE_EMBEDDED;
8807 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8808 opts_type = OPTS_TYPE_PT_GENERATE_BE
8809 | OPTS_TYPE_ST_ADD80
8810 | OPTS_TYPE_ST_UPPER;
8811 kern_type = KERN_TYPE_SAPG;
8812 dgst_size = DGST_SIZE_4_5;
8813 parse_func = sapg_parse_hash;
8814 sort_by_digest = sort_by_digest_4_5;
8815 opti_type = OPTI_TYPE_ZERO_BYTE
8816 | OPTI_TYPE_PRECOMPUTE_INIT
8817 | OPTI_TYPE_NOT_ITERATED;
8818 dgst_pos0 = 3;
8819 dgst_pos1 = 4;
8820 dgst_pos2 = 2;
8821 dgst_pos3 = 1;
8822 break;
8823
8824 case 7900: hash_type = HASH_TYPE_SHA512;
8825 salt_type = SALT_TYPE_EMBEDDED;
8826 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8827 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8828 kern_type = KERN_TYPE_DRUPAL7;
8829 dgst_size = DGST_SIZE_8_8;
8830 parse_func = drupal7_parse_hash;
8831 sort_by_digest = sort_by_digest_8_8;
8832 opti_type = OPTI_TYPE_ZERO_BYTE;
8833 dgst_pos0 = 0;
8834 dgst_pos1 = 1;
8835 dgst_pos2 = 2;
8836 dgst_pos3 = 3;
8837 break;
8838
8839 case 8000: hash_type = HASH_TYPE_SHA256;
8840 salt_type = SALT_TYPE_EMBEDDED;
8841 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8842 opts_type = OPTS_TYPE_PT_GENERATE_BE
8843 | OPTS_TYPE_PT_UNICODE
8844 | OPTS_TYPE_ST_ADD80
8845 | OPTS_TYPE_ST_HEX;
8846 kern_type = KERN_TYPE_SYBASEASE;
8847 dgst_size = DGST_SIZE_4_8;
8848 parse_func = sybasease_parse_hash;
8849 sort_by_digest = sort_by_digest_4_8;
8850 opti_type = OPTI_TYPE_ZERO_BYTE
8851 | OPTI_TYPE_PRECOMPUTE_INIT
8852 | OPTI_TYPE_EARLY_SKIP
8853 | OPTI_TYPE_NOT_ITERATED
8854 | OPTI_TYPE_RAW_HASH;
8855 dgst_pos0 = 3;
8856 dgst_pos1 = 7;
8857 dgst_pos2 = 2;
8858 dgst_pos3 = 6;
8859 break;
8860
8861 case 8100: hash_type = HASH_TYPE_SHA1;
8862 salt_type = SALT_TYPE_EMBEDDED;
8863 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8864 opts_type = OPTS_TYPE_PT_GENERATE_BE;
8865 kern_type = KERN_TYPE_NETSCALER;
8866 dgst_size = DGST_SIZE_4_5;
8867 parse_func = netscaler_parse_hash;
8868 sort_by_digest = sort_by_digest_4_5;
8869 opti_type = OPTI_TYPE_ZERO_BYTE
8870 | OPTI_TYPE_PRECOMPUTE_INIT
8871 | OPTI_TYPE_PRECOMPUTE_MERKLE
8872 | OPTI_TYPE_EARLY_SKIP
8873 | OPTI_TYPE_NOT_ITERATED
8874 | OPTI_TYPE_PREPENDED_SALT
8875 | OPTI_TYPE_RAW_HASH;
8876 dgst_pos0 = 3;
8877 dgst_pos1 = 4;
8878 dgst_pos2 = 2;
8879 dgst_pos3 = 1;
8880 break;
8881
8882 case 8200: hash_type = HASH_TYPE_SHA256;
8883 salt_type = SALT_TYPE_EMBEDDED;
8884 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8885 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8886 kern_type = KERN_TYPE_CLOUDKEY;
8887 dgst_size = DGST_SIZE_4_8;
8888 parse_func = cloudkey_parse_hash;
8889 sort_by_digest = sort_by_digest_4_8;
8890 opti_type = OPTI_TYPE_ZERO_BYTE;
8891 dgst_pos0 = 0;
8892 dgst_pos1 = 1;
8893 dgst_pos2 = 2;
8894 dgst_pos3 = 3;
8895 break;
8896
8897 case 8300: hash_type = HASH_TYPE_SHA1;
8898 salt_type = SALT_TYPE_EMBEDDED;
8899 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8900 opts_type = OPTS_TYPE_PT_GENERATE_LE
8901 | OPTS_TYPE_ST_HEX
8902 | OPTS_TYPE_ST_ADD80;
8903 kern_type = KERN_TYPE_NSEC3;
8904 dgst_size = DGST_SIZE_4_5;
8905 parse_func = nsec3_parse_hash;
8906 sort_by_digest = sort_by_digest_4_5;
8907 opti_type = OPTI_TYPE_ZERO_BYTE;
8908 dgst_pos0 = 3;
8909 dgst_pos1 = 4;
8910 dgst_pos2 = 2;
8911 dgst_pos3 = 1;
8912 break;
8913
8914 case 8400: hash_type = HASH_TYPE_SHA1;
8915 salt_type = SALT_TYPE_INTERN;
8916 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8917 opts_type = OPTS_TYPE_PT_GENERATE_BE
8918 | OPTS_TYPE_PT_ADD80
8919 | OPTS_TYPE_PT_ADDBITS15;
8920 kern_type = KERN_TYPE_WBB3;
8921 dgst_size = DGST_SIZE_4_5;
8922 parse_func = wbb3_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_NOT_ITERATED;
8927 dgst_pos0 = 3;
8928 dgst_pos1 = 4;
8929 dgst_pos2 = 2;
8930 dgst_pos3 = 1;
8931 break;
8932
8933 case 8500: hash_type = HASH_TYPE_DESRACF;
8934 salt_type = SALT_TYPE_EMBEDDED;
8935 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8936 opts_type = OPTS_TYPE_PT_GENERATE_LE
8937 | OPTS_TYPE_ST_UPPER;
8938 kern_type = KERN_TYPE_RACF;
8939 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8940 parse_func = racf_parse_hash;
8941 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8942 opti_type = OPTI_TYPE_ZERO_BYTE
8943 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8944 dgst_pos0 = 0;
8945 dgst_pos1 = 1;
8946 dgst_pos2 = 2;
8947 dgst_pos3 = 3;
8948 break;
8949
8950 case 8600: hash_type = HASH_TYPE_LOTUS5;
8951 salt_type = SALT_TYPE_NONE;
8952 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8953 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8954 kern_type = KERN_TYPE_LOTUS5;
8955 dgst_size = DGST_SIZE_4_4;
8956 parse_func = lotus5_parse_hash;
8957 sort_by_digest = sort_by_digest_4_4;
8958 opti_type = OPTI_TYPE_EARLY_SKIP
8959 | OPTI_TYPE_NOT_ITERATED
8960 | OPTI_TYPE_NOT_SALTED
8961 | OPTI_TYPE_RAW_HASH;
8962 dgst_pos0 = 0;
8963 dgst_pos1 = 1;
8964 dgst_pos2 = 2;
8965 dgst_pos3 = 3;
8966 break;
8967
8968 case 8700: hash_type = HASH_TYPE_LOTUS6;
8969 salt_type = SALT_TYPE_EMBEDDED;
8970 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8971 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8972 kern_type = KERN_TYPE_LOTUS6;
8973 dgst_size = DGST_SIZE_4_4;
8974 parse_func = lotus6_parse_hash;
8975 sort_by_digest = sort_by_digest_4_4;
8976 opti_type = OPTI_TYPE_EARLY_SKIP
8977 | OPTI_TYPE_NOT_ITERATED
8978 | OPTI_TYPE_RAW_HASH;
8979 dgst_pos0 = 0;
8980 dgst_pos1 = 1;
8981 dgst_pos2 = 2;
8982 dgst_pos3 = 3;
8983 break;
8984
8985 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
8986 salt_type = SALT_TYPE_EMBEDDED;
8987 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8988 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8989 kern_type = KERN_TYPE_ANDROIDFDE;
8990 dgst_size = DGST_SIZE_4_4;
8991 parse_func = androidfde_parse_hash;
8992 sort_by_digest = sort_by_digest_4_4;
8993 opti_type = OPTI_TYPE_ZERO_BYTE;
8994 dgst_pos0 = 0;
8995 dgst_pos1 = 1;
8996 dgst_pos2 = 2;
8997 dgst_pos3 = 3;
8998 break;
8999
9000 case 8900: hash_type = HASH_TYPE_SCRYPT;
9001 salt_type = SALT_TYPE_EMBEDDED;
9002 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9003 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9004 kern_type = KERN_TYPE_SCRYPT;
9005 dgst_size = DGST_SIZE_4_8;
9006 parse_func = scrypt_parse_hash;
9007 sort_by_digest = sort_by_digest_4_8;
9008 opti_type = OPTI_TYPE_ZERO_BYTE;
9009 dgst_pos0 = 0;
9010 dgst_pos1 = 1;
9011 dgst_pos2 = 2;
9012 dgst_pos3 = 3;
9013 break;
9014
9015 case 9000: hash_type = HASH_TYPE_SHA1;
9016 salt_type = SALT_TYPE_EMBEDDED;
9017 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9018 opts_type = OPTS_TYPE_PT_GENERATE_LE
9019 | OPTS_TYPE_ST_GENERATE_LE;
9020 kern_type = KERN_TYPE_PSAFE2;
9021 dgst_size = DGST_SIZE_4_5;
9022 parse_func = psafe2_parse_hash;
9023 sort_by_digest = sort_by_digest_4_5;
9024 opti_type = OPTI_TYPE_ZERO_BYTE;
9025 dgst_pos0 = 0;
9026 dgst_pos1 = 1;
9027 dgst_pos2 = 2;
9028 dgst_pos3 = 3;
9029 break;
9030
9031 case 9100: hash_type = HASH_TYPE_LOTUS8;
9032 salt_type = SALT_TYPE_EMBEDDED;
9033 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9034 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9035 kern_type = KERN_TYPE_LOTUS8;
9036 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9037 parse_func = lotus8_parse_hash;
9038 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9039 opti_type = OPTI_TYPE_ZERO_BYTE;
9040 dgst_pos0 = 0;
9041 dgst_pos1 = 1;
9042 dgst_pos2 = 2;
9043 dgst_pos3 = 3;
9044 break;
9045
9046 case 9200: hash_type = HASH_TYPE_SHA256;
9047 salt_type = SALT_TYPE_EMBEDDED;
9048 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9049 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9050 kern_type = KERN_TYPE_PBKDF2_SHA256;
9051 dgst_size = DGST_SIZE_4_32;
9052 parse_func = cisco8_parse_hash;
9053 sort_by_digest = sort_by_digest_4_32;
9054 opti_type = OPTI_TYPE_ZERO_BYTE;
9055 dgst_pos0 = 0;
9056 dgst_pos1 = 1;
9057 dgst_pos2 = 2;
9058 dgst_pos3 = 3;
9059 break;
9060
9061 case 9300: hash_type = HASH_TYPE_SCRYPT;
9062 salt_type = SALT_TYPE_EMBEDDED;
9063 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9064 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9065 kern_type = KERN_TYPE_SCRYPT;
9066 dgst_size = DGST_SIZE_4_8;
9067 parse_func = cisco9_parse_hash;
9068 sort_by_digest = sort_by_digest_4_8;
9069 opti_type = OPTI_TYPE_ZERO_BYTE;
9070 dgst_pos0 = 0;
9071 dgst_pos1 = 1;
9072 dgst_pos2 = 2;
9073 dgst_pos3 = 3;
9074 break;
9075
9076 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9077 salt_type = SALT_TYPE_EMBEDDED;
9078 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9079 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9080 kern_type = KERN_TYPE_OFFICE2007;
9081 dgst_size = DGST_SIZE_4_4;
9082 parse_func = office2007_parse_hash;
9083 sort_by_digest = sort_by_digest_4_4;
9084 opti_type = OPTI_TYPE_ZERO_BYTE;
9085 dgst_pos0 = 0;
9086 dgst_pos1 = 1;
9087 dgst_pos2 = 2;
9088 dgst_pos3 = 3;
9089 break;
9090
9091 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9092 salt_type = SALT_TYPE_EMBEDDED;
9093 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9094 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9095 kern_type = KERN_TYPE_OFFICE2010;
9096 dgst_size = DGST_SIZE_4_4;
9097 parse_func = office2010_parse_hash;
9098 sort_by_digest = sort_by_digest_4_4;
9099 opti_type = OPTI_TYPE_ZERO_BYTE;
9100 dgst_pos0 = 0;
9101 dgst_pos1 = 1;
9102 dgst_pos2 = 2;
9103 dgst_pos3 = 3;
9104 break;
9105
9106 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9107 salt_type = SALT_TYPE_EMBEDDED;
9108 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9109 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9110 kern_type = KERN_TYPE_OFFICE2013;
9111 dgst_size = DGST_SIZE_4_4;
9112 parse_func = office2013_parse_hash;
9113 sort_by_digest = sort_by_digest_4_4;
9114 opti_type = OPTI_TYPE_ZERO_BYTE;
9115 dgst_pos0 = 0;
9116 dgst_pos1 = 1;
9117 dgst_pos2 = 2;
9118 dgst_pos3 = 3;
9119 break;
9120
9121 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9122 salt_type = SALT_TYPE_EMBEDDED;
9123 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9124 opts_type = OPTS_TYPE_PT_GENERATE_LE
9125 | OPTS_TYPE_PT_ADD80
9126 | OPTS_TYPE_PT_UNICODE;
9127 kern_type = KERN_TYPE_OLDOFFICE01;
9128 dgst_size = DGST_SIZE_4_4;
9129 parse_func = oldoffice01_parse_hash;
9130 sort_by_digest = sort_by_digest_4_4;
9131 opti_type = OPTI_TYPE_ZERO_BYTE
9132 | OPTI_TYPE_PRECOMPUTE_INIT
9133 | OPTI_TYPE_NOT_ITERATED;
9134 dgst_pos0 = 0;
9135 dgst_pos1 = 1;
9136 dgst_pos2 = 2;
9137 dgst_pos3 = 3;
9138 break;
9139
9140 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9141 salt_type = SALT_TYPE_EMBEDDED;
9142 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9143 opts_type = OPTS_TYPE_PT_GENERATE_LE
9144 | OPTS_TYPE_PT_ADD80;
9145 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9146 dgst_size = DGST_SIZE_4_4;
9147 parse_func = oldoffice01cm1_parse_hash;
9148 sort_by_digest = sort_by_digest_4_4;
9149 opti_type = OPTI_TYPE_ZERO_BYTE
9150 | OPTI_TYPE_PRECOMPUTE_INIT
9151 | OPTI_TYPE_NOT_ITERATED;
9152 dgst_pos0 = 0;
9153 dgst_pos1 = 1;
9154 dgst_pos2 = 2;
9155 dgst_pos3 = 3;
9156 break;
9157
9158 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9159 salt_type = SALT_TYPE_EMBEDDED;
9160 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9161 opts_type = OPTS_TYPE_PT_GENERATE_LE
9162 | OPTS_TYPE_PT_ADD80
9163 | OPTS_TYPE_PT_UNICODE
9164 | OPTS_TYPE_PT_NEVERCRACK;
9165 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9166 dgst_size = DGST_SIZE_4_4;
9167 parse_func = oldoffice01cm2_parse_hash;
9168 sort_by_digest = sort_by_digest_4_4;
9169 opti_type = OPTI_TYPE_ZERO_BYTE
9170 | OPTI_TYPE_PRECOMPUTE_INIT
9171 | OPTI_TYPE_NOT_ITERATED;
9172 dgst_pos0 = 0;
9173 dgst_pos1 = 1;
9174 dgst_pos2 = 2;
9175 dgst_pos3 = 3;
9176 break;
9177
9178 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9179 salt_type = SALT_TYPE_EMBEDDED;
9180 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9181 opts_type = OPTS_TYPE_PT_GENERATE_BE
9182 | OPTS_TYPE_PT_ADD80
9183 | OPTS_TYPE_PT_UNICODE;
9184 kern_type = KERN_TYPE_OLDOFFICE34;
9185 dgst_size = DGST_SIZE_4_4;
9186 parse_func = oldoffice34_parse_hash;
9187 sort_by_digest = sort_by_digest_4_4;
9188 opti_type = OPTI_TYPE_ZERO_BYTE
9189 | OPTI_TYPE_PRECOMPUTE_INIT
9190 | OPTI_TYPE_NOT_ITERATED;
9191 dgst_pos0 = 0;
9192 dgst_pos1 = 1;
9193 dgst_pos2 = 2;
9194 dgst_pos3 = 3;
9195 break;
9196
9197 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9198 salt_type = SALT_TYPE_EMBEDDED;
9199 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9200 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9201 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9202 dgst_size = DGST_SIZE_4_4;
9203 parse_func = oldoffice34cm1_parse_hash;
9204 sort_by_digest = sort_by_digest_4_4;
9205 opti_type = OPTI_TYPE_ZERO_BYTE
9206 | OPTI_TYPE_PRECOMPUTE_INIT
9207 | OPTI_TYPE_NOT_ITERATED;
9208 dgst_pos0 = 0;
9209 dgst_pos1 = 1;
9210 dgst_pos2 = 2;
9211 dgst_pos3 = 3;
9212 break;
9213
9214 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9215 salt_type = SALT_TYPE_EMBEDDED;
9216 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9217 opts_type = OPTS_TYPE_PT_GENERATE_BE
9218 | OPTS_TYPE_PT_ADD80
9219 | OPTS_TYPE_PT_UNICODE
9220 | OPTS_TYPE_PT_NEVERCRACK;
9221 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9222 dgst_size = DGST_SIZE_4_4;
9223 parse_func = oldoffice34cm2_parse_hash;
9224 sort_by_digest = sort_by_digest_4_4;
9225 opti_type = OPTI_TYPE_ZERO_BYTE
9226 | OPTI_TYPE_PRECOMPUTE_INIT
9227 | OPTI_TYPE_NOT_ITERATED;
9228 dgst_pos0 = 0;
9229 dgst_pos1 = 1;
9230 dgst_pos2 = 2;
9231 dgst_pos3 = 3;
9232 break;
9233
9234 case 9900: hash_type = HASH_TYPE_MD5;
9235 salt_type = SALT_TYPE_NONE;
9236 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9237 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9238 kern_type = KERN_TYPE_RADMIN2;
9239 dgst_size = DGST_SIZE_4_4;
9240 parse_func = radmin2_parse_hash;
9241 sort_by_digest = sort_by_digest_4_4;
9242 opti_type = OPTI_TYPE_ZERO_BYTE
9243 | OPTI_TYPE_PRECOMPUTE_INIT
9244 | OPTI_TYPE_EARLY_SKIP
9245 | OPTI_TYPE_NOT_ITERATED
9246 | OPTI_TYPE_NOT_SALTED;
9247 dgst_pos0 = 0;
9248 dgst_pos1 = 3;
9249 dgst_pos2 = 2;
9250 dgst_pos3 = 1;
9251 break;
9252
9253 case 10000: hash_type = HASH_TYPE_SHA256;
9254 salt_type = SALT_TYPE_EMBEDDED;
9255 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9256 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9257 kern_type = KERN_TYPE_PBKDF2_SHA256;
9258 dgst_size = DGST_SIZE_4_32;
9259 parse_func = djangopbkdf2_parse_hash;
9260 sort_by_digest = sort_by_digest_4_32;
9261 opti_type = OPTI_TYPE_ZERO_BYTE;
9262 dgst_pos0 = 0;
9263 dgst_pos1 = 1;
9264 dgst_pos2 = 2;
9265 dgst_pos3 = 3;
9266 break;
9267
9268 case 10100: hash_type = HASH_TYPE_SIPHASH;
9269 salt_type = SALT_TYPE_EMBEDDED;
9270 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9271 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9272 kern_type = KERN_TYPE_SIPHASH;
9273 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9274 parse_func = siphash_parse_hash;
9275 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9276 opti_type = OPTI_TYPE_ZERO_BYTE
9277 | OPTI_TYPE_NOT_ITERATED
9278 | OPTI_TYPE_RAW_HASH;
9279 dgst_pos0 = 0;
9280 dgst_pos1 = 1;
9281 dgst_pos2 = 2;
9282 dgst_pos3 = 3;
9283 break;
9284
9285 case 10200: hash_type = HASH_TYPE_MD5;
9286 salt_type = SALT_TYPE_EMBEDDED;
9287 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9288 opts_type = OPTS_TYPE_PT_GENERATE_LE
9289 | OPTS_TYPE_ST_ADD80
9290 | OPTS_TYPE_ST_ADDBITS14;
9291 kern_type = KERN_TYPE_HMACMD5_PW;
9292 dgst_size = DGST_SIZE_4_4;
9293 parse_func = crammd5_parse_hash;
9294 sort_by_digest = sort_by_digest_4_4;
9295 opti_type = OPTI_TYPE_ZERO_BYTE
9296 | OPTI_TYPE_NOT_ITERATED;
9297 dgst_pos0 = 0;
9298 dgst_pos1 = 3;
9299 dgst_pos2 = 2;
9300 dgst_pos3 = 1;
9301 break;
9302
9303 case 10300: hash_type = HASH_TYPE_SHA1;
9304 salt_type = SALT_TYPE_EMBEDDED;
9305 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9306 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9307 kern_type = KERN_TYPE_SAPH_SHA1;
9308 dgst_size = DGST_SIZE_4_5;
9309 parse_func = saph_sha1_parse_hash;
9310 sort_by_digest = sort_by_digest_4_5;
9311 opti_type = OPTI_TYPE_ZERO_BYTE;
9312 dgst_pos0 = 0;
9313 dgst_pos1 = 1;
9314 dgst_pos2 = 2;
9315 dgst_pos3 = 3;
9316 break;
9317
9318 case 10400: hash_type = HASH_TYPE_PDFU16;
9319 salt_type = SALT_TYPE_EMBEDDED;
9320 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9321 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9322 kern_type = KERN_TYPE_PDF11;
9323 dgst_size = DGST_SIZE_4_4;
9324 parse_func = pdf11_parse_hash;
9325 sort_by_digest = sort_by_digest_4_4;
9326 opti_type = OPTI_TYPE_ZERO_BYTE
9327 | OPTI_TYPE_NOT_ITERATED;
9328 dgst_pos0 = 0;
9329 dgst_pos1 = 1;
9330 dgst_pos2 = 2;
9331 dgst_pos3 = 3;
9332 break;
9333
9334 case 10410: hash_type = HASH_TYPE_PDFU16;
9335 salt_type = SALT_TYPE_EMBEDDED;
9336 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9337 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9338 kern_type = KERN_TYPE_PDF11CM1;
9339 dgst_size = DGST_SIZE_4_4;
9340 parse_func = pdf11cm1_parse_hash;
9341 sort_by_digest = sort_by_digest_4_4;
9342 opti_type = OPTI_TYPE_ZERO_BYTE
9343 | OPTI_TYPE_NOT_ITERATED;
9344 dgst_pos0 = 0;
9345 dgst_pos1 = 1;
9346 dgst_pos2 = 2;
9347 dgst_pos3 = 3;
9348 break;
9349
9350 case 10420: hash_type = HASH_TYPE_PDFU16;
9351 salt_type = SALT_TYPE_EMBEDDED;
9352 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9353 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9354 kern_type = KERN_TYPE_PDF11CM2;
9355 dgst_size = DGST_SIZE_4_4;
9356 parse_func = pdf11cm2_parse_hash;
9357 sort_by_digest = sort_by_digest_4_4;
9358 opti_type = OPTI_TYPE_ZERO_BYTE
9359 | OPTI_TYPE_NOT_ITERATED;
9360 dgst_pos0 = 0;
9361 dgst_pos1 = 1;
9362 dgst_pos2 = 2;
9363 dgst_pos3 = 3;
9364 break;
9365
9366 case 10500: hash_type = HASH_TYPE_PDFU16;
9367 salt_type = SALT_TYPE_EMBEDDED;
9368 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9369 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9370 kern_type = KERN_TYPE_PDF14;
9371 dgst_size = DGST_SIZE_4_4;
9372 parse_func = pdf14_parse_hash;
9373 sort_by_digest = sort_by_digest_4_4;
9374 opti_type = OPTI_TYPE_ZERO_BYTE
9375 | OPTI_TYPE_NOT_ITERATED;
9376 dgst_pos0 = 0;
9377 dgst_pos1 = 1;
9378 dgst_pos2 = 2;
9379 dgst_pos3 = 3;
9380 break;
9381
9382 case 10600: hash_type = HASH_TYPE_SHA256;
9383 salt_type = SALT_TYPE_EMBEDDED;
9384 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9385 opts_type = OPTS_TYPE_PT_GENERATE_BE
9386 | OPTS_TYPE_ST_ADD80
9387 | OPTS_TYPE_ST_ADDBITS15
9388 | OPTS_TYPE_HASH_COPY;
9389 kern_type = KERN_TYPE_SHA256_PWSLT;
9390 dgst_size = DGST_SIZE_4_8;
9391 parse_func = pdf17l3_parse_hash;
9392 sort_by_digest = sort_by_digest_4_8;
9393 opti_type = OPTI_TYPE_ZERO_BYTE
9394 | OPTI_TYPE_PRECOMPUTE_INIT
9395 | OPTI_TYPE_PRECOMPUTE_MERKLE
9396 | OPTI_TYPE_EARLY_SKIP
9397 | OPTI_TYPE_NOT_ITERATED
9398 | OPTI_TYPE_APPENDED_SALT
9399 | OPTI_TYPE_RAW_HASH;
9400 dgst_pos0 = 3;
9401 dgst_pos1 = 7;
9402 dgst_pos2 = 2;
9403 dgst_pos3 = 6;
9404 break;
9405
9406 case 10700: hash_type = HASH_TYPE_PDFU32;
9407 salt_type = SALT_TYPE_EMBEDDED;
9408 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9409 opts_type = OPTS_TYPE_PT_GENERATE_LE
9410 | OPTS_TYPE_HASH_COPY;
9411 kern_type = KERN_TYPE_PDF17L8;
9412 dgst_size = DGST_SIZE_4_8;
9413 parse_func = pdf17l8_parse_hash;
9414 sort_by_digest = sort_by_digest_4_8;
9415 opti_type = OPTI_TYPE_ZERO_BYTE
9416 | OPTI_TYPE_NOT_ITERATED;
9417 dgst_pos0 = 0;
9418 dgst_pos1 = 1;
9419 dgst_pos2 = 2;
9420 dgst_pos3 = 3;
9421 break;
9422
9423 case 10800: hash_type = HASH_TYPE_SHA384;
9424 salt_type = SALT_TYPE_NONE;
9425 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9426 opts_type = OPTS_TYPE_PT_GENERATE_BE
9427 | OPTS_TYPE_PT_ADD80
9428 | OPTS_TYPE_PT_ADDBITS15;
9429 kern_type = KERN_TYPE_SHA384;
9430 dgst_size = DGST_SIZE_8_8;
9431 parse_func = sha384_parse_hash;
9432 sort_by_digest = sort_by_digest_8_8;
9433 opti_type = OPTI_TYPE_ZERO_BYTE
9434 | OPTI_TYPE_PRECOMPUTE_INIT
9435 | OPTI_TYPE_PRECOMPUTE_MERKLE
9436 | OPTI_TYPE_EARLY_SKIP
9437 | OPTI_TYPE_NOT_ITERATED
9438 | OPTI_TYPE_NOT_SALTED
9439 | OPTI_TYPE_RAW_HASH;
9440 dgst_pos0 = 6;
9441 dgst_pos1 = 7;
9442 dgst_pos2 = 4;
9443 dgst_pos3 = 5;
9444 break;
9445
9446 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9447 salt_type = SALT_TYPE_EMBEDDED;
9448 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9449 opts_type = OPTS_TYPE_PT_GENERATE_LE
9450 | OPTS_TYPE_ST_BASE64
9451 | OPTS_TYPE_HASH_COPY;
9452 kern_type = KERN_TYPE_PBKDF2_SHA256;
9453 dgst_size = DGST_SIZE_4_32;
9454 parse_func = pbkdf2_sha256_parse_hash;
9455 sort_by_digest = sort_by_digest_4_32;
9456 opti_type = OPTI_TYPE_ZERO_BYTE;
9457 dgst_pos0 = 0;
9458 dgst_pos1 = 1;
9459 dgst_pos2 = 2;
9460 dgst_pos3 = 3;
9461 break;
9462
9463 case 11000: hash_type = HASH_TYPE_MD5;
9464 salt_type = SALT_TYPE_INTERN;
9465 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9466 opts_type = OPTS_TYPE_PT_GENERATE_LE
9467 | OPTS_TYPE_PT_ADD80;
9468 kern_type = KERN_TYPE_PRESTASHOP;
9469 dgst_size = DGST_SIZE_4_4;
9470 parse_func = prestashop_parse_hash;
9471 sort_by_digest = sort_by_digest_4_4;
9472 opti_type = OPTI_TYPE_ZERO_BYTE
9473 | OPTI_TYPE_PRECOMPUTE_INIT
9474 | OPTI_TYPE_NOT_ITERATED
9475 | OPTI_TYPE_PREPENDED_SALT;
9476 dgst_pos0 = 0;
9477 dgst_pos1 = 3;
9478 dgst_pos2 = 2;
9479 dgst_pos3 = 1;
9480 break;
9481
9482 case 11100: hash_type = HASH_TYPE_MD5;
9483 salt_type = SALT_TYPE_EMBEDDED;
9484 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9485 opts_type = OPTS_TYPE_PT_GENERATE_LE
9486 | OPTS_TYPE_ST_ADD80;
9487 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9488 dgst_size = DGST_SIZE_4_4;
9489 parse_func = postgresql_auth_parse_hash;
9490 sort_by_digest = sort_by_digest_4_4;
9491 opti_type = OPTI_TYPE_ZERO_BYTE
9492 | OPTI_TYPE_PRECOMPUTE_INIT
9493 | OPTI_TYPE_PRECOMPUTE_MERKLE
9494 | OPTI_TYPE_EARLY_SKIP;
9495 dgst_pos0 = 0;
9496 dgst_pos1 = 3;
9497 dgst_pos2 = 2;
9498 dgst_pos3 = 1;
9499 break;
9500
9501 case 11200: hash_type = HASH_TYPE_SHA1;
9502 salt_type = SALT_TYPE_EMBEDDED;
9503 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9504 opts_type = OPTS_TYPE_PT_GENERATE_BE
9505 | OPTS_TYPE_PT_ADD80
9506 | OPTS_TYPE_ST_HEX;
9507 kern_type = KERN_TYPE_MYSQL_AUTH;
9508 dgst_size = DGST_SIZE_4_5;
9509 parse_func = mysql_auth_parse_hash;
9510 sort_by_digest = sort_by_digest_4_5;
9511 opti_type = OPTI_TYPE_ZERO_BYTE
9512 | OPTI_TYPE_EARLY_SKIP;
9513 dgst_pos0 = 3;
9514 dgst_pos1 = 4;
9515 dgst_pos2 = 2;
9516 dgst_pos3 = 1;
9517 break;
9518
9519 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9520 salt_type = SALT_TYPE_EMBEDDED;
9521 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9522 opts_type = OPTS_TYPE_PT_GENERATE_LE
9523 | OPTS_TYPE_ST_HEX
9524 | OPTS_TYPE_ST_ADD80;
9525 kern_type = KERN_TYPE_BITCOIN_WALLET;
9526 dgst_size = DGST_SIZE_4_4;
9527 parse_func = bitcoin_wallet_parse_hash;
9528 sort_by_digest = sort_by_digest_4_4;
9529 opti_type = OPTI_TYPE_ZERO_BYTE;
9530 dgst_pos0 = 0;
9531 dgst_pos1 = 1;
9532 dgst_pos2 = 2;
9533 dgst_pos3 = 3;
9534 break;
9535
9536 case 11400: hash_type = HASH_TYPE_MD5;
9537 salt_type = SALT_TYPE_EMBEDDED;
9538 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9539 opts_type = OPTS_TYPE_PT_GENERATE_LE
9540 | OPTS_TYPE_PT_ADD80
9541 | OPTS_TYPE_HASH_COPY;
9542 kern_type = KERN_TYPE_SIP_AUTH;
9543 dgst_size = DGST_SIZE_4_4;
9544 parse_func = sip_auth_parse_hash;
9545 sort_by_digest = sort_by_digest_4_4;
9546 opti_type = OPTI_TYPE_ZERO_BYTE;
9547 dgst_pos0 = 0;
9548 dgst_pos1 = 3;
9549 dgst_pos2 = 2;
9550 dgst_pos3 = 1;
9551 break;
9552
9553 case 11500: hash_type = HASH_TYPE_CRC32;
9554 salt_type = SALT_TYPE_INTERN;
9555 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9556 opts_type = OPTS_TYPE_PT_GENERATE_LE
9557 | OPTS_TYPE_ST_GENERATE_LE
9558 | OPTS_TYPE_ST_HEX;
9559 kern_type = KERN_TYPE_CRC32;
9560 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9561 parse_func = crc32_parse_hash;
9562 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9563 opti_type = OPTI_TYPE_ZERO_BYTE;
9564 dgst_pos0 = 0;
9565 dgst_pos1 = 1;
9566 dgst_pos2 = 2;
9567 dgst_pos3 = 3;
9568 break;
9569
9570 case 11600: hash_type = HASH_TYPE_AES;
9571 salt_type = SALT_TYPE_EMBEDDED;
9572 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9573 opts_type = OPTS_TYPE_PT_GENERATE_LE
9574 | OPTS_TYPE_PT_NEVERCRACK;
9575 kern_type = KERN_TYPE_SEVEN_ZIP;
9576 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9577 parse_func = seven_zip_parse_hash;
9578 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9579 opti_type = OPTI_TYPE_ZERO_BYTE;
9580 dgst_pos0 = 0;
9581 dgst_pos1 = 1;
9582 dgst_pos2 = 2;
9583 dgst_pos3 = 3;
9584 break;
9585
9586 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9587 salt_type = SALT_TYPE_NONE;
9588 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9589 opts_type = OPTS_TYPE_PT_GENERATE_LE
9590 | OPTS_TYPE_PT_ADD01;
9591 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9592 dgst_size = DGST_SIZE_4_8;
9593 parse_func = gost2012sbog_256_parse_hash;
9594 sort_by_digest = sort_by_digest_4_8;
9595 opti_type = OPTI_TYPE_ZERO_BYTE;
9596 dgst_pos0 = 0;
9597 dgst_pos1 = 1;
9598 dgst_pos2 = 2;
9599 dgst_pos3 = 3;
9600 break;
9601
9602 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9603 salt_type = SALT_TYPE_NONE;
9604 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9605 opts_type = OPTS_TYPE_PT_GENERATE_LE
9606 | OPTS_TYPE_PT_ADD01;
9607 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9608 dgst_size = DGST_SIZE_4_16;
9609 parse_func = gost2012sbog_512_parse_hash;
9610 sort_by_digest = sort_by_digest_4_16;
9611 opti_type = OPTI_TYPE_ZERO_BYTE;
9612 dgst_pos0 = 0;
9613 dgst_pos1 = 1;
9614 dgst_pos2 = 2;
9615 dgst_pos3 = 3;
9616 break;
9617
9618 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9619 salt_type = SALT_TYPE_EMBEDDED;
9620 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9621 opts_type = OPTS_TYPE_PT_GENERATE_LE
9622 | OPTS_TYPE_ST_BASE64
9623 | OPTS_TYPE_HASH_COPY;
9624 kern_type = KERN_TYPE_PBKDF2_MD5;
9625 dgst_size = DGST_SIZE_4_32;
9626 parse_func = pbkdf2_md5_parse_hash;
9627 sort_by_digest = sort_by_digest_4_32;
9628 opti_type = OPTI_TYPE_ZERO_BYTE;
9629 dgst_pos0 = 0;
9630 dgst_pos1 = 1;
9631 dgst_pos2 = 2;
9632 dgst_pos3 = 3;
9633 break;
9634
9635 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
9636 salt_type = SALT_TYPE_EMBEDDED;
9637 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9638 opts_type = OPTS_TYPE_PT_GENERATE_LE
9639 | OPTS_TYPE_ST_BASE64
9640 | OPTS_TYPE_HASH_COPY;
9641 kern_type = KERN_TYPE_PBKDF2_SHA1;
9642 dgst_size = DGST_SIZE_4_32;
9643 parse_func = pbkdf2_sha1_parse_hash;
9644 sort_by_digest = sort_by_digest_4_32;
9645 opti_type = OPTI_TYPE_ZERO_BYTE;
9646 dgst_pos0 = 0;
9647 dgst_pos1 = 1;
9648 dgst_pos2 = 2;
9649 dgst_pos3 = 3;
9650 break;
9651
9652 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
9653 salt_type = SALT_TYPE_EMBEDDED;
9654 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9655 opts_type = OPTS_TYPE_PT_GENERATE_LE
9656 | OPTS_TYPE_ST_BASE64
9657 | OPTS_TYPE_HASH_COPY;
9658 kern_type = KERN_TYPE_PBKDF2_SHA512;
9659 dgst_size = DGST_SIZE_8_16;
9660 parse_func = pbkdf2_sha512_parse_hash;
9661 sort_by_digest = sort_by_digest_8_16;
9662 opti_type = OPTI_TYPE_ZERO_BYTE;
9663 dgst_pos0 = 0;
9664 dgst_pos1 = 1;
9665 dgst_pos2 = 2;
9666 dgst_pos3 = 3;
9667 break;
9668
9669 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
9670 salt_type = SALT_TYPE_EMBEDDED;
9671 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9672 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9673 kern_type = KERN_TYPE_ECRYPTFS;
9674 dgst_size = DGST_SIZE_8_8;
9675 parse_func = ecryptfs_parse_hash;
9676 sort_by_digest = sort_by_digest_8_8;
9677 opti_type = OPTI_TYPE_ZERO_BYTE;
9678 dgst_pos0 = 0;
9679 dgst_pos1 = 1;
9680 dgst_pos2 = 2;
9681 dgst_pos3 = 3;
9682 break;
9683
9684 case 12300: hash_type = HASH_TYPE_ORACLET;
9685 salt_type = SALT_TYPE_EMBEDDED;
9686 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9687 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9688 kern_type = KERN_TYPE_ORACLET;
9689 dgst_size = DGST_SIZE_8_16;
9690 parse_func = oraclet_parse_hash;
9691 sort_by_digest = sort_by_digest_8_16;
9692 opti_type = OPTI_TYPE_ZERO_BYTE;
9693 dgst_pos0 = 0;
9694 dgst_pos1 = 1;
9695 dgst_pos2 = 2;
9696 dgst_pos3 = 3;
9697 break;
9698
9699 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
9700 salt_type = SALT_TYPE_EMBEDDED;
9701 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9702 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9703 kern_type = KERN_TYPE_BSDICRYPT;
9704 dgst_size = DGST_SIZE_4_4;
9705 parse_func = bsdicrypt_parse_hash;
9706 sort_by_digest = sort_by_digest_4_4;
9707 opti_type = OPTI_TYPE_ZERO_BYTE
9708 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9709 dgst_pos0 = 0;
9710 dgst_pos1 = 1;
9711 dgst_pos2 = 2;
9712 dgst_pos3 = 3;
9713 break;
9714
9715 case 12500: hash_type = HASH_TYPE_RAR3HP;
9716 salt_type = SALT_TYPE_EMBEDDED;
9717 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9718 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9719 kern_type = KERN_TYPE_RAR3;
9720 dgst_size = DGST_SIZE_4_4;
9721 parse_func = rar3hp_parse_hash;
9722 sort_by_digest = sort_by_digest_4_4;
9723 opti_type = OPTI_TYPE_ZERO_BYTE;
9724 dgst_pos0 = 0;
9725 dgst_pos1 = 1;
9726 dgst_pos2 = 2;
9727 dgst_pos3 = 3;
9728 break;
9729
9730 case 12600: hash_type = HASH_TYPE_SHA256;
9731 salt_type = SALT_TYPE_INTERN;
9732 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9733 opts_type = OPTS_TYPE_PT_GENERATE_BE
9734 | OPTS_TYPE_PT_ADD80;
9735 kern_type = KERN_TYPE_CF10;
9736 dgst_size = DGST_SIZE_4_8;
9737 parse_func = cf10_parse_hash;
9738 sort_by_digest = sort_by_digest_4_8;
9739 opti_type = OPTI_TYPE_ZERO_BYTE
9740 | OPTI_TYPE_PRECOMPUTE_INIT
9741 | OPTI_TYPE_EARLY_SKIP
9742 | OPTI_TYPE_NOT_ITERATED;
9743 dgst_pos0 = 3;
9744 dgst_pos1 = 7;
9745 dgst_pos2 = 2;
9746 dgst_pos3 = 6;
9747 break;
9748
9749 case 12700: hash_type = HASH_TYPE_AES;
9750 salt_type = SALT_TYPE_EMBEDDED;
9751 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9752 opts_type = OPTS_TYPE_PT_GENERATE_LE
9753 | OPTS_TYPE_HASH_COPY;
9754 kern_type = KERN_TYPE_MYWALLET;
9755 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9756 parse_func = mywallet_parse_hash;
9757 sort_by_digest = sort_by_digest_4_5;
9758 opti_type = OPTI_TYPE_ZERO_BYTE;
9759 dgst_pos0 = 0;
9760 dgst_pos1 = 1;
9761 dgst_pos2 = 2;
9762 dgst_pos3 = 3;
9763 break;
9764
9765 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
9766 salt_type = SALT_TYPE_EMBEDDED;
9767 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9768 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9769 kern_type = KERN_TYPE_MS_DRSR;
9770 dgst_size = DGST_SIZE_4_8;
9771 parse_func = ms_drsr_parse_hash;
9772 sort_by_digest = sort_by_digest_4_8;
9773 opti_type = OPTI_TYPE_ZERO_BYTE;
9774 dgst_pos0 = 0;
9775 dgst_pos1 = 1;
9776 dgst_pos2 = 2;
9777 dgst_pos3 = 3;
9778 break;
9779
9780 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9781 salt_type = SALT_TYPE_EMBEDDED;
9782 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9783 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9784 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
9785 dgst_size = DGST_SIZE_4_8;
9786 parse_func = androidfde_samsung_parse_hash;
9787 sort_by_digest = sort_by_digest_4_8;
9788 opti_type = OPTI_TYPE_ZERO_BYTE;
9789 dgst_pos0 = 0;
9790 dgst_pos1 = 1;
9791 dgst_pos2 = 2;
9792 dgst_pos3 = 3;
9793 break;
9794
9795 default: usage_mini_print (PROGNAME); return (-1);
9796 }
9797
9798 /**
9799 * transpose
9800 */
9801
9802 data.parse_func = parse_func;
9803
9804 /**
9805 * misc stuff
9806 */
9807
9808 if (hex_salt)
9809 {
9810 if (salt_type == SALT_TYPE_INTERN)
9811 {
9812 opts_type |= OPTS_TYPE_ST_HEX;
9813 }
9814 else
9815 {
9816 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
9817
9818 return (-1);
9819 }
9820 }
9821
9822 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
9823 | (salt_type == SALT_TYPE_EXTERN)
9824 | (salt_type == SALT_TYPE_EMBEDDED)
9825 | (salt_type == SALT_TYPE_VIRTUAL));
9826
9827 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
9828
9829 data.hash_type = hash_type;
9830 data.attack_mode = attack_mode;
9831 data.attack_kern = attack_kern;
9832 data.attack_exec = attack_exec;
9833 data.kern_type = kern_type;
9834 data.opts_type = opts_type;
9835 data.dgst_size = dgst_size;
9836 data.salt_type = salt_type;
9837 data.isSalted = isSalted;
9838 data.sort_by_digest = sort_by_digest;
9839 data.dgst_pos0 = dgst_pos0;
9840 data.dgst_pos1 = dgst_pos1;
9841 data.dgst_pos2 = dgst_pos2;
9842 data.dgst_pos3 = dgst_pos3;
9843
9844 esalt_size = 0;
9845
9846 switch (hash_mode)
9847 {
9848 case 2500: esalt_size = sizeof (wpa_t); break;
9849 case 5300: esalt_size = sizeof (ikepsk_t); break;
9850 case 5400: esalt_size = sizeof (ikepsk_t); break;
9851 case 5500: esalt_size = sizeof (netntlm_t); break;
9852 case 5600: esalt_size = sizeof (netntlm_t); break;
9853 case 6211:
9854 case 6212:
9855 case 6213:
9856 case 6221:
9857 case 6222:
9858 case 6223:
9859 case 6231:
9860 case 6232:
9861 case 6233:
9862 case 6241:
9863 case 6242:
9864 case 6243: esalt_size = sizeof (tc_t); break;
9865 case 6600: esalt_size = sizeof (agilekey_t); break;
9866 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
9867 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
9868 case 7300: esalt_size = sizeof (rakp_t); break;
9869 case 7500: esalt_size = sizeof (krb5pa_t); break;
9870 case 8200: esalt_size = sizeof (cloudkey_t); break;
9871 case 8800: esalt_size = sizeof (androidfde_t); break;
9872 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
9873 case 9400: esalt_size = sizeof (office2007_t); break;
9874 case 9500: esalt_size = sizeof (office2010_t); break;
9875 case 9600: esalt_size = sizeof (office2013_t); break;
9876 case 9700: esalt_size = sizeof (oldoffice01_t); break;
9877 case 9710: esalt_size = sizeof (oldoffice01_t); break;
9878 case 9720: esalt_size = sizeof (oldoffice01_t); break;
9879 case 9800: esalt_size = sizeof (oldoffice34_t); break;
9880 case 9810: esalt_size = sizeof (oldoffice34_t); break;
9881 case 9820: esalt_size = sizeof (oldoffice34_t); break;
9882 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
9883 case 10200: esalt_size = sizeof (cram_md5_t); break;
9884 case 10400: esalt_size = sizeof (pdf_t); break;
9885 case 10410: esalt_size = sizeof (pdf_t); break;
9886 case 10420: esalt_size = sizeof (pdf_t); break;
9887 case 10500: esalt_size = sizeof (pdf_t); break;
9888 case 10600: esalt_size = sizeof (pdf_t); break;
9889 case 10700: esalt_size = sizeof (pdf_t); break;
9890 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
9891 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
9892 case 11400: esalt_size = sizeof (sip_t); break;
9893 case 11600: esalt_size = sizeof (seven_zip_t); break;
9894 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
9895 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
9896 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
9897 }
9898
9899 data.esalt_size = esalt_size;
9900
9901 /**
9902 * choose dictionary parser
9903 */
9904
9905 if (hash_type == HASH_TYPE_LM)
9906 {
9907 get_next_word_func = get_next_word_lm;
9908 }
9909 else if (opts_type & OPTS_TYPE_PT_UPPER)
9910 {
9911 get_next_word_func = get_next_word_uc;
9912 }
9913 else
9914 {
9915 get_next_word_func = get_next_word_std;
9916 }
9917
9918 /**
9919 * dictstat
9920 */
9921
9922 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
9923
9924 #ifdef _POSIX
9925 size_t dictstat_nmemb = 0;
9926 #endif
9927
9928 #ifdef _WIN
9929 uint dictstat_nmemb = 0;
9930 #endif
9931
9932 char dictstat[256];
9933
9934 FILE *dictstat_fp = NULL;
9935
9936 if (keyspace == 0)
9937 {
9938 memset (dictstat, 0, sizeof (dictstat));
9939
9940 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
9941
9942 dictstat_fp = fopen (dictstat, "rb");
9943
9944 if (dictstat_fp)
9945 {
9946 #ifdef _POSIX
9947 struct stat tmpstat;
9948
9949 fstat (fileno (dictstat_fp), &tmpstat);
9950 #endif
9951
9952 #ifdef _WIN
9953 struct stat64 tmpstat;
9954
9955 _fstat64 (fileno (dictstat_fp), &tmpstat);
9956 #endif
9957
9958 if (tmpstat.st_mtime < COMPTIME)
9959 {
9960 /* with v0.15 the format changed so we have to ensure user is using a good version
9961 since there is no version-header in the dictstat file */
9962
9963 fclose (dictstat_fp);
9964
9965 unlink (dictstat);
9966 }
9967 else
9968 {
9969 while (!feof (dictstat_fp))
9970 {
9971 dictstat_t d;
9972
9973 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
9974
9975 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
9976
9977 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
9978 {
9979 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
9980
9981 return -1;
9982 }
9983 }
9984
9985 fclose (dictstat_fp);
9986 }
9987 }
9988 }
9989
9990 /**
9991 * potfile
9992 */
9993
9994 char potfile[256];
9995
9996 memset (potfile, 0, sizeof (potfile));
9997
9998 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
9999
10000 data.pot_fp = NULL;
10001
10002 FILE *out_fp = NULL;
10003 FILE *pot_fp = NULL;
10004
10005 if (show == 1 || left == 1)
10006 {
10007 pot_fp = fopen (potfile, "rb");
10008
10009 if (pot_fp == NULL)
10010 {
10011 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10012
10013 return (-1);
10014 }
10015
10016 if (outfile != NULL)
10017 {
10018 if ((out_fp = fopen (outfile, "ab")) == NULL)
10019 {
10020 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10021
10022 fclose (pot_fp);
10023
10024 return (-1);
10025 }
10026 }
10027 else
10028 {
10029 out_fp = stdout;
10030 }
10031 }
10032 else
10033 {
10034 if (potfile_disable == 0)
10035 {
10036 pot_fp = fopen (potfile, "ab");
10037
10038 if (pot_fp == NULL)
10039 {
10040 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10041
10042 return (-1);
10043 }
10044
10045 data.pot_fp = pot_fp;
10046 }
10047 }
10048
10049 pot_t *pot = NULL;
10050
10051 uint pot_cnt = 0;
10052 uint pot_avail = 0;
10053
10054 if (show == 1 || left == 1)
10055 {
10056 SUPPRESS_OUTPUT = 1;
10057
10058 pot_avail = count_lines (pot_fp);
10059
10060 rewind (pot_fp);
10061
10062 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10063
10064 uint pot_hashes_avail = 0;
10065
10066 uint line_num = 0;
10067
10068 while (!feof (pot_fp))
10069 {
10070 line_num++;
10071
10072 char line_buf[BUFSIZ];
10073
10074 int line_len = fgetl (pot_fp, line_buf);
10075
10076 if (line_len == 0) continue;
10077
10078 char *plain_buf = line_buf + line_len;
10079
10080 pot_t *pot_ptr = &pot[pot_cnt];
10081
10082 hash_t *hashes_buf = &pot_ptr->hash;
10083
10084 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10085 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10086
10087 if (pot_cnt == pot_hashes_avail)
10088 {
10089 uint pos = 0;
10090
10091 for (pos = 0; pos < INCR_POT; pos++)
10092 {
10093 if ((pot_cnt + pos) >= pot_avail) break;
10094
10095 pot_t *tmp_pot = &pot[pot_cnt + pos];
10096
10097 hash_t *tmp_hash = &tmp_pot->hash;
10098
10099 tmp_hash->digest = mymalloc (dgst_size);
10100
10101 if (isSalted)
10102 {
10103 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10104 }
10105
10106 if (esalt_size)
10107 {
10108 tmp_hash->esalt = mymalloc (esalt_size);
10109 }
10110
10111 pot_hashes_avail++;
10112 }
10113 }
10114
10115 int plain_len = 0;
10116
10117 int parser_status;
10118
10119 int iter = MAX_CUT_TRIES;
10120
10121 do
10122 {
10123 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10124 {
10125 if (line_buf[i] == ':')
10126 {
10127 line_len--;
10128
10129 break;
10130 }
10131 }
10132
10133 if (data.hash_mode != 2500)
10134 {
10135 parser_status = parse_func (line_buf, line_len, hashes_buf);
10136 }
10137 else
10138 {
10139 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10140
10141 if (line_len > max_salt_size)
10142 {
10143 parser_status = PARSER_GLOBAL_LENGTH;
10144 }
10145 else
10146 {
10147 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10148
10149 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10150
10151 hashes_buf->salt->salt_len = line_len;
10152
10153 parser_status = PARSER_OK;
10154 }
10155 }
10156
10157 // if NOT parsed without error, we add the ":" to the plain
10158
10159 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10160 {
10161 plain_len++;
10162 plain_buf--;
10163 }
10164
10165 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10166
10167 if (parser_status < PARSER_GLOBAL_ZERO)
10168 {
10169 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10170
10171 continue;
10172 }
10173
10174 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10175
10176 pot_ptr->plain_len = plain_len;
10177
10178 pot_cnt++;
10179 }
10180
10181 fclose (pot_fp);
10182
10183 SUPPRESS_OUTPUT = 0;
10184
10185 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10186 }
10187
10188 /**
10189 * kernel accel and loops auto adjustment
10190 */
10191
10192 if (kernel_accel_chgd == 0) kernel_accel = set_kernel_accel (hash_mode);
10193 if (kernel_loops_chgd == 0) kernel_loops = set_kernel_loops (hash_mode);
10194
10195 if (workload_profile == 1)
10196 {
10197 kernel_loops /= 8;
10198 kernel_accel /= 4;
10199
10200 if (kernel_loops == 0) kernel_loops = 8;
10201 if (kernel_accel == 0) kernel_accel = 2;
10202 }
10203 else if (workload_profile == 3)
10204 {
10205 kernel_loops *= 8;
10206 kernel_accel *= 4;
10207
10208 if (kernel_loops > 1024) kernel_loops = 1024;
10209 if (kernel_accel > 256) kernel_accel = 256; // causes memory problems otherwise
10210 }
10211
10212 // those hashes *must* run at a specific kernel_loops count because of some optimization inside the kernel
10213
10214 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
10215 {
10216 kernel_loops = 1024;
10217 }
10218
10219 if (hash_mode == 12500)
10220 {
10221 kernel_loops = ROUNDS_RAR3 / 16;
10222 }
10223
10224 data.kernel_accel = kernel_accel;
10225 data.kernel_loops = kernel_loops;
10226
10227 /**
10228 * word len
10229 */
10230
10231 uint pw_min = PW_MIN;
10232 uint pw_max = PW_MAX;
10233
10234 switch (hash_mode)
10235 {
10236 case 400: if (pw_max > 40) pw_max = 40;
10237 break;
10238 case 500: if (pw_max > 16) pw_max = 16;
10239 break;
10240 case 1500: if (pw_max > 8) pw_max = 8;
10241 break;
10242 case 1600: if (pw_max > 16) pw_max = 16;
10243 break;
10244 case 1800: if (pw_max > 16) pw_max = 16;
10245 break;
10246 case 2100: if (pw_max > 16) pw_max = 16;
10247 break;
10248 case 2500: if (pw_min < 8) pw_min = 8;
10249 break;
10250 case 3000: if (pw_max > 7) pw_max = 7;
10251 break;
10252 case 5200: if (pw_max > 24) pw_max = 24;
10253 break;
10254 case 5800: if (pw_max > 16) pw_max = 16;
10255 break;
10256 case 6300: if (pw_max > 16) pw_max = 16;
10257 break;
10258 case 7400: if (pw_max > 16) pw_max = 16;
10259 break;
10260 case 7900: if (pw_max > 48) pw_max = 48;
10261 break;
10262 case 8500: if (pw_max > 8) pw_max = 8;
10263 break;
10264 case 8600: if (pw_max > 16) pw_max = 16;
10265 break;
10266 case 9710: pw_min = 5;
10267 pw_max = 5;
10268 break;
10269 case 9810: pw_min = 5;
10270 pw_max = 5;
10271 break;
10272 case 10410: pw_min = 5;
10273 pw_max = 5;
10274 break;
10275 case 10300: if (pw_max < 3) pw_min = 3;
10276 if (pw_max > 40) pw_max = 40;
10277 break;
10278 case 10500: if (pw_max < 3) pw_min = 3;
10279 if (pw_max > 40) pw_max = 40;
10280 break;
10281 case 10700: if (pw_max > 16) pw_max = 16;
10282 break;
10283 case 11300: if (pw_max > 40) pw_max = 40;
10284 break;
10285 case 12500: if (pw_max > 20) pw_max = 20;
10286 break;
10287 case 12800: if (pw_max > 24) pw_max = 24;
10288 break;
10289 }
10290
10291 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10292 {
10293 switch (attack_kern)
10294 {
10295 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10296 break;
10297 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10298 break;
10299 }
10300 }
10301
10302 /**
10303 * charsets : keep them together for more easy maintainnce
10304 */
10305
10306 cs_t mp_sys[6];
10307 cs_t mp_usr[4];
10308
10309 memset (mp_sys, 0, sizeof (mp_sys));
10310 memset (mp_usr, 0, sizeof (mp_usr));
10311
10312 mp_setup_sys (mp_sys);
10313
10314 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10315 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10316 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10317 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10318
10319 /**
10320 * load hashes, part I: find input mode, count hashes
10321 */
10322
10323 uint hashlist_mode = 0;
10324 uint hashlist_format = HLFMT_HASHCAT;
10325
10326 uint hashes_avail = 0;
10327
10328 if (benchmark == 0)
10329 {
10330 struct stat f;
10331
10332 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10333
10334 if ((hash_mode == 2500) ||
10335 (hash_mode == 5200) ||
10336 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10337 (hash_mode == 9000))
10338 {
10339 hashlist_mode = HL_MODE_ARG;
10340
10341 char *hashfile = myargv[optind];
10342
10343 data.hashfile = hashfile;
10344
10345 logfile_top_var_string ("target", hashfile);
10346 }
10347
10348 if (hashlist_mode == HL_MODE_ARG)
10349 {
10350 if (hash_mode == 2500)
10351 {
10352 struct stat st;
10353
10354 if (stat (data.hashfile, &st) == -1)
10355 {
10356 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10357
10358 return (-1);
10359 }
10360
10361 hashes_avail = st.st_size / sizeof (hccap_t);
10362 }
10363 else
10364 {
10365 hashes_avail = 1;
10366 }
10367 }
10368 else if (hashlist_mode == HL_MODE_FILE)
10369 {
10370 char *hashfile = myargv[optind];
10371
10372 data.hashfile = hashfile;
10373
10374 logfile_top_var_string ("target", hashfile);
10375
10376 FILE *fp = NULL;
10377
10378 if ((fp = fopen (hashfile, "rb")) == NULL)
10379 {
10380 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10381
10382 return (-1);
10383 }
10384
10385 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10386
10387 hashes_avail = count_lines (fp);
10388
10389 rewind (fp);
10390
10391 if (hashes_avail == 0)
10392 {
10393 log_error ("ERROR: hashfile is empty or corrupt");
10394
10395 fclose (fp);
10396
10397 return (-1);
10398 }
10399
10400 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10401
10402 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10403 {
10404 log_error ("ERROR: remove not supported in native hashfile-format mode");
10405
10406 fclose (fp);
10407
10408 return (-1);
10409 }
10410
10411 fclose (fp);
10412 }
10413 }
10414 else
10415 {
10416 hashlist_mode = HL_MODE_ARG;
10417
10418 hashes_avail = 1;
10419 }
10420
10421 if (hash_mode == 3000) hashes_avail *= 2;
10422
10423 data.hashlist_mode = hashlist_mode;
10424 data.hashlist_format = hashlist_format;
10425
10426 logfile_top_uint (hashlist_mode);
10427 logfile_top_uint (hashlist_format);
10428
10429 /**
10430 * load hashes, part II: allocate required memory, set pointers
10431 */
10432
10433 hash_t *hashes_buf = NULL;
10434 void *digests_buf = NULL;
10435 salt_t *salts_buf = NULL;
10436 void *esalts_buf = NULL;
10437
10438 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10439
10440 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10441
10442 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10443 {
10444 uint32_t hash_pos;
10445
10446 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10447 {
10448 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10449
10450 hashes_buf[hash_pos].hash_info = hash_info;
10451
10452 if (username && (remove || show || left))
10453 {
10454 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10455 }
10456
10457 if (benchmark)
10458 {
10459 hash_info->orighash = (char *) mymalloc (256);
10460 }
10461 }
10462 }
10463
10464 if (isSalted)
10465 {
10466 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10467
10468 if (esalt_size)
10469 {
10470 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10471 }
10472 }
10473 else
10474 {
10475 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10476 }
10477
10478 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10479 {
10480 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10481
10482 if (isSalted)
10483 {
10484 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10485
10486 if (esalt_size)
10487 {
10488 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10489 }
10490 }
10491 else
10492 {
10493 hashes_buf[hash_pos].salt = &salts_buf[0];
10494 }
10495 }
10496
10497 /**
10498 * load hashes, part III: parse hashes or generate them if benchmark
10499 */
10500
10501 uint hashes_cnt = 0;
10502
10503 if (benchmark == 0)
10504 {
10505 if (keyspace == 1)
10506 {
10507 // useless to read hash file for keyspace, cheat a little bit w/ optind
10508 }
10509 else if (hashes_avail == 0)
10510 {
10511 }
10512 else if (hashlist_mode == HL_MODE_ARG)
10513 {
10514 char *input_buf = myargv[optind];
10515
10516 uint input_len = strlen (input_buf);
10517
10518 logfile_top_var_string ("target", input_buf);
10519
10520 char *hash_buf = NULL;
10521 int hash_len = 0;
10522
10523 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10524
10525 if (hash_len)
10526 {
10527 if (opts_type & OPTS_TYPE_HASH_COPY)
10528 {
10529 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10530
10531 hash_info_tmp->orighash = mystrdup (hash_buf);
10532 }
10533
10534 if (isSalted)
10535 {
10536 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10537 }
10538
10539 int parser_status = PARSER_OK;
10540
10541 if (hash_mode == 2500)
10542 {
10543 if (hash_len == 0)
10544 {
10545 log_error ("ERROR: hccap file not specified");
10546
10547 return (-1);
10548 }
10549
10550 hashlist_mode = HL_MODE_FILE;
10551
10552 data.hashlist_mode = hashlist_mode;
10553
10554 FILE *fp = fopen (hash_buf, "rb");
10555
10556 if (fp == NULL)
10557 {
10558 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10559
10560 return (-1);
10561 }
10562
10563 if (hashes_avail < 1)
10564 {
10565 log_error ("ERROR: hccap file is empty or corrupt");
10566
10567 fclose (fp);
10568
10569 return (-1);
10570 }
10571
10572 uint hccap_size = sizeof (hccap_t);
10573
10574 char in[hccap_size];
10575
10576 while (!feof (fp))
10577 {
10578 int n = fread (&in, hccap_size, 1, fp);
10579
10580 if (n != 1)
10581 {
10582 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
10583
10584 break;
10585 }
10586
10587 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
10588
10589 if (parser_status != PARSER_OK)
10590 {
10591 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
10592
10593 continue;
10594 }
10595
10596 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
10597
10598 if ((show == 1) || (left == 1))
10599 {
10600 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
10601
10602 char *salt_ptr = (char *) tmp_salt->salt_buf;
10603
10604 int cur_pos = tmp_salt->salt_len;
10605 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10606
10607 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
10608
10609 unsigned char *pke_ptr = (unsigned char *) wpa->pke;
10610
10611 // do the appending task
10612
10613 snprintf (salt_ptr + cur_pos,
10614 rem_len,
10615 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
10616 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
10617 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
10618
10619
10620 // memset () the remaining part of the salt
10621
10622 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
10623 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10624
10625 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
10626
10627 tmp_salt->salt_len += 1 + 12 + 1 + 12;
10628 }
10629
10630 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);
10631 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);
10632
10633 hashes_cnt++;
10634 }
10635
10636 fclose (fp);
10637 }
10638 else if (hash_mode == 3000)
10639 {
10640 if (hash_len == 32)
10641 {
10642 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10643
10644 hash_t *lm_hash_left = NULL;
10645
10646 if (parser_status == PARSER_OK)
10647 {
10648 lm_hash_left = &hashes_buf[hashes_cnt];
10649
10650 hashes_cnt++;
10651 }
10652 else
10653 {
10654 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10655 }
10656
10657
10658 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10659
10660 hash_t *lm_hash_right = NULL;
10661
10662 if (parser_status == PARSER_OK)
10663 {
10664 lm_hash_right = &hashes_buf[hashes_cnt];
10665
10666 hashes_cnt++;
10667 }
10668 else
10669 {
10670 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10671 }
10672
10673 // show / left
10674
10675 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
10676 {
10677 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);
10678 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);
10679 }
10680 }
10681 else
10682 {
10683 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10684
10685 if (parser_status == PARSER_OK)
10686 {
10687 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10688 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10689 }
10690
10691 if (parser_status == PARSER_OK)
10692 {
10693 hashes_cnt++;
10694 }
10695 else
10696 {
10697 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10698 }
10699 }
10700 }
10701 else
10702 {
10703 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10704
10705 if (parser_status == PARSER_OK)
10706 {
10707 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10708 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10709 }
10710
10711 if (parser_status == PARSER_OK)
10712 {
10713 hashes_cnt++;
10714 }
10715 else
10716 {
10717 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10718 }
10719 }
10720 }
10721 }
10722 else if (hashlist_mode == HL_MODE_FILE)
10723 {
10724 char *hashfile = data.hashfile;
10725
10726 FILE *fp;
10727
10728 if ((fp = fopen (hashfile, "rb")) == NULL)
10729 {
10730 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10731
10732 return (-1);
10733 }
10734
10735 uint line_num = 0;
10736
10737 while (!feof (fp))
10738 {
10739 line_num++;
10740
10741 char line_buf[BUFSIZ];
10742
10743 int line_len = fgetl (fp, line_buf);
10744
10745 if (line_len == 0) continue;
10746
10747 char *hash_buf = NULL;
10748 int hash_len = 0;
10749
10750 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
10751
10752 if (username)
10753 {
10754 char *user_buf = NULL;
10755 int user_len = 0;
10756
10757 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
10758
10759 if (remove || show)
10760 {
10761 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
10762
10763 *user = (user_t *) malloc (sizeof (user_t));
10764
10765 user_t *user_ptr = *user;
10766
10767 if (user_buf != NULL)
10768 {
10769 user_ptr->user_name = mystrdup (user_buf);
10770 }
10771 else
10772 {
10773 user_ptr->user_name = mystrdup ("");
10774 }
10775
10776 user_ptr->user_len = user_len;
10777 }
10778 }
10779
10780 if (opts_type & OPTS_TYPE_HASH_COPY)
10781 {
10782 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10783
10784 hash_info_tmp->orighash = mystrdup (hash_buf);
10785 }
10786
10787 if (isSalted)
10788 {
10789 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
10790 }
10791
10792 if (hash_mode == 3000)
10793 {
10794 if (hash_len == 32)
10795 {
10796 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10797
10798 if (parser_status < PARSER_GLOBAL_ZERO)
10799 {
10800 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10801
10802 continue;
10803 }
10804
10805 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
10806
10807 hashes_cnt++;
10808
10809 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10810
10811 if (parser_status < PARSER_GLOBAL_ZERO)
10812 {
10813 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10814
10815 continue;
10816 }
10817
10818 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
10819
10820 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);
10821
10822 hashes_cnt++;
10823
10824 // show / left
10825
10826 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);
10827 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);
10828 }
10829 else
10830 {
10831 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10832
10833 if (parser_status < PARSER_GLOBAL_ZERO)
10834 {
10835 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10836
10837 continue;
10838 }
10839
10840 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);
10841
10842 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10843 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10844
10845 hashes_cnt++;
10846 }
10847 }
10848 else
10849 {
10850 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10851
10852 if (parser_status < PARSER_GLOBAL_ZERO)
10853 {
10854 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10855
10856 continue;
10857 }
10858
10859 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);
10860
10861 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10862 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10863
10864 hashes_cnt++;
10865 }
10866 }
10867
10868 fclose (fp);
10869
10870 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
10871
10872 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
10873 }
10874 }
10875 else
10876 {
10877 if (isSalted)
10878 {
10879 hashes_buf[0].salt->salt_len = 8;
10880
10881 // special salt handling
10882
10883 switch (hash_mode)
10884 {
10885 case 1500: hashes_buf[0].salt->salt_len = 2;
10886 break;
10887 case 1731: hashes_buf[0].salt->salt_len = 4;
10888 break;
10889 case 2410: hashes_buf[0].salt->salt_len = 4;
10890 break;
10891 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
10892 break;
10893 case 3100: hashes_buf[0].salt->salt_len = 1;
10894 break;
10895 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
10896 break;
10897 case 5800: hashes_buf[0].salt->salt_len = 16;
10898 break;
10899 case 6800: hashes_buf[0].salt->salt_len = 32;
10900 break;
10901 case 8400: hashes_buf[0].salt->salt_len = 40;
10902 break;
10903 case 8800: hashes_buf[0].salt->salt_len = 16;
10904 break;
10905 case 8900: hashes_buf[0].salt->salt_len = 16;
10906 hashes_buf[0].salt->scrypt_N = 1024;
10907 hashes_buf[0].salt->scrypt_r = 1;
10908 hashes_buf[0].salt->scrypt_p = 1;
10909 break;
10910 case 9100: hashes_buf[0].salt->salt_len = 16;
10911 break;
10912 case 9300: hashes_buf[0].salt->salt_len = 14;
10913 hashes_buf[0].salt->scrypt_N = 16384;
10914 hashes_buf[0].salt->scrypt_r = 1;
10915 hashes_buf[0].salt->scrypt_p = 1;
10916 break;
10917 case 9400: hashes_buf[0].salt->salt_len = 16;
10918 break;
10919 case 9500: hashes_buf[0].salt->salt_len = 16;
10920 break;
10921 case 9600: hashes_buf[0].salt->salt_len = 16;
10922 break;
10923 case 9700: hashes_buf[0].salt->salt_len = 16;
10924 break;
10925 case 9710: hashes_buf[0].salt->salt_len = 16;
10926 break;
10927 case 9720: hashes_buf[0].salt->salt_len = 16;
10928 break;
10929 case 9800: hashes_buf[0].salt->salt_len = 16;
10930 break;
10931 case 9810: hashes_buf[0].salt->salt_len = 16;
10932 break;
10933 case 9820: hashes_buf[0].salt->salt_len = 16;
10934 break;
10935 case 10300: hashes_buf[0].salt->salt_len = 12;
10936 break;
10937 case 11500: hashes_buf[0].salt->salt_len = 4;
10938 break;
10939 case 11600: hashes_buf[0].salt->salt_len = 4;
10940 break;
10941 case 12400: hashes_buf[0].salt->salt_len = 4;
10942 break;
10943 case 12500: hashes_buf[0].salt->salt_len = 8;
10944 break;
10945 case 12600: hashes_buf[0].salt->salt_len = 64;
10946 break;
10947 }
10948
10949 // special esalt handling
10950
10951 switch (hash_mode)
10952 {
10953 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
10954 break;
10955 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
10956 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
10957 break;
10958 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
10959 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
10960 break;
10961 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
10962 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
10963 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
10964 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
10965 break;
10966 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
10967 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
10968 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
10969 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
10970 break;
10971 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
10972 break;
10973 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10974 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
10975 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
10976 break;
10977 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10978 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
10979 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
10980 break;
10981 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10982 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
10983 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
10984 break;
10985 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10986 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
10987 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
10988 break;
10989 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10990 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
10991 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
10992 break;
10993 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10994 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
10995 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
10996 break;
10997 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
10998 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
10999 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11000 break;
11001 }
11002 }
11003
11004 // set hashfile
11005
11006 switch (hash_mode)
11007 {
11008 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11009 break;
11010 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11011 break;
11012 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11013 break;
11014 case 6211:
11015 case 6212:
11016 case 6213:
11017 case 6221:
11018 case 6222:
11019 case 6223:
11020 case 6231:
11021 case 6232:
11022 case 6233:
11023 case 6241:
11024 case 6242:
11025 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11026 break;
11027 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11028 break;
11029 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11030 break;
11031 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11032 break;
11033 }
11034
11035 // set default iterations
11036
11037 switch (hash_mode)
11038 {
11039 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11040 break;
11041 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11042 break;
11043 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11044 break;
11045 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11046 break;
11047 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11048 break;
11049 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11050 break;
11051 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11052 break;
11053 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11054 break;
11055 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11056 break;
11057 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11058 break;
11059 case 6211:
11060 case 6212:
11061 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11062 break;
11063 case 6221:
11064 case 6222:
11065 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11066 break;
11067 case 6231:
11068 case 6232:
11069 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11070 break;
11071 case 6241:
11072 case 6242:
11073 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11074 break;
11075 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11076 break;
11077 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11078 break;
11079 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11080 break;
11081 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11082 break;
11083 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11084 break;
11085 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11086 break;
11087 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11088 break;
11089 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11090 break;
11091 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11092 break;
11093 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11094 break;
11095 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11096 break;
11097 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11098 break;
11099 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11100 break;
11101 case 8900: hashes_buf[0].salt->salt_iter = 1;
11102 break;
11103 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11104 break;
11105 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11106 break;
11107 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11108 break;
11109 case 9300: hashes_buf[0].salt->salt_iter = 1;
11110 break;
11111 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11112 break;
11113 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11114 break;
11115 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11116 break;
11117 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11118 break;
11119 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11120 break;
11121 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11122 break;
11123 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11124 break;
11125 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11126 break;
11127 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11128 break;
11129 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11130 break;
11131 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11132 break;
11133 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11134 break;
11135 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11136 break;
11137 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11138 break;
11139 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11140 break;
11141 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11142 break;
11143 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11144 break;
11145 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11146 break;
11147 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11148 break;
11149 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11150 break;
11151 }
11152
11153 // set special tuning for benchmark-mode 1
11154
11155 if (benchmark_mode == 1)
11156 {
11157 kernel_loops *= 8;
11158 kernel_accel *= 4;
11159
11160 switch (hash_mode)
11161 {
11162 case 400: kernel_loops = ROUNDS_PHPASS;
11163 kernel_accel = 32;
11164 break;
11165 case 500: kernel_loops = ROUNDS_MD5CRYPT;
11166 kernel_accel = 32;
11167 break;
11168 case 501: kernel_loops = ROUNDS_MD5CRYPT;
11169 kernel_accel = 32;
11170 break;
11171 case 1600: kernel_loops = ROUNDS_MD5CRYPT;
11172 kernel_accel = 32;
11173 break;
11174 case 1800: kernel_loops = ROUNDS_SHA512CRYPT;
11175 kernel_accel = 16;
11176 break;
11177 case 2100: kernel_loops = ROUNDS_DCC2;
11178 kernel_accel = 16;
11179 break;
11180 case 2500: kernel_loops = ROUNDS_WPA2;
11181 kernel_accel = 32;
11182 break;
11183 case 3200: kernel_loops = ROUNDS_BCRYPT;
11184 kernel_accel = 8;
11185 break;
11186 case 5200: kernel_loops = ROUNDS_PSAFE3;
11187 kernel_accel = 16;
11188 break;
11189 case 5800: kernel_loops = ROUNDS_ANDROIDPIN;
11190 kernel_accel = 16;
11191 break;
11192 case 6211: kernel_loops = ROUNDS_TRUECRYPT_2K;
11193 kernel_accel = 64;
11194 break;
11195 case 6212: kernel_loops = ROUNDS_TRUECRYPT_2K;
11196 kernel_accel = 32;
11197 break;
11198 case 6213: kernel_loops = ROUNDS_TRUECRYPT_2K;
11199 kernel_accel = 32;
11200 break;
11201 case 6221: kernel_loops = ROUNDS_TRUECRYPT_1K;
11202 kernel_accel = 8;
11203 break;
11204 case 6222: kernel_loops = ROUNDS_TRUECRYPT_1K;
11205 kernel_accel = 8;
11206 break;
11207 case 6223: kernel_loops = ROUNDS_TRUECRYPT_1K;
11208 kernel_accel = 8;
11209 break;
11210 case 6231: kernel_loops = ROUNDS_TRUECRYPT_1K;
11211 kernel_accel = 8;
11212 break;
11213 case 6232: kernel_loops = ROUNDS_TRUECRYPT_1K;
11214 kernel_accel = 8;
11215 break;
11216 case 6233: kernel_loops = ROUNDS_TRUECRYPT_1K;
11217 kernel_accel = 8;
11218 break;
11219 case 6241: kernel_loops = ROUNDS_TRUECRYPT_1K;
11220 kernel_accel = 128;
11221 break;
11222 case 6242: kernel_loops = ROUNDS_TRUECRYPT_1K;
11223 kernel_accel = 64;
11224 break;
11225 case 6243: kernel_loops = ROUNDS_TRUECRYPT_1K;
11226 kernel_accel = 64;
11227 break;
11228 case 6300: kernel_loops = ROUNDS_MD5CRYPT;
11229 kernel_accel = 32;
11230 break;
11231 case 6700: kernel_loops = ROUNDS_SHA1AIX;
11232 kernel_accel = 128;
11233 break;
11234 case 6400: kernel_loops = ROUNDS_SHA256AIX;
11235 kernel_accel = 128;
11236 break;
11237 case 6500: kernel_loops = ROUNDS_SHA512AIX;
11238 kernel_accel = 32;
11239 break;
11240 case 6600: kernel_loops = ROUNDS_AGILEKEY;
11241 kernel_accel = 64;
11242 break;
11243 case 6800: kernel_loops = ROUNDS_LASTPASS;
11244 kernel_accel = 64;
11245 break;
11246 case 7100: kernel_loops = ROUNDS_SHA512OSX;
11247 kernel_accel = 8;
11248 break;
11249 case 7200: kernel_loops = ROUNDS_GRUB;
11250 kernel_accel = 16;
11251 break;
11252 case 7400: kernel_loops = ROUNDS_SHA256CRYPT;
11253 kernel_accel = 8;
11254 break;
11255 case 7900: kernel_loops = ROUNDS_DRUPAL7;
11256 kernel_accel = 8;
11257 break;
11258 case 8200: kernel_loops = ROUNDS_CLOUDKEY;
11259 kernel_accel = 8;
11260 break;
11261 case 8800: kernel_loops = ROUNDS_ANDROIDFDE;
11262 kernel_accel = 32;
11263 break;
11264 case 8900: kernel_loops = 1;
11265 kernel_accel = 64;
11266 break;
11267 case 9000: kernel_loops = ROUNDS_PSAFE2;
11268 kernel_accel = 16;
11269 break;
11270 case 9100: kernel_loops = ROUNDS_LOTUS8;
11271 kernel_accel = 64;
11272 break;
11273 case 9200: kernel_loops = ROUNDS_CISCO8;
11274 kernel_accel = 8;
11275 break;
11276 case 9300: kernel_loops = 1;
11277 kernel_accel = 4;
11278 break;
11279 case 9400: kernel_loops = ROUNDS_OFFICE2007;
11280 kernel_accel = 32;
11281 break;
11282 case 9500: kernel_loops = ROUNDS_OFFICE2010;
11283 kernel_accel = 32;
11284 break;
11285 case 9600: kernel_loops = ROUNDS_OFFICE2013;
11286 kernel_accel = 8;
11287 break;
11288 case 10000: kernel_loops = ROUNDS_DJANGOPBKDF2;
11289 kernel_accel = 8;
11290 break;
11291 case 10300: kernel_loops = ROUNDS_SAPH_SHA1;
11292 kernel_accel = 16;
11293 break;
11294 case 10500: kernel_loops = ROUNDS_PDF14;
11295 kernel_accel = 256;
11296 break;
11297 case 10700: kernel_loops = ROUNDS_PDF17L8;
11298 kernel_accel = 8;
11299 break;
11300 case 10900: kernel_loops = ROUNDS_PBKDF2_SHA256;
11301 kernel_accel = 8;
11302 break;
11303 case 11300: kernel_loops = ROUNDS_BITCOIN_WALLET;
11304 kernel_accel = 8;
11305 break;
11306 case 11600: kernel_loops = ROUNDS_SEVEN_ZIP;
11307 kernel_accel = 8;
11308 break;
11309 case 11900: kernel_loops = ROUNDS_PBKDF2_MD5;
11310 kernel_accel = 8;
11311 break;
11312 case 12000: kernel_loops = ROUNDS_PBKDF2_SHA1;
11313 kernel_accel = 8;
11314 break;
11315 case 12100: kernel_loops = ROUNDS_PBKDF2_SHA512;
11316 kernel_accel = 8;
11317 break;
11318 case 12200: kernel_loops = ROUNDS_ECRYPTFS;
11319 kernel_accel = 8;
11320 break;
11321 case 12300: kernel_loops = ROUNDS_ORACLET;
11322 kernel_accel = 8;
11323 break;
11324 case 12500: kernel_loops = ROUNDS_RAR3;
11325 kernel_accel = 32;
11326 break;
11327 case 12700: kernel_loops = ROUNDS_MYWALLET;
11328 kernel_accel = 512;
11329 break;
11330 case 12800: kernel_loops = ROUNDS_MS_DRSR;
11331 kernel_accel = 512;
11332 break;
11333 case 12900: kernel_loops = ROUNDS_ANDROIDFDE_SAMSUNG;
11334 kernel_accel = 8;
11335 break;
11336 }
11337
11338 // some algorithm collide too fast, make that impossible
11339
11340 switch (hash_mode)
11341 {
11342 case 11500: ((uint *) digests_buf)[1] = 1;
11343 break;
11344 }
11345
11346 if (kernel_loops > 1024) kernel_loops = 1024;
11347 if (kernel_accel > 256) kernel_accel = 256; // causes memory problems otherwise
11348 }
11349
11350 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
11351 {
11352 kernel_loops = 1024;
11353 }
11354
11355 if (hash_mode == 12500)
11356 {
11357 kernel_loops = ROUNDS_RAR3 / 16;
11358 }
11359
11360 data.kernel_accel = kernel_accel;
11361 data.kernel_loops = kernel_loops;
11362
11363 hashes_cnt = 1;
11364 }
11365
11366 if (show == 1 || left == 1)
11367 {
11368 for (uint i = 0; i < pot_cnt; i++)
11369 {
11370 pot_t *pot_ptr = &pot[i];
11371
11372 hash_t *hashes_buf = &pot_ptr->hash;
11373
11374 local_free (hashes_buf->digest);
11375
11376 if (isSalted)
11377 {
11378 local_free (hashes_buf->salt);
11379 }
11380 }
11381
11382 local_free (pot);
11383
11384 if (data.quiet == 0) log_info_nn ("");
11385
11386 return (0);
11387 }
11388
11389 if (keyspace == 0)
11390 {
11391 if (hashes_cnt == 0)
11392 {
11393 log_error ("ERROR: No hashes loaded");
11394
11395 return (-1);
11396 }
11397 }
11398
11399 /**
11400 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11401 */
11402
11403 if (data.outfile != NULL)
11404 {
11405 if (data.hashfile != NULL)
11406 {
11407 #ifdef _POSIX
11408 struct stat tmpstat_outfile;
11409 struct stat tmpstat_hashfile;
11410 #endif
11411
11412 #ifdef _WIN
11413 struct stat64 tmpstat_outfile;
11414 struct stat64 tmpstat_hashfile;
11415 #endif
11416
11417 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11418
11419 if (tmp_outfile_fp)
11420 {
11421 #ifdef _POSIX
11422 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11423 #endif
11424
11425 #ifdef _WIN
11426 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11427 #endif
11428
11429 fclose (tmp_outfile_fp);
11430 }
11431
11432 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11433
11434 if (tmp_hashfile_fp)
11435 {
11436 #ifdef _POSIX
11437 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11438 #endif
11439
11440 #ifdef _WIN
11441 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11442 #endif
11443
11444 fclose (tmp_hashfile_fp);
11445 }
11446
11447 if (tmp_outfile_fp && tmp_outfile_fp)
11448 {
11449 tmpstat_outfile.st_mode = 0;
11450 tmpstat_outfile.st_nlink = 0;
11451 tmpstat_outfile.st_uid = 0;
11452 tmpstat_outfile.st_gid = 0;
11453 tmpstat_outfile.st_rdev = 0;
11454 tmpstat_outfile.st_atime = 0;
11455
11456 tmpstat_hashfile.st_mode = 0;
11457 tmpstat_hashfile.st_nlink = 0;
11458 tmpstat_hashfile.st_uid = 0;
11459 tmpstat_hashfile.st_gid = 0;
11460 tmpstat_hashfile.st_rdev = 0;
11461 tmpstat_hashfile.st_atime = 0;
11462
11463 #ifdef _POSIX
11464 tmpstat_outfile.st_blksize = 0;
11465 tmpstat_outfile.st_blocks = 0;
11466
11467 tmpstat_hashfile.st_blksize = 0;
11468 tmpstat_hashfile.st_blocks = 0;
11469 #endif
11470
11471 #ifdef _POSIX
11472 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11473 {
11474 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11475
11476 return (-1);
11477 }
11478 #endif
11479
11480 #ifdef _WIN
11481 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11482 {
11483 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11484
11485 return (-1);
11486 }
11487 #endif
11488 }
11489 }
11490 }
11491
11492 /**
11493 * Remove duplicates
11494 */
11495
11496 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11497
11498 if (isSalted)
11499 {
11500 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11501 }
11502 else
11503 {
11504 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11505 }
11506
11507 uint hashes_cnt_orig = hashes_cnt;
11508
11509 hashes_cnt = 1;
11510
11511 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11512 {
11513 if (isSalted)
11514 {
11515 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11516 {
11517 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11518 }
11519 }
11520 else
11521 {
11522 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11523 }
11524
11525 if (hashes_pos > hashes_cnt)
11526 {
11527 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11528 }
11529
11530 hashes_cnt++;
11531 }
11532
11533 /**
11534 * Potfile removes
11535 */
11536
11537 uint potfile_remove_cracks = 0;
11538
11539 if (potfile_disable == 0)
11540 {
11541 hash_t hash_buf;
11542
11543 hash_buf.digest = mymalloc (dgst_size);
11544 hash_buf.salt = NULL;
11545 hash_buf.esalt = NULL;
11546 hash_buf.hash_info = NULL;
11547 hash_buf.cracked = 0;
11548
11549 if (isSalted)
11550 {
11551 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11552 }
11553
11554 if (esalt_size)
11555 {
11556 hash_buf.esalt = mymalloc (esalt_size);
11557 }
11558
11559 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11560
11561 // no solution for these special hash types (for instane because they use hashfile in output etc)
11562 if ((hash_mode != 5200) &&
11563 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11564 (hash_mode != 9000))
11565 {
11566 FILE *fp = fopen (potfile, "rb");
11567
11568 if (fp != NULL)
11569 {
11570 while (!feof (fp))
11571 {
11572 char line_buf[BUFSIZ];
11573
11574 memset (line_buf, 0, BUFSIZ);
11575
11576 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11577
11578 if (ptr == NULL) break;
11579
11580 int line_len = strlen (line_buf);
11581
11582 if (line_len == 0) continue;
11583
11584 int iter = MAX_CUT_TRIES;
11585
11586 for (int i = line_len - 1; i && iter; i--, line_len--)
11587 {
11588 if (line_buf[i] != ':') continue;
11589
11590 if (isSalted)
11591 {
11592 memset (hash_buf.salt, 0, sizeof (salt_t));
11593 }
11594
11595 hash_t *found = NULL;
11596
11597 if (hash_mode == 6800)
11598 {
11599 if (i < 48) // 48 = 12 * uint in salt_buf[]
11600 {
11601 // manipulate salt_buf
11602 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11603
11604 hash_buf.salt->salt_len = i;
11605
11606 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11607 }
11608 }
11609 else if (hash_mode == 2500)
11610 {
11611 if (i < 48) // 48 = 12 * uint in salt_buf[]
11612 {
11613 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11614 // manipulate salt_buf
11615
11616 // to be safe work with a copy (because of line_len loop, i etc)
11617
11618 char line_buf_cpy[BUFSIZ];
11619 memset (line_buf_cpy, 0, BUFSIZ);
11620
11621 memset (line_buf_cpy, 0, sizeof (line_buf_cpy));
11622
11623 memcpy (line_buf_cpy, line_buf, i);
11624
11625 char *mac2_pos = strrchr (line_buf_cpy, ':');
11626
11627 if (mac2_pos == NULL) continue;
11628
11629 mac2_pos[0] = 0;
11630 mac2_pos++;
11631
11632 if (strlen (mac2_pos) != 12) continue;
11633
11634 char *mac1_pos = strrchr (line_buf_cpy, ':');
11635
11636 if (mac1_pos == NULL) continue;
11637
11638 mac1_pos[0] = 0;
11639 mac1_pos++;
11640
11641 if (strlen (mac1_pos) != 12) continue;
11642
11643 uint essid_length = mac1_pos - line_buf_cpy - 1;
11644
11645 // here we need the ESSID
11646 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11647
11648 hash_buf.salt->salt_len = essid_length;
11649
11650 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11651
11652 if (found)
11653 {
11654 wpa_t *wpa = (wpa_t *) found->esalt;
11655
11656 uint pke[25];
11657
11658 char *pke_ptr = (char *) pke;
11659
11660 for (uint i = 0; i < 25; i++)
11661 {
11662 pke[i] = byte_swap_32 (wpa->pke[i]);
11663 }
11664
11665 unsigned char mac1[6];
11666 unsigned char mac2[6];
11667
11668 memcpy (mac1, pke_ptr + 23, 6);
11669 memcpy (mac2, pke_ptr + 29, 6);
11670
11671 // compare hex string(s) vs binary MAC address(es)
11672
11673 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11674 {
11675 if (mac1[i] != (unsigned char) hex_to_char (&mac1_pos[j]))
11676 {
11677 found = NULL;
11678 break;
11679 }
11680 }
11681
11682 // early skip ;)
11683 if (!found) continue;
11684
11685 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11686 {
11687 if (mac2[i] != (unsigned char) hex_to_char (&mac2_pos[j]))
11688 {
11689 found = NULL;
11690 break;
11691 }
11692 }
11693 }
11694 }
11695 }
11696 else
11697 {
11698 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11699
11700 if (parser_status == PARSER_OK)
11701 {
11702 if (isSalted)
11703 {
11704 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11705 }
11706 else
11707 {
11708 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11709 }
11710 }
11711 }
11712
11713 if (found == NULL) continue;
11714
11715 if (!found->cracked) potfile_remove_cracks++;
11716
11717 found->cracked = 1;
11718
11719 if (found) break;
11720
11721 iter--;
11722 }
11723 }
11724
11725 fclose (fp);
11726 }
11727 }
11728
11729 if (esalt_size)
11730 {
11731 local_free (hash_buf.esalt);
11732 }
11733
11734 if (isSalted)
11735 {
11736 local_free (hash_buf.salt);
11737 }
11738
11739 local_free (hash_buf.digest);
11740 }
11741
11742 /**
11743 * Now generate all the buffers required for later
11744 */
11745
11746 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11747
11748 salt_t *salts_buf_new = NULL;
11749 void *esalts_buf_new = NULL;
11750
11751 if (isSalted)
11752 {
11753 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11754
11755 if (esalt_size)
11756 {
11757 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
11758 }
11759 }
11760 else
11761 {
11762 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
11763 }
11764
11765 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
11766
11767 uint digests_cnt = hashes_cnt;
11768 uint digests_done = 0;
11769
11770 uint size_digests = digests_cnt * dgst_size;
11771 uint size_shown = digests_cnt * sizeof (uint);
11772
11773 uint *digests_shown = (uint *) mymalloc (size_shown);
11774 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
11775
11776 uint salts_cnt = 0;
11777 uint salts_done = 0;
11778
11779 hashinfo_t **hash_info = NULL;
11780
11781 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11782 {
11783 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
11784
11785 if (username && (remove || show))
11786 {
11787 uint user_pos;
11788
11789 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
11790 {
11791 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
11792
11793 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
11794 }
11795 }
11796 }
11797
11798 uint *salts_shown = (uint *) mymalloc (size_shown);
11799
11800 salt_t *salt_buf;
11801
11802 {
11803 // copied from inner loop
11804
11805 salt_buf = &salts_buf_new[salts_cnt];
11806
11807 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
11808
11809 if (esalt_size)
11810 {
11811 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
11812 }
11813
11814 salt_buf->digests_cnt = 0;
11815 salt_buf->digests_done = 0;
11816 salt_buf->digests_offset = 0;
11817
11818 salts_cnt++;
11819 }
11820
11821 if (hashes_buf[0].cracked == 1)
11822 {
11823 digests_shown[0] = 1;
11824
11825 digests_done++;
11826
11827 salt_buf->digests_done++;
11828 }
11829
11830 salt_buf->digests_cnt++;
11831
11832 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
11833
11834 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11835 {
11836 hash_info[0] = hashes_buf[0].hash_info;
11837 }
11838
11839 // copy from inner loop
11840
11841 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
11842 {
11843 if (isSalted)
11844 {
11845 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
11846 {
11847 salt_buf = &salts_buf_new[salts_cnt];
11848
11849 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
11850
11851 if (esalt_size)
11852 {
11853 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
11854 }
11855
11856 salt_buf->digests_cnt = 0;
11857 salt_buf->digests_done = 0;
11858 salt_buf->digests_offset = hashes_pos;
11859
11860 salts_cnt++;
11861 }
11862 }
11863
11864 if (hashes_buf[hashes_pos].cracked == 1)
11865 {
11866 digests_shown[hashes_pos] = 1;
11867
11868 digests_done++;
11869
11870 salt_buf->digests_done++;
11871 }
11872
11873 salt_buf->digests_cnt++;
11874
11875 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
11876
11877 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11878 {
11879 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
11880 }
11881 }
11882
11883 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
11884 {
11885 salt_t *salt_buf = &salts_buf_new[salt_pos];
11886
11887 if (salt_buf->digests_done == salt_buf->digests_cnt)
11888 {
11889 salts_shown[salt_pos] = 1;
11890
11891 salts_done++;
11892 }
11893
11894 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
11895 }
11896
11897 local_free (digests_buf);
11898 local_free (salts_buf);
11899 local_free (esalts_buf);
11900
11901 digests_buf = digests_buf_new;
11902 salts_buf = salts_buf_new;
11903 esalts_buf = esalts_buf_new;
11904
11905 local_free (hashes_buf);
11906
11907 /**
11908 * special modification not set from parser
11909 */
11910
11911 switch (hash_mode)
11912 {
11913 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
11914 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
11915 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
11916 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
11917 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
11918 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
11919 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
11920 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
11921 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
11922 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
11923 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
11924 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
11925 }
11926
11927 if (truecrypt_keyfiles)
11928 {
11929 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
11930
11931 char *keyfiles = strdup (truecrypt_keyfiles);
11932
11933 char *keyfile = strtok (keyfiles, ",");
11934
11935 do
11936 {
11937 truecrypt_crc32 (keyfile, (unsigned char *) keyfile_buf);
11938
11939 } while ((keyfile = strtok (NULL, ",")) != NULL);
11940
11941 free (keyfiles);
11942 }
11943
11944 data.digests_cnt = digests_cnt;
11945 data.digests_done = digests_done;
11946 data.digests_buf = digests_buf;
11947 data.digests_shown = digests_shown;
11948 data.digests_shown_tmp = digests_shown_tmp;
11949
11950 data.salts_cnt = salts_cnt;
11951 data.salts_done = salts_done;
11952 data.salts_buf = salts_buf;
11953 data.salts_shown = salts_shown;
11954
11955 data.esalts_buf = esalts_buf;
11956 data.hash_info = hash_info;
11957
11958 /**
11959 * Automatic Optimizers
11960 */
11961
11962 if (salts_cnt == 1)
11963 opti_type |= OPTI_TYPE_SINGLE_SALT;
11964
11965 if (digests_cnt == 1)
11966 opti_type |= OPTI_TYPE_SINGLE_HASH;
11967
11968 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11969 opti_type |= OPTI_TYPE_NOT_ITERATED;
11970
11971 if (attack_mode == ATTACK_MODE_BF)
11972 opti_type |= OPTI_TYPE_BRUTE_FORCE;
11973
11974 data.opti_type = opti_type;
11975
11976 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
11977 {
11978 if (opti_type & OPTI_TYPE_SINGLE_HASH)
11979 {
11980 if (opti_type & OPTI_TYPE_APPENDED_SALT)
11981 {
11982 if (opts_type & OPTS_TYPE_ST_ADD80)
11983 {
11984 opts_type &= ~OPTS_TYPE_ST_ADD80;
11985 opts_type |= OPTS_TYPE_PT_ADD80;
11986 }
11987
11988 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
11989 {
11990 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
11991 opts_type |= OPTS_TYPE_PT_ADDBITS14;
11992 }
11993
11994 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
11995 {
11996 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
11997 opts_type |= OPTS_TYPE_PT_ADDBITS15;
11998 }
11999 }
12000 }
12001 }
12002
12003 /**
12004 * Some algorithm, like descrypt, can benefit from JIT compilation
12005 */
12006
12007 uint force_jit_compilation = 0;
12008
12009 if (hash_mode == 8900)
12010 {
12011 force_jit_compilation = 8900;
12012 }
12013 else if (hash_mode == 9300)
12014 {
12015 force_jit_compilation = 8900;
12016 }
12017 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12018 {
12019 force_jit_compilation = 1500;
12020 }
12021
12022 /**
12023 * generate bitmap tables
12024 */
12025
12026 const uint bitmap_shift1 = 5;
12027 const uint bitmap_shift2 = 13;
12028
12029 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12030
12031 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12032 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12033 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12034 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12035 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12036 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12037 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12038 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12039
12040 uint bitmap_bits;
12041 uint bitmap_nums;
12042 uint bitmap_mask;
12043 uint bitmap_size;
12044
12045 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12046 {
12047 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12048
12049 bitmap_nums = 1 << bitmap_bits;
12050
12051 bitmap_mask = bitmap_nums - 1;
12052
12053 bitmap_size = bitmap_nums * sizeof (uint);
12054
12055 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12056
12057 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;
12058 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;
12059
12060 break;
12061 }
12062
12063 bitmap_nums = 1 << bitmap_bits;
12064
12065 bitmap_mask = bitmap_nums - 1;
12066
12067 bitmap_size = bitmap_nums * sizeof (uint);
12068
12069 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);
12070 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);
12071
12072 /**
12073 * prepare quick rule
12074 */
12075
12076 data.rule_buf_l = rule_buf_l;
12077 data.rule_buf_r = rule_buf_r;
12078
12079 int rule_len_l = (int) strlen (rule_buf_l);
12080 int rule_len_r = (int) strlen (rule_buf_r);
12081
12082 data.rule_len_l = rule_len_l;
12083 data.rule_len_r = rule_len_r;
12084
12085 /**
12086 * load rules
12087 */
12088
12089 uint *all_kernel_rules_cnt = NULL;
12090
12091 kernel_rule_t **all_kernel_rules_buf = NULL;
12092
12093 if (rp_files_cnt)
12094 {
12095 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12096
12097 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12098 }
12099
12100 char rule_buf[BUFSIZ];
12101
12102 int rule_len = 0;
12103
12104 for (uint i = 0; i < rp_files_cnt; i++)
12105 {
12106 uint kernel_rules_avail = 0;
12107
12108 uint kernel_rules_cnt = 0;
12109
12110 kernel_rule_t *kernel_rules_buf = NULL;
12111
12112 char *rp_file = rp_files[i];
12113
12114 char in[BLOCK_SIZE];
12115 char out[BLOCK_SIZE];
12116
12117 FILE *fp = NULL;
12118
12119 uint rule_line = 0;
12120
12121 if ((fp = fopen (rp_file, "rb")) == NULL)
12122 {
12123 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12124
12125 return (-1);
12126 }
12127
12128 while (!feof (fp))
12129 {
12130 memset (rule_buf, 0, BUFSIZ);
12131
12132 rule_len = fgetl (fp, rule_buf);
12133
12134 rule_line++;
12135
12136 if (rule_len == 0) continue;
12137
12138 if (rule_buf[0] == '#') continue;
12139
12140 if (kernel_rules_avail == kernel_rules_cnt)
12141 {
12142 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12143
12144 kernel_rules_avail += INCR_RULES;
12145 }
12146
12147 memset (in, 0, BLOCK_SIZE);
12148 memset (out, 0, BLOCK_SIZE);
12149
12150 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12151
12152 if (result == -1)
12153 {
12154 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12155
12156 continue;
12157 }
12158
12159 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12160 {
12161 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12162
12163 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12164
12165 continue;
12166 }
12167
12168 /* its so slow
12169 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12170 {
12171 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12172
12173 continue;
12174 }
12175 */
12176
12177 kernel_rules_cnt++;
12178 }
12179
12180 fclose (fp);
12181
12182 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12183
12184 all_kernel_rules_buf[i] = kernel_rules_buf;
12185 }
12186
12187 /**
12188 * merge rules or automatic rule generator
12189 */
12190
12191 uint kernel_rules_cnt = 0;
12192
12193 kernel_rule_t *kernel_rules_buf = NULL;
12194
12195 if (attack_mode == ATTACK_MODE_STRAIGHT)
12196 {
12197 if (rp_files_cnt)
12198 {
12199 kernel_rules_cnt = 1;
12200
12201 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12202
12203 repeats[0] = kernel_rules_cnt;
12204
12205 for (uint i = 0; i < rp_files_cnt; i++)
12206 {
12207 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12208
12209 repeats[i + 1] = kernel_rules_cnt;
12210 }
12211
12212 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12213
12214 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12215
12216 for (uint i = 0; i < kernel_rules_cnt; i++)
12217 {
12218 uint out_pos = 0;
12219
12220 kernel_rule_t *out = &kernel_rules_buf[i];
12221
12222 for (uint j = 0; j < rp_files_cnt; j++)
12223 {
12224 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12225 uint in_pos;
12226
12227 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12228
12229 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12230 {
12231 if (out_pos == RULES_MAX - 1)
12232 {
12233 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12234
12235 break;
12236 }
12237
12238 out->cmds[out_pos] = in->cmds[in_pos];
12239 }
12240 }
12241 }
12242
12243 local_free (repeats);
12244 }
12245 else if (rp_gen)
12246 {
12247 uint kernel_rules_avail = 0;
12248
12249 while (kernel_rules_cnt < rp_gen)
12250 {
12251 if (kernel_rules_avail == kernel_rules_cnt)
12252 {
12253 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12254
12255 kernel_rules_avail += INCR_RULES;
12256 }
12257
12258 memset (rule_buf, 0, BLOCK_SIZE);
12259
12260 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12261
12262 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12263
12264 kernel_rules_cnt++;
12265 }
12266 }
12267 }
12268
12269 /**
12270 * generate NOP rules
12271 */
12272
12273 if (kernel_rules_cnt == 0)
12274 {
12275 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12276
12277 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12278
12279 kernel_rules_cnt++;
12280 }
12281
12282 data.kernel_rules_cnt = kernel_rules_cnt;
12283 data.kernel_rules_buf = kernel_rules_buf;
12284
12285 /**
12286 * platform
12287 */
12288
12289 cl_platform_id CL_platforms[CL_PLATFORMS_MAX];
12290
12291 uint CL_platforms_cnt = 0;
12292
12293 hc_clGetPlatformIDs (CL_PLATFORMS_MAX, CL_platforms, &CL_platforms_cnt);
12294
12295 if (CL_platforms_cnt == 0)
12296 {
12297 log_error ("ERROR: No OpenCL compatible platform found");
12298
12299 return (-1);
12300 }
12301
12302 int CL_platform_sel = 1;
12303
12304 if (opencl_platform != NULL)
12305 {
12306 CL_platform_sel = atoi (opencl_platform);
12307 }
12308
12309 if (CL_platforms_cnt > 1)
12310 {
12311 if (opencl_platform == NULL)
12312 {
12313 log_error ("ERROR: Too many OpenCL compatible platforms found");
12314
12315 log_info ("Please select a single platform using the --opencl-platform option");
12316 log_info ("");
12317 log_info ("Available OpenCL platforms:");
12318 log_info ("");
12319
12320 for (uint i = 0; i < CL_platforms_cnt; i++)
12321 {
12322 char CL_platform_vendor[INFOSZ];
12323
12324 memset (CL_platform_vendor, 0, sizeof (CL_platform_vendor));
12325
12326 hc_clGetPlatformInfo (CL_platforms[i], CL_PLATFORM_VENDOR, sizeof (CL_platform_vendor), CL_platform_vendor, NULL);
12327
12328 log_info ("* %d = %s", i + 1, CL_platform_vendor);
12329 }
12330
12331 log_info ("");
12332
12333 return (-1);
12334 }
12335 else
12336 {
12337 if (CL_platform_sel < 1)
12338 {
12339 log_error ("ERROR: --opencl-platform < 1");
12340
12341 return (-1);
12342 }
12343
12344 if (CL_platform_sel > (int) CL_platforms_cnt)
12345 {
12346 log_error ("ERROR: invalid OpenCL platforms selected");
12347
12348 return (-1);
12349 }
12350 }
12351 }
12352 else
12353 {
12354 if (CL_platform_sel != 1)
12355 {
12356 log_error ("ERROR: OpenCL platform number %d is not available", CL_platform_sel);
12357
12358 return (-1);
12359 }
12360 }
12361
12362 // zero-indexed: not starting to count at 1, as user does
12363
12364 CL_platform_sel -= 1;
12365
12366
12367 cl_platform_id CL_platform = CL_platforms[CL_platform_sel];
12368
12369 char CL_platform_vendor[INFOSZ];
12370
12371 memset (CL_platform_vendor, 0, sizeof (CL_platform_vendor));
12372
12373 hc_clGetPlatformInfo (CL_platform, CL_PLATFORM_VENDOR, sizeof (CL_platform_vendor), CL_platform_vendor, NULL);
12374
12375 cl_device_type device_type_filter;
12376
12377 uint vendor_id;
12378
12379 if (strcmp (CL_platform_vendor, CL_VENDOR_AMD) == 0)
12380 {
12381 vendor_id = VENDOR_ID_AMD;
12382
12383 device_type_filter = CL_DEVICE_TYPE_GPU;
12384 }
12385 else if (strcmp (CL_platform_vendor, CL_VENDOR_NV) == 0)
12386 {
12387 vendor_id = VENDOR_ID_NV;
12388
12389 device_type_filter = CL_DEVICE_TYPE_GPU;
12390
12391 // make sure that we do not directly control the fan for NVidia
12392
12393 gpu_temp_retain = 0;
12394
12395 data.gpu_temp_retain = gpu_temp_retain;
12396 }
12397 else if (strcmp (CL_platform_vendor, CL_VENDOR_POCL) == 0)
12398 {
12399 if (force == 0)
12400 {
12401 log_error ("");
12402 log_error ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12403 log_error ("You are STRONGLY encouraged not to use it");
12404 log_error ("You can use --force to override this but do not post error reports if you do so");
12405
12406 return (-1);
12407 }
12408
12409 vendor_id = VENDOR_ID_GENERIC;
12410
12411 device_type_filter = CL_DEVICE_TYPE_DEFAULT;
12412 }
12413 else
12414 {
12415 vendor_id = VENDOR_ID_GENERIC;
12416
12417 device_type_filter = CL_DEVICE_TYPE_DEFAULT;
12418 }
12419
12420 if (vendor_id == VENDOR_ID_GENERIC)
12421 {
12422 log_error ("Warning: unknown OpenCL vendor '%s' detected", CL_platform_vendor);
12423
12424 gpu_temp_disable = 1;
12425 }
12426
12427 data.vendor_id = vendor_id;
12428
12429 /**
12430 * cached kernel path depends on vendor_id which we don't know, so create it here
12431 */
12432
12433 int vendor_id_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 10 + 1;
12434
12435 char *vendor_id_folder = (char *) mymalloc (vendor_id_folder_size);
12436
12437 snprintf (vendor_id_folder, vendor_id_folder_size - 1, "%s/kernels", profile_dir);
12438
12439 mkdir (vendor_id_folder, 0700);
12440
12441 snprintf (vendor_id_folder, vendor_id_folder_size - 1, "%s/kernels/%d", profile_dir, vendor_id);
12442
12443 mkdir (vendor_id_folder, 0700);
12444
12445 myfree (vendor_id_folder);
12446
12447 /**
12448 * devices
12449 */
12450
12451 cl_device_id devices_all[DEVICES_MAX];
12452 cl_device_id devices[DEVICES_MAX];
12453
12454 uint devices_all_cnt = 0;
12455
12456 hc_clGetDeviceIDs (CL_platform, device_type_filter, DEVICES_MAX, devices_all, (uint *) &devices_all_cnt);
12457
12458 int hm_adapters_all = devices_all_cnt;
12459
12460 hm_attrs_t hm_adapter_all[DEVICES_MAX];
12461
12462 memset (hm_adapter_all, 0, sizeof (hm_adapter_all));
12463
12464 if (gpu_temp_disable == 0)
12465 {
12466 if (vendor_id == VENDOR_ID_NV)
12467 {
12468 #ifdef LINUX
12469 HM_LIB hm_dll = hm_init ();
12470
12471 data.hm_dll = hm_dll;
12472
12473 if (hc_NVML_nvmlInit (hm_dll) == NVML_SUCCESS)
12474 {
12475 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX];
12476
12477 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12478
12479 int tmp_out = 0;
12480
12481 for (int i = 0; i < tmp_in; i++)
12482 {
12483 hm_adapter_all[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12484 }
12485
12486 hm_adapters_all = tmp_out;
12487
12488 for (int i = 0; i < tmp_out; i++)
12489 {
12490 unsigned int speed;
12491
12492 if (hc_NVML_nvmlDeviceGetFanSpeed (hm_dll, 1, hm_adapter_all[i].adapter_index.nv, &speed) != NVML_ERROR_NOT_SUPPORTED) hm_adapter_all[i].fan_supported = 1;
12493 }
12494 }
12495 #endif
12496
12497 #ifdef WIN
12498 if (NvAPI_Initialize () == NVAPI_OK)
12499 {
12500 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX];
12501
12502 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12503
12504 int tmp_out = 0;
12505
12506 for (int i = 0; i < tmp_in; i++)
12507 {
12508 hm_adapter_all[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12509 }
12510
12511 hm_adapters_all = tmp_out;
12512
12513 for (int i = 0; i < tmp_out; i++)
12514 {
12515 NvU32 speed;
12516
12517 if (NvAPI_GPU_GetTachReading (hm_adapter_all[i].adapter_index.nv, &speed) != NVAPI_NOT_SUPPORTED) hm_adapter_all[i].fan_supported = 1;
12518 }
12519 }
12520 #endif
12521 }
12522
12523 if (vendor_id == VENDOR_ID_AMD)
12524 {
12525 HM_LIB hm_dll = hm_init ();
12526
12527 data.hm_dll = hm_dll;
12528
12529 if (hc_ADL_Main_Control_Create (hm_dll, ADL_Main_Memory_Alloc, 0) == ADL_OK)
12530 {
12531 // total number of adapters
12532
12533 int hm_adapters_num;
12534
12535 if (get_adapters_num_amd (hm_dll, &hm_adapters_num) != 0) return (-1);
12536
12537 // adapter info
12538
12539 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (hm_dll, hm_adapters_num);
12540
12541 if (lpAdapterInfo == NULL) return (-1);
12542
12543 // get a list (of ids of) valid/usable adapters
12544
12545 int num_adl_adapters = 0;
12546
12547 uint32_t *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
12548
12549 if (num_adl_adapters > 0)
12550 {
12551 hc_thread_mutex_lock (mux_adl);
12552
12553 // hm_get_opencl_busid_devid (hm_adapter_all, devices_all_cnt, devices_all);
12554
12555 hm_get_adapter_index_amd (hm_adapter_all, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12556
12557 hm_get_overdrive_version (hm_dll, hm_adapter_all, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12558 hm_check_fanspeed_control (hm_dll, hm_adapter_all, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12559
12560 hc_thread_mutex_unlock (mux_adl);
12561 }
12562
12563 hm_adapters_all = num_adl_adapters;
12564
12565 myfree (valid_adl_device_list);
12566 myfree (lpAdapterInfo);
12567 }
12568 }
12569 }
12570
12571 if (hm_adapters_all == 0)
12572 {
12573 gpu_temp_disable = 1;
12574 }
12575
12576 if (gpu_temp_disable == 1)
12577 {
12578 gpu_temp_abort = 0;
12579 gpu_temp_retain = 0;
12580 }
12581
12582 /**
12583 * enable custom signal handler(s)
12584 */
12585
12586 if (benchmark == 0)
12587 {
12588 hc_signal (sigHandler_default);
12589 }
12590 else
12591 {
12592 hc_signal (sigHandler_benchmark);
12593 }
12594
12595 /**
12596 * devices mask and properties
12597 */
12598
12599 uint devices_cnt = 0;
12600
12601 for (uint device_all_id = 0; device_all_id < devices_all_cnt; device_all_id++)
12602 {
12603 if (opencl_devicemask)
12604 {
12605 uint device_all_id_mask = 1 << device_all_id;
12606
12607 if ((device_all_id_mask & opencl_devicemask) != device_all_id_mask)
12608 {
12609 if (quiet == 0 && algorithm_pos == 0) log_info ("Device #%d: skipped by user", device_all_id_mask + 1);
12610
12611 continue;
12612 }
12613 }
12614
12615 const uint device_id = devices_cnt;
12616
12617 devices[device_id] = devices_all[device_all_id];
12618
12619 memcpy (&data.hm_device[device_id], &hm_adapter_all[device_all_id], sizeof (hm_attrs_t));
12620
12621 char device_name[INFOSZ];
12622
12623 memset (device_name, 0, sizeof (device_name));
12624
12625 cl_ulong global_mem_size;
12626 cl_ulong max_mem_alloc_size;
12627 cl_uint max_clock_frequency;
12628 cl_uint max_compute_units;
12629
12630 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_NAME, sizeof (device_name), &device_name, NULL);
12631 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (global_mem_size), &global_mem_size, NULL);
12632 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (max_mem_alloc_size), &max_mem_alloc_size, NULL);
12633 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (max_clock_frequency), &max_clock_frequency, NULL);
12634 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (max_compute_units), &max_compute_units, NULL);
12635
12636 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12637 {
12638 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12639 device_all_id + 1,
12640 device_name,
12641 (unsigned int) (max_mem_alloc_size / 1024 / 1024),
12642 (unsigned int) (global_mem_size / 1024 / 1024),
12643 (unsigned int) (max_clock_frequency),
12644 (unsigned int) max_compute_units);
12645 }
12646
12647 devices_cnt++;
12648 }
12649
12650 if (devices_cnt == 0)
12651 {
12652 log_error ("ERROR: No devices left that matches your specification.");
12653
12654 return (-1);
12655 }
12656
12657 data.devices_cnt = devices_cnt;
12658
12659 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12660 {
12661 log_info ("");
12662 }
12663
12664 /**
12665 * inform the user
12666 */
12667
12668 // gpu temp sanity check
12669
12670 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
12671 {
12672 if (gpu_temp_abort < gpu_temp_retain)
12673 {
12674 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
12675
12676 return (-1);
12677 }
12678 }
12679
12680 data.gpu_temp_disable = gpu_temp_disable;
12681 data.gpu_temp_abort = gpu_temp_abort;
12682 data.gpu_temp_retain = gpu_temp_retain;
12683
12684 if (data.quiet == 0)
12685 {
12686 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
12687
12688 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);
12689
12690 if (attack_mode == ATTACK_MODE_STRAIGHT)
12691 {
12692 log_info ("Rules: %u", kernel_rules_cnt);
12693 }
12694
12695 if (opti_type)
12696 {
12697 log_info ("Applicable Optimizers:");
12698
12699 for (uint i = 0; i < 32; i++)
12700 {
12701 const uint opti_bit = 1 << i;
12702
12703 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
12704 }
12705 }
12706
12707 /**
12708 * Watchdog and Temperature balance
12709 */
12710
12711 if (gpu_temp_abort == 0)
12712 {
12713 log_info ("Watchdog: Temperature abort trigger disabled");
12714 }
12715 else
12716 {
12717 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
12718 }
12719
12720 if (gpu_temp_retain == 0)
12721 {
12722 log_info ("Watchdog: Temperature retain trigger disabled");
12723 }
12724 else
12725 {
12726 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
12727 }
12728 }
12729
12730 /**
12731 * devices init
12732 */
12733
12734 int *temp_retain_fanspeed_value = (int *) mycalloc (devices_cnt, sizeof (int));
12735
12736 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (devices_cnt, sizeof (ADLOD6MemClockState));
12737
12738 int *od_power_control_status = (int *) mycalloc (devices_cnt, sizeof (int));
12739
12740 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (devices_cnt, sizeof (hc_device_param_t));
12741
12742 data.devices_param = devices_param;
12743
12744 for (uint device_id = 0; device_id < devices_cnt; device_id++)
12745 {
12746 hc_device_param_t *device_param = &data.devices_param[device_id];
12747
12748 cl_device_id device = devices[device_id];
12749
12750 device_param->device = device;
12751
12752 cl_device_type device_type = 0;
12753
12754 hc_clGetDeviceInfo (device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12755
12756 device_param->device_type = device_type;
12757
12758 cl_uint max_compute_units = 0;
12759
12760 hc_clGetDeviceInfo (device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (max_compute_units), &max_compute_units, NULL);
12761
12762 device_param->device_processors = max_compute_units;
12763
12764 cl_ulong max_mem_alloc_size = 0;
12765
12766 hc_clGetDeviceInfo (device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (max_mem_alloc_size), &max_mem_alloc_size, NULL);
12767
12768 device_param->device_maxmem_alloc = max_mem_alloc_size;
12769
12770 char tmp[INFOSZ], t1[64];
12771
12772 memset (tmp, 0, sizeof (tmp));
12773
12774 hc_clGetDeviceInfo (device, CL_DEVICE_NAME, sizeof (tmp), &tmp, NULL);
12775
12776 device_param->device_name = mystrdup (tmp);
12777
12778 memset (tmp, 0, sizeof (tmp));
12779
12780 hc_clGetDeviceInfo (device, CL_DEVICE_VERSION, sizeof (tmp), &tmp, NULL);
12781
12782 memset (t1, 0, sizeof (t1));
12783
12784 sscanf (tmp, "%*16s %*16s %*16s (%[^)]16s)", t1);
12785
12786 device_param->device_version = mystrdup (t1);
12787
12788 memset (tmp, 0, sizeof (tmp));
12789
12790 hc_clGetDeviceInfo (device, CL_DRIVER_VERSION, sizeof (tmp), &tmp, NULL);
12791
12792 device_param->driver_version = mystrdup (tmp);
12793
12794 // create some filename that is easier to read on cached folder
12795
12796 snprintf (tmp, sizeof (tmp) - 1, "%s-%s-%s-%d", device_param->device_name, device_param->device_version, device_param->driver_version, COMPTIME);
12797
12798 uint device_name_digest[4];
12799
12800 device_name_digest[0] = 0;
12801 device_name_digest[1] = 0;
12802 device_name_digest[2] = 0;
12803 device_name_digest[3] = 0;
12804
12805 md5_64 ((uint *) tmp, device_name_digest);
12806
12807 sprintf (tmp, "%08x", device_name_digest[0]);
12808
12809 device_param->device_name_chksum = mystrdup (tmp);
12810
12811 if (device_type & CL_DEVICE_TYPE_CPU)
12812 {
12813 cl_uint device_processor_cores = 1;
12814
12815 device_param->device_processor_cores = device_processor_cores;
12816 }
12817
12818 if (device_type & CL_DEVICE_TYPE_GPU)
12819 {
12820 if (vendor_id == VENDOR_ID_AMD)
12821 {
12822 cl_uint device_processor_cores = 0;
12823
12824 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12825
12826 hc_clGetDeviceInfo (device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12827
12828 device_param->device_processor_cores = device_processor_cores;
12829 }
12830
12831 if (vendor_id == VENDOR_ID_NV)
12832 {
12833 cl_uint kernel_exec_timeout = 0;
12834
12835 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12836
12837 hc_clGetDeviceInfo (device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12838
12839 device_param->kernel_exec_timeout = kernel_exec_timeout;
12840
12841 cl_uint device_processor_cores = 0;
12842
12843 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12844
12845 hc_clGetDeviceInfo (device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12846
12847 device_param->device_processor_cores = device_processor_cores;
12848
12849 cl_uint sm_minor = 0;
12850 cl_uint sm_major = 0;
12851
12852 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12853 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12854
12855 hc_clGetDeviceInfo (device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12856 hc_clGetDeviceInfo (device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12857
12858 device_param->sm_minor = sm_minor;
12859 device_param->sm_major = sm_major;
12860 }
12861 }
12862
12863 /**
12864 * common driver check
12865 */
12866
12867 if (device_type & CL_DEVICE_TYPE_GPU)
12868 {
12869 if (vendor_id == VENDOR_ID_NV)
12870 {
12871 if (device_param->kernel_exec_timeout != 0)
12872 {
12873 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);
12874 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12875 }
12876 }
12877
12878 if (vendor_id == VENDOR_ID_AMD)
12879 {
12880 int catalyst_check = (force == 1) ? 0 : 1;
12881
12882 int catalyst_warn = 0;
12883
12884 int catalyst_broken = 0;
12885
12886 if (catalyst_check == 1)
12887 {
12888 catalyst_warn = 1;
12889
12890 // v14.9 and higher
12891 if ((atoi (device_param->device_version) >= 1573)
12892 && (atoi (device_param->driver_version) >= 1573))
12893 {
12894 catalyst_warn = 0;
12895 }
12896
12897 catalyst_check = 0;
12898 }
12899
12900 if (catalyst_broken == 1)
12901 {
12902 log_error ("");
12903 log_error ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12904 log_error ("It will pass over cracked hashes and does not report them as cracked");
12905 log_error ("You are STRONGLY encouraged not to use it");
12906 log_error ("You can use --force to override this but do not post error reports if you do so");
12907
12908 return (-1);
12909 }
12910
12911 if (catalyst_warn == 1)
12912 {
12913 log_error ("");
12914 log_error ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12915 log_error ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12916 log_error ("See oclHashcat's homepage for official supported catalyst drivers");
12917 #ifdef _WIN
12918 log_error ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12919 #endif
12920 log_error ("You can use --force to override this but do not post error reports if you do so");
12921
12922 return (-1);
12923 }
12924 }
12925 }
12926 }
12927
12928 /*
12929 * Temporary fix:
12930 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
12931 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
12932 * were not working @ full speed (setting hc_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
12933 * Driver / ADL bug?
12934 */
12935
12936 if (vendor_id == VENDOR_ID_AMD)
12937 {
12938 if (powertune_enable == 1)
12939 {
12940 hc_thread_mutex_lock (mux_adl);
12941
12942 for (uint i = 0; i < devices_cnt; i++)
12943 {
12944 if (data.hm_device[i].od_version == 6)
12945 {
12946 // set powertune value only
12947
12948 int powertune_supported = 0;
12949
12950 int ADL_rc = 0;
12951
12952 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll, data.hm_device[i].adapter_index.amd, &powertune_supported)) != ADL_OK)
12953 {
12954 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
12955
12956 return (-1);
12957 }
12958
12959 if (powertune_supported != 0)
12960 {
12961 // powertune set
12962 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
12963
12964 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll, data.hm_device[i].adapter_index.amd, &powertune)) != ADL_OK)
12965 {
12966 log_error ("ERROR: Failed to get current ADL PowerControl settings");
12967
12968 return (-1);
12969 }
12970
12971 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll, data.hm_device[i].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
12972 {
12973 log_error ("ERROR: Failed to set new ADL PowerControl values");
12974
12975 return (-1);
12976 }
12977 }
12978 }
12979 }
12980
12981 hc_thread_mutex_unlock (mux_adl);
12982 }
12983 }
12984
12985 uint kernel_blocks_all = 0;
12986
12987 for (uint device_id = 0; device_id < devices_cnt; device_id++)
12988 {
12989 /**
12990 * host buffer
12991 */
12992
12993 hc_device_param_t *device_param = &data.devices_param[device_id];
12994
12995 /**
12996 * device properties
12997 */
12998
12999 char *device_name_chksum = device_param->device_name_chksum;
13000
13001 uint device_processors = device_param->device_processors;
13002
13003 uint device_processor_cores = device_param->device_processor_cores;
13004
13005 cl_device_type device_type = device_param->device_type;
13006
13007 /**
13008 * create context for each device
13009 */
13010
13011 device_param->context = hc_clCreateContext (NULL, 1, &device_param->device, NULL, NULL);
13012
13013 /**
13014 * create command-queue
13015 */
13016
13017 // not support with NV
13018 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13019
13020 device_param->command_queue = hc_clCreateCommandQueue (device_param->context, device_param->device, 0);
13021
13022 /**
13023 * create input buffers on device
13024 */
13025
13026 uint kernel_threads = KERNEL_THREADS;
13027
13028 // bcrypt
13029 if (hash_mode == 3200) kernel_threads = 8;
13030 if (hash_mode == 9000) kernel_threads = 8;
13031
13032 if (device_type & CL_DEVICE_TYPE_CPU)
13033 {
13034 // CPU still need lots of workitems, don't know why...
13035 // for testing phase, lets start with this
13036
13037 kernel_accel = 1;
13038 }
13039
13040 uint kernel_power = device_processors * kernel_threads * kernel_accel;
13041 uint kernel_blocks = kernel_power;
13042
13043 device_param->kernel_threads = kernel_threads;
13044 device_param->kernel_power_user = kernel_power;
13045 device_param->kernel_blocks_user = kernel_blocks;
13046
13047 kernel_blocks_all += kernel_blocks;
13048
13049 uint size_pws = kernel_power * sizeof (pw_t);
13050
13051 uint size_tmps = 4;
13052
13053 switch (hash_mode)
13054 {
13055 case 400: size_tmps = kernel_blocks * sizeof (phpass_tmp_t); break;
13056 case 500: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13057 case 501: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13058 case 1600: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13059 case 1800: size_tmps = kernel_blocks * sizeof (sha512crypt_tmp_t); break;
13060 case 2100: size_tmps = kernel_blocks * sizeof (dcc2_tmp_t); break;
13061 case 2500: size_tmps = kernel_blocks * sizeof (wpa_tmp_t); break;
13062 case 3200: size_tmps = kernel_blocks * sizeof (bcrypt_tmp_t); break;
13063 case 5200: size_tmps = kernel_blocks * sizeof (pwsafe3_tmp_t); break;
13064 case 5800: size_tmps = kernel_blocks * sizeof (androidpin_tmp_t); break;
13065 case 6211:
13066 case 6212:
13067 case 6213: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13068 case 6221:
13069 case 6222:
13070 case 6223: size_tmps = kernel_blocks * sizeof (tc64_tmp_t); break;
13071 case 6231:
13072 case 6232:
13073 case 6233: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13074 case 6241:
13075 case 6242:
13076 case 6243: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13077 case 6300: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13078 case 6400: size_tmps = kernel_blocks * sizeof (sha256aix_tmp_t); break;
13079 case 6500: size_tmps = kernel_blocks * sizeof (sha512aix_tmp_t); break;
13080 case 6600: size_tmps = kernel_blocks * sizeof (agilekey_tmp_t); break;
13081 case 6700: size_tmps = kernel_blocks * sizeof (sha1aix_tmp_t); break;
13082 case 6800: size_tmps = kernel_blocks * sizeof (lastpass_tmp_t); break;
13083 case 7100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13084 case 7200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13085 case 7400: size_tmps = kernel_blocks * sizeof (sha256crypt_tmp_t); break;
13086 case 7900: size_tmps = kernel_blocks * sizeof (drupal7_tmp_t); break;
13087 case 8200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13088 case 8800: size_tmps = kernel_blocks * sizeof (androidfde_tmp_t); break;
13089 case 8900: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13090 case 9000: size_tmps = kernel_blocks * sizeof (pwsafe2_tmp_t); break;
13091 case 9100: size_tmps = kernel_blocks * sizeof (lotus8_tmp_t); break;
13092 case 9200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13093 case 9300: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13094 case 9400: size_tmps = kernel_blocks * sizeof (office2007_tmp_t); break;
13095 case 9500: size_tmps = kernel_blocks * sizeof (office2010_tmp_t); break;
13096 case 9600: size_tmps = kernel_blocks * sizeof (office2013_tmp_t); break;
13097 case 10000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13098 case 10200: size_tmps = kernel_blocks * sizeof (cram_md5_t); break;
13099 case 10300: size_tmps = kernel_blocks * sizeof (saph_sha1_tmp_t); break;
13100 case 10500: size_tmps = kernel_blocks * sizeof (pdf14_tmp_t); break;
13101 case 10700: size_tmps = kernel_blocks * sizeof (pdf17l8_tmp_t); break;
13102 case 10900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13103 case 11300: size_tmps = kernel_blocks * sizeof (bitcoin_wallet_tmp_t); break;
13104 case 11600: size_tmps = kernel_blocks * sizeof (seven_zip_tmp_t); break;
13105 case 11900: size_tmps = kernel_blocks * sizeof (pbkdf2_md5_tmp_t); break;
13106 case 12000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha1_tmp_t); break;
13107 case 12100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13108 case 12200: size_tmps = kernel_blocks * sizeof (ecryptfs_tmp_t); break;
13109 case 12300: size_tmps = kernel_blocks * sizeof (oraclet_tmp_t); break;
13110 case 12400: size_tmps = kernel_blocks * sizeof (bsdicrypt_tmp_t); break;
13111 case 12500: size_tmps = kernel_blocks * sizeof (rar3_tmp_t); break;
13112 case 12700: size_tmps = kernel_blocks * sizeof (mywallet_tmp_t); break;
13113 case 12800: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13114 case 12900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13115 };
13116
13117 uint size_hooks = 4;
13118
13119 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13120 {
13121 // insert correct hook size
13122 }
13123
13124 // we can optimize some stuff here...
13125
13126 device_param->size_pws = size_pws;
13127 device_param->size_tmps = size_tmps;
13128 device_param->size_hooks = size_hooks;
13129
13130 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13131 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13132
13133 device_param->size_root_css = size_root_css;
13134 device_param->size_markov_css = size_markov_css;
13135
13136 uint size_results = KERNEL_THREADS * sizeof (uint);
13137
13138 device_param->size_results = size_results;
13139
13140 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13141 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13142
13143 uint size_plains = digests_cnt * sizeof (plain_t);
13144 uint size_salts = salts_cnt * sizeof (salt_t);
13145 uint size_esalts = salts_cnt * esalt_size;
13146
13147 device_param->size_plains = size_plains;
13148 device_param->size_digests = size_digests;
13149 device_param->size_shown = size_shown;
13150 device_param->size_salts = size_salts;
13151
13152 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13153 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13154 uint size_tm = 32 * sizeof (bs_word_t);
13155
13156 uint64_t size_scryptV = 1;
13157
13158 if ((hash_mode == 8900) || (hash_mode == 9300))
13159 {
13160 uint tmto_start = 0;
13161 uint tmto_stop = 10;
13162
13163 if (scrypt_tmto)
13164 {
13165 tmto_start = scrypt_tmto;
13166 }
13167 else
13168 {
13169 // in case the user did not specify the tmto manually
13170 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13171 // but set the lower end only in case the user has a device with too less memory
13172
13173 if (hash_mode == 8900)
13174 {
13175 if (vendor_id == VENDOR_ID_AMD)
13176 {
13177 tmto_start = 1;
13178 }
13179 else if (vendor_id == VENDOR_ID_NV)
13180 {
13181 tmto_start = 3;
13182 }
13183 }
13184 else if (hash_mode == 9300)
13185 {
13186 if (vendor_id == VENDOR_ID_AMD)
13187 {
13188 tmto_start = 3;
13189 }
13190 else if (vendor_id == VENDOR_ID_NV)
13191 {
13192 tmto_start = 5;
13193 }
13194 }
13195 }
13196
13197 if (quiet == 0) log_info ("");
13198
13199 uint shader_per_mp = 1;
13200
13201 if (vendor_id == VENDOR_ID_AMD)
13202 {
13203 shader_per_mp = 8;
13204 }
13205
13206 if (vendor_id == VENDOR_ID_NV)
13207 {
13208 shader_per_mp = 32;
13209 }
13210
13211 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13212 {
13213 // TODO: in theory the following calculation needs to be done per salt, not global
13214 // we assume all hashes have the same scrypt settings
13215
13216 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13217
13218 size_scryptV /= 1 << tmto;
13219
13220 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13221
13222 if (size_scryptV > device_param->device_maxmem_alloc)
13223 {
13224 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13225
13226 continue;
13227 }
13228
13229 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13230 {
13231 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13232 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13233 }
13234
13235 break;
13236 }
13237
13238 if (data.salts_buf[0].scrypt_phy == 0)
13239 {
13240 log_error ("ERROR: can't allocate enough device memory");
13241
13242 return -1;
13243 }
13244
13245 if (quiet == 0) log_info ("");
13246 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13247 }
13248
13249 /**
13250 * default building options
13251 */
13252
13253 char build_opts[1024];
13254
13255 // we don't have sm_* on AMD but it doesn't matter
13256
13257 sprintf (build_opts, "-I%s/ -DVENDOR_ID=%d -DCUDA_ARCH=%d", shared_dir, vendor_id, (device_param->sm_major * 100) + device_param->sm_minor);
13258
13259 /**
13260 * main kernel
13261 */
13262
13263 {
13264 /**
13265 * kernel source filename
13266 */
13267
13268 char source_file[256];
13269
13270 memset (source_file, 0, sizeof (source_file));
13271
13272 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13273
13274 struct stat sst;
13275
13276 if (stat (source_file, &sst) == -1)
13277 {
13278 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13279
13280 return -1;
13281 }
13282
13283 /**
13284 * kernel cached filename
13285 */
13286
13287 char cached_file[256];
13288
13289 memset (cached_file, 0, sizeof (cached_file));
13290
13291 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, vendor_id, cached_file);
13292
13293 int cached = 1;
13294
13295 struct stat cst;
13296
13297 if (stat (cached_file, &cst) == -1)
13298 {
13299 cached = 0;
13300 }
13301
13302 /**
13303 * kernel compile or load
13304 */
13305
13306 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13307
13308 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13309
13310 if (force_jit_compilation == 0)
13311 {
13312 if (cached == 0)
13313 {
13314 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13315
13316 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13317
13318 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13319
13320 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13321
13322 size_t binary_size;
13323
13324 clGetProgramInfo (device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13325
13326 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13327
13328 clGetProgramInfo (device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13329
13330 writeProgramBin (cached_file, binary, binary_size);
13331
13332 local_free (binary);
13333 }
13334 else
13335 {
13336 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13337
13338 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13339
13340 device_param->program = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13341
13342 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13343 }
13344 }
13345 else
13346 {
13347 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13348
13349 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13350
13351 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13352
13353 if (force_jit_compilation == 1500)
13354 {
13355 sprintf (build_opts, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13356 }
13357 else if (force_jit_compilation == 8900)
13358 {
13359 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);
13360 }
13361
13362 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13363 }
13364
13365 local_free (kernel_lengths);
13366 local_free (kernel_sources[0]);
13367 local_free (kernel_sources);
13368
13369 // this is mostly for debug
13370
13371 size_t ret_val_size = 0;
13372
13373 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13374
13375 if (ret_val_size > 2)
13376 {
13377 char *build_log = (char *) mymalloc (ret_val_size + 1);
13378
13379 memset (build_log, 0, ret_val_size + 1);
13380
13381 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13382
13383 puts (build_log);
13384
13385 myfree (build_log);
13386 }
13387 }
13388
13389 /**
13390 * word generator kernel
13391 */
13392
13393 if (attack_mode != ATTACK_MODE_STRAIGHT)
13394 {
13395 /**
13396 * kernel mp source filename
13397 */
13398
13399 char source_file[256];
13400
13401 memset (source_file, 0, sizeof (source_file));
13402
13403 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
13404
13405 struct stat sst;
13406
13407 if (stat (source_file, &sst) == -1)
13408 {
13409 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13410
13411 return -1;
13412 }
13413
13414 /**
13415 * kernel mp cached filename
13416 */
13417
13418 char cached_file[256];
13419
13420 memset (cached_file, 0, sizeof (cached_file));
13421
13422 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, vendor_id, cached_file);
13423
13424 int cached = 1;
13425
13426 struct stat cst;
13427
13428 if (stat (cached_file, &cst) == -1)
13429 {
13430 cached = 0;
13431 }
13432
13433 /**
13434 * kernel compile or load
13435 */
13436
13437 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13438
13439 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13440
13441 if (cached == 0)
13442 {
13443 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13444
13445 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13446
13447 device_param->program_mp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13448
13449 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13450
13451 size_t binary_size;
13452
13453 clGetProgramInfo (device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13454
13455 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13456
13457 clGetProgramInfo (device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13458
13459 writeProgramBin (cached_file, binary, binary_size);
13460
13461 local_free (binary);
13462 }
13463 else
13464 {
13465 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13466
13467 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13468
13469 device_param->program_mp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13470
13471 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13472 }
13473
13474 local_free (kernel_lengths);
13475 local_free (kernel_sources[0]);
13476 local_free (kernel_sources);
13477
13478 // this is mostly for debug
13479
13480 size_t ret_val_size = 0;
13481
13482 clGetProgramBuildInfo (device_param->program_mp, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13483
13484 if (ret_val_size > 2)
13485 {
13486 char *build_log = (char *) mymalloc (ret_val_size + 1);
13487
13488 memset (build_log, 0, ret_val_size + 1);
13489
13490 clGetProgramBuildInfo (device_param->program_mp, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13491
13492 puts (build_log);
13493
13494 myfree (build_log);
13495 }
13496 }
13497
13498 /**
13499 * amplifier kernel
13500 */
13501
13502 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13503 {
13504
13505 }
13506 else
13507 {
13508 /**
13509 * kernel amp source filename
13510 */
13511
13512 char source_file[256];
13513
13514 memset (source_file, 0, sizeof (source_file));
13515
13516 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
13517
13518 struct stat sst;
13519
13520 if (stat (source_file, &sst) == -1)
13521 {
13522 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13523
13524 return -1;
13525 }
13526
13527 /**
13528 * kernel amp cached filename
13529 */
13530
13531 char cached_file[256];
13532
13533 memset (cached_file, 0, sizeof (cached_file));
13534
13535 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, vendor_id, cached_file);
13536
13537 int cached = 1;
13538
13539 struct stat cst;
13540
13541 if (stat (cached_file, &cst) == -1)
13542 {
13543 cached = 0;
13544 }
13545
13546 /**
13547 * kernel compile or load
13548 */
13549
13550 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13551
13552 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13553
13554 if (cached == 0)
13555 {
13556 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13557
13558 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13559
13560 device_param->program_amp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13561
13562 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13563
13564 size_t binary_size;
13565
13566 clGetProgramInfo (device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13567
13568 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13569
13570 clGetProgramInfo (device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13571
13572 writeProgramBin (cached_file, binary, binary_size);
13573
13574 local_free (binary);
13575 }
13576 else
13577 {
13578 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13579
13580 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13581
13582 device_param->program_amp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13583
13584 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13585 }
13586
13587 local_free (kernel_lengths);
13588 local_free (kernel_sources[0]);
13589 local_free (kernel_sources);
13590
13591 // this is mostly for debug
13592
13593 size_t ret_val_size = 0;
13594
13595 clGetProgramBuildInfo (device_param->program_amp, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13596
13597 if (ret_val_size > 2)
13598 {
13599 char *build_log = (char *) mymalloc (ret_val_size + 1);
13600
13601 memset (build_log, 0, ret_val_size + 1);
13602
13603 clGetProgramBuildInfo (device_param->program_amp, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13604
13605 puts (build_log);
13606
13607 myfree (build_log);
13608 }
13609 }
13610
13611 /**
13612 * global buffers
13613 */
13614
13615 device_param->d_pws_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13616 device_param->d_pws_amp_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13617 device_param->d_tmps = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
13618 device_param->d_hooks = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
13619 device_param->d_bitmap_s1_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13620 device_param->d_bitmap_s1_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13621 device_param->d_bitmap_s1_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13622 device_param->d_bitmap_s1_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13623 device_param->d_bitmap_s2_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13624 device_param->d_bitmap_s2_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13625 device_param->d_bitmap_s2_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13626 device_param->d_bitmap_s2_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13627 device_param->d_plain_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
13628 device_param->d_digests_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
13629 device_param->d_digests_shown = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
13630 device_param->d_salt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
13631 device_param->d_result = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
13632 device_param->d_scryptV_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
13633
13634 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_a, CL_TRUE, 0, bitmap_size, bitmap_s1_a, 0, NULL, NULL);
13635 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_b, CL_TRUE, 0, bitmap_size, bitmap_s1_b, 0, NULL, NULL);
13636 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_c, CL_TRUE, 0, bitmap_size, bitmap_s1_c, 0, NULL, NULL);
13637 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_d, CL_TRUE, 0, bitmap_size, bitmap_s1_d, 0, NULL, NULL);
13638 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_a, CL_TRUE, 0, bitmap_size, bitmap_s2_a, 0, NULL, NULL);
13639 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_b, CL_TRUE, 0, bitmap_size, bitmap_s2_b, 0, NULL, NULL);
13640 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_c, CL_TRUE, 0, bitmap_size, bitmap_s2_c, 0, NULL, NULL);
13641 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_d, CL_TRUE, 0, bitmap_size, bitmap_s2_d, 0, NULL, NULL);
13642 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
13643 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
13644 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
13645
13646 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
13647 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
13648 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
13649 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
13650 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
13651 run_kernel_bzero (device_param, device_param->d_result, size_results);
13652
13653 /**
13654 * special buffers
13655 */
13656
13657 if (attack_kern == ATTACK_KERN_STRAIGHT)
13658 {
13659 device_param->d_rules = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
13660 device_param->d_rules_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
13661
13662 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
13663
13664 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
13665 }
13666 else if (attack_kern == ATTACK_KERN_COMBI)
13667 {
13668 device_param->d_combs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13669 device_param->d_combs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13670 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13671 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13672
13673 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
13674 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
13675 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13676 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13677 }
13678 else if (attack_kern == ATTACK_KERN_BF)
13679 {
13680 device_param->d_bfs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13681 device_param->d_bfs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13682 device_param->d_tm_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
13683 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13684 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13685
13686 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
13687 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
13688 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
13689 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13690 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13691 }
13692
13693 if (size_esalts)
13694 {
13695 device_param->d_esalt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
13696
13697 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
13698 }
13699
13700 /**
13701 * main host data
13702 */
13703
13704 uint *result = (uint *) mymalloc (size_results);
13705
13706 memset (result, 0, size_results);
13707
13708 device_param->result = result;
13709
13710 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
13711
13712 memset (pws_buf, 0, size_pws);
13713
13714 device_param->pws_buf = pws_buf;
13715
13716 pw_cache_t *pw_caches = (pw_cache_t *) mycalloc (64, sizeof (pw_cache_t));
13717
13718 for (int i = 0; i < 64; i++)
13719 {
13720 pw_caches[i].pw_buf.pw_len = i;
13721 pw_caches[i].cnt = 0;
13722 }
13723
13724 device_param->pw_caches = pw_caches;
13725
13726 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
13727
13728 device_param->combs_buf = combs_buf;
13729
13730 void *hooks_buf = mymalloc (size_hooks);
13731
13732 device_param->hooks_buf = hooks_buf;
13733
13734 device_param->pw_transpose = pw_transpose_to_hi1;
13735 device_param->pw_add = pw_add_to_hc1;
13736
13737 /**
13738 * kernel args
13739 */
13740
13741 device_param->kernel_params_buf32[21] = bitmap_mask;
13742 device_param->kernel_params_buf32[22] = bitmap_shift1;
13743 device_param->kernel_params_buf32[23] = bitmap_shift2;
13744 device_param->kernel_params_buf32[24] = 0; // salt_pos
13745 device_param->kernel_params_buf32[25] = 0; // loop_pos
13746 device_param->kernel_params_buf32[26] = 0; // loop_cnt
13747 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
13748 device_param->kernel_params_buf32[28] = 0; // digests_cnt
13749 device_param->kernel_params_buf32[29] = 0; // digests_offset
13750 device_param->kernel_params_buf32[30] = 0; // combs_mode
13751 device_param->kernel_params_buf32[31] = 0; // gid_max
13752
13753 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13754 ? &device_param->d_pws_buf
13755 : &device_param->d_pws_amp_buf;
13756 device_param->kernel_params[ 1] = &device_param->d_rules_c;
13757 device_param->kernel_params[ 2] = &device_param->d_combs_c;
13758 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
13759 device_param->kernel_params[ 4] = &device_param->d_tmps;
13760 device_param->kernel_params[ 5] = &device_param->d_hooks;
13761 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
13762 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
13763 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
13764 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
13765 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
13766 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
13767 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
13768 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
13769 device_param->kernel_params[14] = &device_param->d_plain_bufs;
13770 device_param->kernel_params[15] = &device_param->d_digests_buf;
13771 device_param->kernel_params[16] = &device_param->d_digests_shown;
13772 device_param->kernel_params[17] = &device_param->d_salt_bufs;
13773 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
13774 device_param->kernel_params[19] = &device_param->d_result;
13775 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
13776 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
13777 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
13778 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
13779 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
13780 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
13781 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
13782 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
13783 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
13784 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
13785 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
13786 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
13787
13788 device_param->kernel_params_mp_buf64[3] = 0;
13789 device_param->kernel_params_mp_buf32[4] = 0;
13790 device_param->kernel_params_mp_buf32[5] = 0;
13791 device_param->kernel_params_mp_buf32[6] = 0;
13792 device_param->kernel_params_mp_buf32[7] = 0;
13793 device_param->kernel_params_mp_buf32[8] = 0;
13794
13795 device_param->kernel_params_mp[0] = NULL;
13796 device_param->kernel_params_mp[1] = NULL;
13797 device_param->kernel_params_mp[2] = NULL;
13798 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
13799 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
13800 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
13801 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
13802 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
13803 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
13804
13805 device_param->kernel_params_mp_l_buf64[3] = 0;
13806 device_param->kernel_params_mp_l_buf32[4] = 0;
13807 device_param->kernel_params_mp_l_buf32[5] = 0;
13808 device_param->kernel_params_mp_l_buf32[6] = 0;
13809 device_param->kernel_params_mp_l_buf32[7] = 0;
13810 device_param->kernel_params_mp_l_buf32[8] = 0;
13811 device_param->kernel_params_mp_l_buf32[9] = 0;
13812
13813 device_param->kernel_params_mp_l[0] = NULL;
13814 device_param->kernel_params_mp_l[1] = NULL;
13815 device_param->kernel_params_mp_l[2] = NULL;
13816 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
13817 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
13818 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
13819 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
13820 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
13821 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
13822 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
13823
13824 device_param->kernel_params_mp_r_buf64[3] = 0;
13825 device_param->kernel_params_mp_r_buf32[4] = 0;
13826 device_param->kernel_params_mp_r_buf32[5] = 0;
13827 device_param->kernel_params_mp_r_buf32[6] = 0;
13828 device_param->kernel_params_mp_r_buf32[7] = 0;
13829 device_param->kernel_params_mp_r_buf32[8] = 0;
13830
13831 device_param->kernel_params_mp_r[0] = NULL;
13832 device_param->kernel_params_mp_r[1] = NULL;
13833 device_param->kernel_params_mp_r[2] = NULL;
13834 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
13835 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
13836 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
13837 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
13838 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
13839 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
13840
13841 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
13842 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
13843
13844 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
13845 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
13846 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
13847 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
13848 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
13849 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
13850 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
13851
13852 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
13853
13854 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
13855 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
13856
13857 /**
13858 * kernel name
13859 */
13860
13861 char kernel_name[64];
13862
13863 memset (kernel_name, 0, sizeof (kernel_name));
13864
13865 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13866 {
13867 if (opti_type & OPTI_TYPE_SINGLE_HASH)
13868 {
13869 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
13870
13871 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
13872
13873 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
13874
13875 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
13876
13877 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
13878
13879 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
13880 }
13881 else
13882 {
13883 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
13884
13885 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
13886
13887 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
13888
13889 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
13890
13891 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
13892
13893 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
13894 }
13895
13896 if (data.attack_mode == ATTACK_MODE_BF)
13897 {
13898 if (opts_type & OPTS_TYPE_PT_BITSLICE)
13899 {
13900 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
13901
13902 device_param->kernel_tb = hc_clCreateKernel (device_param->program, kernel_name);
13903
13904 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
13905
13906 device_param->kernel_tm = hc_clCreateKernel (device_param->program, kernel_name);
13907 }
13908 }
13909 }
13910 else
13911 {
13912 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
13913
13914 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
13915
13916 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
13917
13918 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
13919
13920 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
13921
13922 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
13923
13924 if (opts_type & OPTS_TYPE_HOOK12)
13925 {
13926 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
13927
13928 device_param->kernel12 = hc_clCreateKernel (device_param->program, kernel_name);
13929 }
13930
13931 if (opts_type & OPTS_TYPE_HOOK23)
13932 {
13933 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
13934
13935 device_param->kernel23 = hc_clCreateKernel (device_param->program, kernel_name);
13936 }
13937 }
13938
13939 for (uint i = 0; i <= 20; i++)
13940 {
13941 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
13942 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
13943 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
13944
13945 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
13946 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
13947 }
13948
13949 for (uint i = 21; i <= 31; i++)
13950 {
13951 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
13952 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
13953 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
13954
13955 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
13956 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
13957 }
13958
13959 if (attack_mode == ATTACK_MODE_BF)
13960 {
13961 device_param->kernel_mp_l = hc_clCreateKernel (device_param->program_mp, "l_markov");
13962 device_param->kernel_mp_r = hc_clCreateKernel (device_param->program_mp, "r_markov");
13963
13964 if (opts_type & OPTS_TYPE_PT_BITSLICE)
13965 {
13966 hc_clSetKernelArg (device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
13967
13968 hc_clSetKernelArg (device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
13969 hc_clSetKernelArg (device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
13970 }
13971 }
13972 else if (attack_mode == ATTACK_MODE_HYBRID1)
13973 {
13974 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
13975 }
13976 else if (attack_mode == ATTACK_MODE_HYBRID2)
13977 {
13978 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
13979 }
13980
13981 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13982 {
13983 // nothing to do
13984 }
13985 else
13986 {
13987 device_param->kernel_amp = hc_clCreateKernel (device_param->program_amp, "amp");
13988 }
13989
13990 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13991 {
13992 // nothing to do
13993 }
13994 else
13995 {
13996 for (uint i = 0; i < 5; i++)
13997 {
13998 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
13999 }
14000
14001 for (uint i = 5; i < 7; i++)
14002 {
14003 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14004 }
14005 }
14006
14007 /**
14008 * Store initial fanspeed if gpu_temp_retain is enabled
14009 */
14010
14011 int gpu_temp_retain_set = 0;
14012
14013 if (gpu_temp_disable == 0)
14014 {
14015 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14016 {
14017 hc_thread_mutex_lock (mux_adl);
14018
14019 if (data.hm_device[device_id].fan_supported == 1)
14020 {
14021 if (gpu_temp_retain_chgd == 0)
14022 {
14023 uint cur_temp = 0;
14024 uint default_temp = 0;
14025
14026 int ADL_rc = hc_ADL_Overdrive6_TargetTemperatureData_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, (int *) &cur_temp, (int *) &default_temp);
14027
14028 if (ADL_rc == ADL_OK)
14029 {
14030 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14031
14032 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14033
14034 // special case with multi gpu setups: always use minimum retain
14035
14036 if (gpu_temp_retain_set == 0)
14037 {
14038 gpu_temp_retain = gpu_temp_retain_target;
14039 gpu_temp_retain_set = 1;
14040 }
14041 else
14042 {
14043 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14044 }
14045
14046 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14047 }
14048 }
14049
14050 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14051
14052 temp_retain_fanspeed_value[device_id] = fan_speed;
14053
14054 if (fan_speed == -1)
14055 {
14056 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14057
14058 temp_retain_fanspeed_value[device_id] = 0;
14059 }
14060 }
14061
14062 hc_thread_mutex_unlock (mux_adl);
14063 }
14064 }
14065
14066 /**
14067 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14068 */
14069
14070 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14071 {
14072 hc_thread_mutex_lock (mux_adl);
14073
14074 if (data.hm_device[device_id].od_version == 6)
14075 {
14076 int ADL_rc;
14077
14078 // check powertune capabilities first, if not available then skip device
14079
14080 int powertune_supported = 0;
14081
14082 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14083 {
14084 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14085
14086 return (-1);
14087 }
14088
14089 if (powertune_supported != 0)
14090 {
14091 // powercontrol settings
14092
14093 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14094
14095 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14096 {
14097 ADL_rc = hc_ADL_Overdrive_PowerControl_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14098 }
14099
14100 if (ADL_rc != ADL_OK)
14101 {
14102 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14103
14104 return (-1);
14105 }
14106
14107 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14108 {
14109 log_error ("ERROR: Failed to set new ADL PowerControl values");
14110
14111 return (-1);
14112 }
14113
14114 // clocks
14115
14116 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14117
14118 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14119
14120 if ((ADL_rc = hc_ADL_Overdrive_StateInfo_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, ADL_OD6_GETSTATEINFO_CUSTOM_PERFORMANCE, &od_clock_mem_status[device_id])) != ADL_OK)
14121 {
14122 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14123
14124 return (-1);
14125 }
14126
14127 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14128
14129 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14130
14131 if ((ADL_rc = hc_ADL_Overdrive_Capabilities_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14132 {
14133 log_error ("ERROR: Failed to get ADL device capabilities");
14134
14135 return (-1);
14136 }
14137
14138 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14139 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14140
14141 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14142 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14143
14144 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14145 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14146
14147 // warning if profile has to low max values
14148
14149 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14150 {
14151 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14152 }
14153
14154 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14155 {
14156 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14157 }
14158
14159 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14160
14161 performance_state->iNumberOfPerformanceLevels = 2;
14162
14163 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14164 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14165 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14166 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14167
14168 if ((ADL_rc = hc_ADL_Overdrive_State_Set (data.hm_dll, data.hm_device[device_id].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
14169 {
14170 log_info ("ERROR: Failed to set ADL performance state");
14171
14172 return (-1);
14173 }
14174
14175 local_free (performance_state);
14176 }
14177 }
14178
14179 hc_thread_mutex_unlock (mux_adl);
14180 }
14181 }
14182
14183 data.kernel_blocks_all = kernel_blocks_all;
14184
14185 if (data.quiet == 0) log_info ("");
14186
14187 /**
14188 * Inform user which algorithm is checked and at which workload setting
14189 */
14190
14191 if (benchmark == 1)
14192 {
14193 quiet = 0;
14194
14195 data.quiet = quiet;
14196
14197 char *hash_type = strhashtype (data.hash_mode); // not a bug
14198
14199 log_info ("Hashtype: %s", hash_type);
14200 log_info ("Workload: %u loops, %u accel", kernel_loops, kernel_accel);
14201 log_info ("");
14202 }
14203
14204 /**
14205 * keep track of the progress
14206 */
14207
14208 data.words_progress_done = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
14209 data.words_progress_rejected = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
14210 data.words_progress_restored = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
14211
14212 /**
14213 * open filehandles
14214 */
14215
14216 #if _WIN
14217 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14218 {
14219 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14220
14221 return (-1);
14222 }
14223
14224 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14225 {
14226 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14227
14228 return (-1);
14229 }
14230
14231 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14232 {
14233 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14234
14235 return (-1);
14236 }
14237 #endif
14238
14239 /**
14240 * dictionary pad
14241 */
14242
14243 segment_size *= (1024 * 1024);
14244
14245 data.segment_size = segment_size;
14246
14247 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14248
14249 wl_data->buf = (char *) mymalloc (segment_size);
14250 wl_data->avail = segment_size;
14251 wl_data->incr = segment_size;
14252 wl_data->cnt = 0;
14253 wl_data->pos = 0;
14254
14255 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14256
14257 data.wordlist_mode = wordlist_mode;
14258
14259 cs_t *css_buf = NULL;
14260 uint css_cnt = 0;
14261 uint dictcnt = 0;
14262 uint maskcnt = 1;
14263 char **masks = NULL;
14264 char **dictfiles = NULL;
14265
14266 uint mask_from_file = 0;
14267
14268 if (attack_mode == ATTACK_MODE_STRAIGHT)
14269 {
14270 if (wordlist_mode == WL_MODE_FILE)
14271 {
14272 int wls_left = myargc - (optind + 1);
14273
14274 for (int i = 0; i < wls_left; i++)
14275 {
14276 char *l0_filename = myargv[optind + 1 + i];
14277
14278 struct stat l0_stat;
14279
14280 if (stat (l0_filename, &l0_stat) == -1)
14281 {
14282 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14283
14284 return (-1);
14285 }
14286
14287 uint is_dir = S_ISDIR (l0_stat.st_mode);
14288
14289 if (is_dir == 0)
14290 {
14291 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14292
14293 dictcnt++;
14294
14295 dictfiles[dictcnt - 1] = l0_filename;
14296 }
14297 else
14298 {
14299 // do not allow --keyspace w/ a directory
14300
14301 if (keyspace == 1)
14302 {
14303 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14304
14305 return (-1);
14306 }
14307
14308 char **dictionary_files = NULL;
14309
14310 dictionary_files = scan_directory (l0_filename);
14311
14312 if (dictionary_files != NULL)
14313 {
14314 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14315
14316 for (int d = 0; dictionary_files[d] != NULL; d++)
14317 {
14318 char *l1_filename = dictionary_files[d];
14319
14320 struct stat l1_stat;
14321
14322 if (stat (l1_filename, &l1_stat) == -1)
14323 {
14324 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14325
14326 return (-1);
14327 }
14328
14329 if (S_ISREG (l1_stat.st_mode))
14330 {
14331 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14332
14333 dictcnt++;
14334
14335 dictfiles[dictcnt - 1] = strdup (l1_filename);
14336 }
14337 }
14338 }
14339
14340 local_free (dictionary_files);
14341 }
14342 }
14343
14344 if (dictcnt < 1)
14345 {
14346 log_error ("ERROR: No usable dictionary file found.");
14347
14348 return (-1);
14349 }
14350 }
14351 else if (wordlist_mode == WL_MODE_STDIN)
14352 {
14353 dictcnt = 1;
14354 }
14355 }
14356 else if (attack_mode == ATTACK_MODE_COMBI)
14357 {
14358 // display
14359
14360 char *dictfile1 = myargv[optind + 1 + 0];
14361 char *dictfile2 = myargv[optind + 1 + 1];
14362
14363 // find the bigger dictionary and use as base
14364
14365 FILE *fp1;
14366 FILE *fp2;
14367
14368 struct stat tmp_stat;
14369
14370 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14371 {
14372 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14373
14374 return (-1);
14375 }
14376
14377 if (stat (dictfile1, &tmp_stat) == -1)
14378 {
14379 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14380
14381 fclose (fp1);
14382
14383 return (-1);
14384 }
14385
14386 if (S_ISDIR (tmp_stat.st_mode))
14387 {
14388 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14389
14390 fclose (fp1);
14391
14392 return (-1);
14393 }
14394
14395 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14396 {
14397 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14398
14399 fclose (fp1);
14400
14401 return (-1);
14402 }
14403
14404 if (stat (dictfile2, &tmp_stat) == -1)
14405 {
14406 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14407
14408 fclose (fp1);
14409 fclose (fp2);
14410
14411 return (-1);
14412 }
14413
14414 if (S_ISDIR (tmp_stat.st_mode))
14415 {
14416 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14417
14418 fclose (fp1);
14419 fclose (fp2);
14420
14421 return (-1);
14422 }
14423
14424 data.combs_cnt = 1;
14425
14426 data.quiet = 1;
14427
14428 const uint64_t words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14429
14430 data.quiet = quiet;
14431
14432 if (words1_cnt == 0)
14433 {
14434 log_error ("ERROR: %s: empty file", dictfile1);
14435
14436 fclose (fp1);
14437 fclose (fp2);
14438
14439 return (-1);
14440 }
14441
14442 data.combs_cnt = 1;
14443
14444 data.quiet = 1;
14445
14446 const uint64_t words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14447
14448 data.quiet = quiet;
14449
14450 if (words2_cnt == 0)
14451 {
14452 log_error ("ERROR: %s: empty file", dictfile2);
14453
14454 fclose (fp1);
14455 fclose (fp2);
14456
14457 return (-1);
14458 }
14459
14460 fclose (fp1);
14461 fclose (fp2);
14462
14463 data.dictfile = dictfile1;
14464 data.dictfile2 = dictfile2;
14465
14466 if (words1_cnt >= words2_cnt)
14467 {
14468 data.combs_cnt = words2_cnt;
14469 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14470
14471 dictfiles = &data.dictfile;
14472
14473 dictcnt = 1;
14474 }
14475 else
14476 {
14477 data.combs_cnt = words1_cnt;
14478 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14479
14480 dictfiles = &data.dictfile2;
14481
14482 dictcnt = 1;
14483
14484 // we also have to switch wordlist related rules!
14485
14486 char *tmpc = data.rule_buf_l;
14487
14488 data.rule_buf_l = data.rule_buf_r;
14489 data.rule_buf_r = tmpc;
14490
14491 int tmpi = data.rule_len_l;
14492
14493 data.rule_len_l = data.rule_len_r;
14494 data.rule_len_r = tmpi;
14495 }
14496 }
14497 else if (attack_mode == ATTACK_MODE_BF)
14498 {
14499 char *mask = NULL;
14500
14501 maskcnt = 0;
14502
14503 if (benchmark == 0)
14504 {
14505 mask = myargv[optind + 1];
14506
14507 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
14508
14509 if ((optind + 2) <= myargc)
14510 {
14511 struct stat file_stat;
14512
14513 if (stat (mask, &file_stat) == -1)
14514 {
14515 maskcnt = 1;
14516
14517 masks[maskcnt - 1] = mystrdup (mask);
14518 }
14519 else
14520 {
14521 int wls_left = myargc - (optind + 1);
14522
14523 uint masks_avail = INCR_MASKS;
14524
14525 for (int i = 0; i < wls_left; i++)
14526 {
14527 if (i != 0)
14528 {
14529 mask = myargv[optind + 1 + i];
14530
14531 if (stat (mask, &file_stat) == -1)
14532 {
14533 log_error ("ERROR: %s: %s", mask, strerror (errno));
14534
14535 return (-1);
14536 }
14537 }
14538
14539 uint is_file = S_ISREG (file_stat.st_mode);
14540
14541 if (is_file == 1)
14542 {
14543 FILE *mask_fp;
14544
14545 if ((mask_fp = fopen (mask, "r")) == NULL)
14546 {
14547 log_error ("ERROR: %s: %s", mask, strerror (errno));
14548
14549 return (-1);
14550 }
14551
14552 char line_buf[BUFSIZ];
14553
14554 while (!feof (mask_fp))
14555 {
14556 memset (line_buf, 0, BUFSIZ);
14557
14558 int line_len = fgetl (mask_fp, line_buf);
14559
14560 if (line_len == 0) continue;
14561
14562 if (line_buf[0] == '#') continue;
14563
14564 if (masks_avail == maskcnt)
14565 {
14566 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14567
14568 masks_avail += INCR_MASKS;
14569 }
14570
14571 masks[maskcnt] = mystrdup (line_buf);
14572
14573 maskcnt++;
14574 }
14575
14576 fclose (mask_fp);
14577 }
14578 else
14579 {
14580 log_error ("ERROR: %s: unsupported file-type", mask);
14581
14582 return (-1);
14583 }
14584 }
14585
14586 mask_from_file = 1;
14587 }
14588 }
14589 else
14590 {
14591 custom_charset_1 = (char *) "?l?d?u";
14592 custom_charset_2 = (char *) "?l?d";
14593 custom_charset_3 = (char *) "?l?d*!$@_";
14594
14595 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
14596 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
14597 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
14598
14599 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
14600
14601 wordlist_mode = WL_MODE_MASK;
14602
14603 data.wordlist_mode = wordlist_mode;
14604
14605 increment = 1;
14606
14607 maskcnt = 1;
14608 }
14609 }
14610 else
14611 {
14612 /**
14613 * generate full masks and charsets
14614 */
14615
14616 masks = (char **) mymalloc (sizeof (char *));
14617
14618 switch (hash_mode)
14619 {
14620 case 1731: pw_min = 5;
14621 pw_max = 5;
14622 mask = mystrdup ("?b?b?b?b?b");
14623 break;
14624 case 12500: pw_min = 5;
14625 pw_max = 5;
14626 mask = mystrdup ("?b?b?b?b?b");
14627 break;
14628 default: pw_min = 7;
14629 pw_max = 7;
14630 mask = mystrdup ("?b?b?b?b?b?b?b");
14631 break;
14632 }
14633
14634 maskcnt = 1;
14635
14636 masks[maskcnt - 1] = mystrdup (mask);
14637
14638 wordlist_mode = WL_MODE_MASK;
14639
14640 data.wordlist_mode = wordlist_mode;
14641
14642 increment = 1;
14643 }
14644
14645 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
14646
14647 if (increment)
14648 {
14649 if (increment_min > pw_min) pw_min = increment_min;
14650
14651 if (increment_max < pw_max) pw_max = increment_max;
14652 }
14653 }
14654 else if (attack_mode == ATTACK_MODE_HYBRID1)
14655 {
14656 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14657
14658 // display
14659
14660 char *mask = myargv[myargc - 1];
14661
14662 maskcnt = 0;
14663
14664 masks = (char **) mymalloc (1 * sizeof (char *));
14665
14666 // mod
14667
14668 struct stat file_stat;
14669
14670 if (stat (mask, &file_stat) == -1)
14671 {
14672 maskcnt = 1;
14673
14674 masks[maskcnt - 1] = mystrdup (mask);
14675 }
14676 else
14677 {
14678 uint is_file = S_ISREG (file_stat.st_mode);
14679
14680 if (is_file == 1)
14681 {
14682 FILE *mask_fp;
14683
14684 if ((mask_fp = fopen (mask, "r")) == NULL)
14685 {
14686 log_error ("ERROR: %s: %s", mask, strerror (errno));
14687
14688 return (-1);
14689 }
14690
14691 char line_buf[BUFSIZ];
14692
14693 uint masks_avail = 1;
14694
14695 while (!feof (mask_fp))
14696 {
14697 memset (line_buf, 0, BUFSIZ);
14698
14699 int line_len = fgetl (mask_fp, line_buf);
14700
14701 if (line_len == 0) continue;
14702
14703 if (line_buf[0] == '#') continue;
14704
14705 if (masks_avail == maskcnt)
14706 {
14707 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14708
14709 masks_avail += INCR_MASKS;
14710 }
14711
14712 masks[maskcnt] = mystrdup (line_buf);
14713
14714 maskcnt++;
14715 }
14716
14717 fclose (mask_fp);
14718
14719 mask_from_file = 1;
14720 }
14721 else
14722 {
14723 maskcnt = 1;
14724
14725 masks[maskcnt - 1] = mystrdup (mask);
14726 }
14727 }
14728
14729 // base
14730
14731 int wls_left = myargc - (optind + 2);
14732
14733 for (int i = 0; i < wls_left; i++)
14734 {
14735 char *filename = myargv[optind + 1 + i];
14736
14737 struct stat file_stat;
14738
14739 if (stat (filename, &file_stat) == -1)
14740 {
14741 log_error ("ERROR: %s: %s", filename, strerror (errno));
14742
14743 return (-1);
14744 }
14745
14746 uint is_dir = S_ISDIR (file_stat.st_mode);
14747
14748 if (is_dir == 0)
14749 {
14750 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14751
14752 dictcnt++;
14753
14754 dictfiles[dictcnt - 1] = filename;
14755 }
14756 else
14757 {
14758 // do not allow --keyspace w/ a directory
14759
14760 if (keyspace == 1)
14761 {
14762 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14763
14764 return (-1);
14765 }
14766
14767 char **dictionary_files = NULL;
14768
14769 dictionary_files = scan_directory (filename);
14770
14771 if (dictionary_files != NULL)
14772 {
14773 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14774
14775 for (int d = 0; dictionary_files[d] != NULL; d++)
14776 {
14777 char *l1_filename = dictionary_files[d];
14778
14779 struct stat l1_stat;
14780
14781 if (stat (l1_filename, &l1_stat) == -1)
14782 {
14783 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14784
14785 return (-1);
14786 }
14787
14788 if (S_ISREG (l1_stat.st_mode))
14789 {
14790 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14791
14792 dictcnt++;
14793
14794 dictfiles[dictcnt - 1] = strdup (l1_filename);
14795 }
14796 }
14797 }
14798
14799 local_free (dictionary_files);
14800 }
14801 }
14802
14803 if (dictcnt < 1)
14804 {
14805 log_error ("ERROR: No usable dictionary file found.");
14806
14807 return (-1);
14808 }
14809
14810 if (increment)
14811 {
14812 maskcnt = 0;
14813
14814 uint mask_min = increment_min; // we can't reject smaller masks here
14815 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
14816
14817 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
14818 {
14819 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
14820
14821 if (cur_mask == NULL) break;
14822
14823 masks[maskcnt] = cur_mask;
14824
14825 maskcnt++;
14826
14827 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
14828 }
14829 }
14830 }
14831 else if (attack_mode == ATTACK_MODE_HYBRID2)
14832 {
14833 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14834
14835 // display
14836
14837 char *mask = myargv[optind + 1 + 0];
14838
14839 maskcnt = 0;
14840
14841 masks = (char **) mymalloc (1 * sizeof (char *));
14842
14843 // mod
14844
14845 struct stat file_stat;
14846
14847 if (stat (mask, &file_stat) == -1)
14848 {
14849 maskcnt = 1;
14850
14851 masks[maskcnt - 1] = mystrdup (mask);
14852 }
14853 else
14854 {
14855 uint is_file = S_ISREG (file_stat.st_mode);
14856
14857 if (is_file == 1)
14858 {
14859 FILE *mask_fp;
14860
14861 if ((mask_fp = fopen (mask, "r")) == NULL)
14862 {
14863 log_error ("ERROR: %s: %s", mask, strerror (errno));
14864
14865 return (-1);
14866 }
14867
14868 char line_buf[BUFSIZ];
14869
14870 uint masks_avail = 1;
14871
14872 while (!feof (mask_fp))
14873 {
14874 memset (line_buf, 0, BUFSIZ);
14875
14876 int line_len = fgetl (mask_fp, line_buf);
14877
14878 if (line_len == 0) continue;
14879
14880 if (line_buf[0] == '#') continue;
14881
14882 if (masks_avail == maskcnt)
14883 {
14884 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14885
14886 masks_avail += INCR_MASKS;
14887 }
14888
14889 masks[maskcnt] = mystrdup (line_buf);
14890
14891 maskcnt++;
14892 }
14893
14894 fclose (mask_fp);
14895
14896 mask_from_file = 1;
14897 }
14898 else
14899 {
14900 maskcnt = 1;
14901
14902 masks[maskcnt - 1] = mystrdup (mask);
14903 }
14904 }
14905
14906 // base
14907
14908 int wls_left = myargc - (optind + 2);
14909
14910 for (int i = 0; i < wls_left; i++)
14911 {
14912 char *filename = myargv[optind + 2 + i];
14913
14914 struct stat file_stat;
14915
14916 if (stat (filename, &file_stat) == -1)
14917 {
14918 log_error ("ERROR: %s: %s", filename, strerror (errno));
14919
14920 return (-1);
14921 }
14922
14923 uint is_dir = S_ISDIR (file_stat.st_mode);
14924
14925 if (is_dir == 0)
14926 {
14927 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14928
14929 dictcnt++;
14930
14931 dictfiles[dictcnt - 1] = filename;
14932 }
14933 else
14934 {
14935 // do not allow --keyspace w/ a directory
14936
14937 if (keyspace == 1)
14938 {
14939 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14940
14941 return (-1);
14942 }
14943
14944 char **dictionary_files = NULL;
14945
14946 dictionary_files = scan_directory (filename);
14947
14948 if (dictionary_files != NULL)
14949 {
14950 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14951
14952 for (int d = 0; dictionary_files[d] != NULL; d++)
14953 {
14954 char *l1_filename = dictionary_files[d];
14955
14956 struct stat l1_stat;
14957
14958 if (stat (l1_filename, &l1_stat) == -1)
14959 {
14960 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14961
14962 return (-1);
14963 }
14964
14965 if (S_ISREG (l1_stat.st_mode))
14966 {
14967 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14968
14969 dictcnt++;
14970
14971 dictfiles[dictcnt - 1] = strdup (l1_filename);
14972 }
14973 }
14974 }
14975
14976 local_free (dictionary_files);
14977 }
14978 }
14979
14980 if (dictcnt < 1)
14981 {
14982 log_error ("ERROR: No usable dictionary file found.");
14983
14984 return (-1);
14985 }
14986
14987 if (increment)
14988 {
14989 maskcnt = 0;
14990
14991 uint mask_min = increment_min; // we can't reject smaller masks here
14992 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
14993
14994 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
14995 {
14996 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
14997
14998 if (cur_mask == NULL) break;
14999
15000 masks[maskcnt] = cur_mask;
15001
15002 maskcnt++;
15003
15004 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15005 }
15006 }
15007 }
15008
15009 data.pw_min = pw_min;
15010 data.pw_max = pw_max;
15011
15012 /**
15013 * weak hash check
15014 */
15015
15016 if (weak_hash_threshold >= salts_cnt)
15017 {
15018 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15019
15020 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15021 {
15022 weak_hash_check (&data.devices_param[0], salt_pos, kernel_loops);
15023 }
15024 }
15025
15026 // Display hack, guarantee that there is at least one \r before real start
15027
15028 if (data.quiet == 0) log_info_nn ("");
15029
15030 /**
15031 * status and monitor threads
15032 */
15033
15034 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15035
15036 hc_thread_t i_thread = 0;
15037
15038 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15039 {
15040 hc_thread_create (i_thread, thread_keypress, &benchmark);
15041 }
15042
15043 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15044
15045 uint ni_threads_cnt = 0;
15046
15047 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15048
15049 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15050
15051 ni_threads_cnt++;
15052
15053 /**
15054 * Outfile remove
15055 */
15056
15057 if (keyspace == 0)
15058 {
15059 if (outfile_check_timer != 0)
15060 {
15061 if (data.outfile_check_directory != NULL)
15062 {
15063 if ((hash_mode != 5200) &&
15064 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15065 (hash_mode != 9000))
15066 {
15067 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15068
15069 ni_threads_cnt++;
15070 }
15071 else
15072 {
15073 outfile_check_timer = 0;
15074 }
15075 }
15076 else
15077 {
15078 outfile_check_timer = 0;
15079 }
15080 }
15081 }
15082
15083 /**
15084 * Inform the user if we got some hashes remove because of the pot file remove feature
15085 */
15086
15087 if (data.quiet == 0)
15088 {
15089 if (potfile_remove_cracks > 0)
15090 {
15091 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15092 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15093 }
15094 }
15095
15096 data.outfile_check_timer = outfile_check_timer;
15097
15098 /**
15099 * main loop
15100 */
15101
15102 char **induction_dictionaries = NULL;
15103
15104 int induction_dictionaries_cnt = 0;
15105
15106 hcstat_table_t *root_table_buf = NULL;
15107 hcstat_table_t *markov_table_buf = NULL;
15108
15109 uint initial_restore_done = 0;
15110
15111 data.maskcnt = maskcnt;
15112
15113 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15114 {
15115 if (data.devices_status == STATUS_CRACKED) break;
15116
15117 data.devices_status = STATUS_INIT;
15118
15119 if (maskpos > rd->maskpos)
15120 {
15121 rd->dictpos = 0;
15122 }
15123
15124 rd->maskpos = maskpos;
15125 data.maskpos = maskpos;
15126
15127 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15128 {
15129 char *mask = masks[maskpos];
15130
15131 if (mask_from_file == 1)
15132 {
15133 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15134
15135 char *str_ptr;
15136 uint str_pos;
15137
15138 uint mask_offset = 0;
15139
15140 uint separator_cnt;
15141
15142 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15143 {
15144 str_ptr = strstr (mask + mask_offset, ",");
15145
15146 if (str_ptr == NULL) break;
15147
15148 str_pos = str_ptr - mask;
15149
15150 // escaped separator, i.e. "\,"
15151
15152 if (str_pos > 0)
15153 {
15154 if (mask[str_pos - 1] == '\\')
15155 {
15156 separator_cnt --;
15157
15158 mask_offset = str_pos + 1;
15159
15160 continue;
15161 }
15162 }
15163
15164 // reset the offset
15165
15166 mask_offset = 0;
15167
15168 mask[str_pos] = '\0';
15169
15170 switch (separator_cnt)
15171 {
15172 case 0:
15173 mp_reset_usr (mp_usr, 0);
15174
15175 custom_charset_1 = mask;
15176 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15177 break;
15178
15179 case 1:
15180 mp_reset_usr (mp_usr, 1);
15181
15182 custom_charset_2 = mask;
15183 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15184 break;
15185
15186 case 2:
15187 mp_reset_usr (mp_usr, 2);
15188
15189 custom_charset_3 = mask;
15190 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15191 break;
15192
15193 case 3:
15194 mp_reset_usr (mp_usr, 3);
15195
15196 custom_charset_4 = mask;
15197 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15198 break;
15199 }
15200
15201 mask = mask + str_pos + 1;
15202 }
15203 }
15204
15205 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15206 {
15207 if (maskpos > 0)
15208 {
15209 local_free (css_buf);
15210 local_free (data.root_css_buf);
15211 local_free (data.markov_css_buf);
15212
15213 local_free (masks[maskpos - 1]);
15214 }
15215
15216 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15217
15218 data.mask = mask;
15219 data.css_cnt = css_cnt;
15220 data.css_buf = css_buf;
15221
15222 uint uniq_tbls[SP_PW_MAX][CHARSIZ];
15223
15224 memset (uniq_tbls, 0, sizeof (uniq_tbls));
15225
15226 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15227
15228 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15229 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15230
15231 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15232
15233 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15234
15235 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15236 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15237
15238 data.root_css_buf = root_css_buf;
15239 data.markov_css_buf = markov_css_buf;
15240
15241 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15242
15243 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15244
15245 local_free (root_table_buf);
15246 local_free (markov_table_buf);
15247
15248 // args
15249
15250 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15251 {
15252 hc_device_param_t *device_param = &data.devices_param[device_id];
15253
15254 device_param->kernel_params_mp[0] = &device_param->d_combs;
15255 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15256 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15257
15258 device_param->kernel_params_mp_buf64[3] = 0;
15259 device_param->kernel_params_mp_buf32[4] = css_cnt;
15260 device_param->kernel_params_mp_buf32[5] = 0;
15261 device_param->kernel_params_mp_buf32[6] = 0;
15262 device_param->kernel_params_mp_buf32[7] = 0;
15263
15264 if (attack_mode == ATTACK_MODE_HYBRID1)
15265 {
15266 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15267 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15268 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15269 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15270 }
15271 else if (attack_mode == ATTACK_MODE_HYBRID2)
15272 {
15273 device_param->kernel_params_mp_buf32[5] = 0;
15274 device_param->kernel_params_mp_buf32[6] = 0;
15275 device_param->kernel_params_mp_buf32[7] = 0;
15276 }
15277
15278 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp[i]);
15279 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp[i]);
15280 for (uint i = 4; i < 8; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp[i]);
15281
15282 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);
15283 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);
15284 }
15285 }
15286 else if (attack_mode == ATTACK_MODE_BF)
15287 {
15288 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15289
15290 if (increment)
15291 {
15292 for (uint i = 0; i < dictcnt; i++)
15293 {
15294 local_free (dictfiles[i]);
15295 }
15296
15297 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15298 {
15299 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15300
15301 if (l1_filename == NULL) break;
15302
15303 dictcnt++;
15304
15305 dictfiles[dictcnt - 1] = l1_filename;
15306 }
15307 }
15308 else
15309 {
15310 dictcnt++;
15311
15312 dictfiles[dictcnt - 1] = mask;
15313 }
15314
15315 if (dictcnt == 0)
15316 {
15317 log_error ("ERROR: Mask is too small");
15318
15319 return (-1);
15320 }
15321 }
15322 }
15323
15324 free (induction_dictionaries);
15325
15326 // induction_dictionaries_cnt = 0; // implied
15327
15328 if (attack_mode != ATTACK_MODE_BF)
15329 {
15330 if (keyspace == 0)
15331 {
15332 induction_dictionaries = scan_directory (induction_directory);
15333
15334 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15335 }
15336 }
15337
15338 if (induction_dictionaries_cnt)
15339 {
15340 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15341 }
15342
15343 /**
15344 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15345 */
15346 if (keyspace == 1)
15347 {
15348 if ((maskcnt > 1) || (dictcnt > 1))
15349 {
15350 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15351
15352 return (-1);
15353 }
15354 }
15355
15356 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15357 {
15358 char *subid = logfile_generate_subid ();
15359
15360 data.subid = subid;
15361
15362 logfile_sub_msg ("START");
15363
15364 data.devices_status = STATUS_INIT;
15365
15366 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (uint64_t));
15367 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (uint64_t));
15368 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (uint64_t));
15369
15370 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15371
15372 data.cpt_pos = 0;
15373
15374 data.cpt_start = time (NULL);
15375
15376 data.cpt_total = 0;
15377
15378 if (data.restore == 0)
15379 {
15380 rd->words_cur = skip;
15381
15382 skip = 0;
15383
15384 data.skip = 0;
15385 }
15386
15387 data.ms_paused = 0;
15388
15389 data.words_cur = rd->words_cur;
15390
15391 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15392 {
15393 hc_device_param_t *device_param = &data.devices_param[device_id];
15394
15395 device_param->speed_pos = 0;
15396
15397 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (uint64_t));
15398 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15399 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15400
15401 device_param->kernel_power = device_param->kernel_power_user;
15402 device_param->kernel_blocks = device_param->kernel_blocks_user;
15403
15404 device_param->outerloop_pos = 0;
15405 device_param->outerloop_left = 0;
15406 device_param->innerloop_pos = 0;
15407 device_param->innerloop_left = 0;
15408
15409 // some more resets:
15410
15411 memset (device_param->pw_caches, 0, 64 * sizeof (pw_cache_t));
15412
15413 memset (device_param->pws_buf, 0, device_param->size_pws);
15414
15415 device_param->pw_cnt = 0;
15416 device_param->pws_cnt = 0;
15417
15418 device_param->words_off = 0;
15419 device_param->words_done = 0;
15420 }
15421
15422 data.kernel_blocks_div = 0;
15423
15424 // figure out some workload
15425
15426 if (attack_mode == ATTACK_MODE_STRAIGHT)
15427 {
15428 if (data.wordlist_mode == WL_MODE_FILE)
15429 {
15430 char *dictfile = NULL;
15431
15432 if (induction_dictionaries_cnt)
15433 {
15434 dictfile = induction_dictionaries[0];
15435 }
15436 else
15437 {
15438 dictfile = dictfiles[dictpos];
15439 }
15440
15441 data.dictfile = dictfile;
15442
15443 logfile_sub_string (dictfile);
15444
15445 for (uint i = 0; i < rp_files_cnt; i++)
15446 {
15447 logfile_sub_var_string ("rulefile", rp_files[i]);
15448 }
15449
15450 FILE *fd2 = fopen (dictfile, "rb");
15451
15452 if (fd2 == NULL)
15453 {
15454 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15455
15456 return (-1);
15457 }
15458
15459 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15460
15461 fclose (fd2);
15462
15463 if (data.words_cnt == 0)
15464 {
15465 if (data.devices_status == STATUS_CRACKED) break;
15466 if (data.devices_status == STATUS_ABORTED) break;
15467
15468 dictpos++;
15469
15470 continue;
15471 }
15472 }
15473 }
15474 else if (attack_mode == ATTACK_MODE_COMBI)
15475 {
15476 char *dictfile = data.dictfile;
15477 char *dictfile2 = data.dictfile2;
15478
15479 logfile_sub_string (dictfile);
15480 logfile_sub_string (dictfile2);
15481
15482 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
15483 {
15484 FILE *fd2 = fopen (dictfile, "rb");
15485
15486 if (fd2 == NULL)
15487 {
15488 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15489
15490 return (-1);
15491 }
15492
15493 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15494
15495 fclose (fd2);
15496 }
15497 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
15498 {
15499 FILE *fd2 = fopen (dictfile2, "rb");
15500
15501 if (fd2 == NULL)
15502 {
15503 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15504
15505 return (-1);
15506 }
15507
15508 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
15509
15510 fclose (fd2);
15511 }
15512
15513 if (data.words_cnt == 0)
15514 {
15515 if (data.devices_status == STATUS_CRACKED) break;
15516 if (data.devices_status == STATUS_ABORTED) break;
15517
15518 dictpos++;
15519
15520 continue;
15521 }
15522 }
15523 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15524 {
15525 char *dictfile = NULL;
15526
15527 if (induction_dictionaries_cnt)
15528 {
15529 dictfile = induction_dictionaries[0];
15530 }
15531 else
15532 {
15533 dictfile = dictfiles[dictpos];
15534 }
15535
15536 data.dictfile = dictfile;
15537
15538 char *mask = data.mask;
15539
15540 logfile_sub_string (dictfile);
15541 logfile_sub_string (mask);
15542
15543 FILE *fd2 = fopen (dictfile, "rb");
15544
15545 if (fd2 == NULL)
15546 {
15547 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15548
15549 return (-1);
15550 }
15551
15552 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15553
15554 fclose (fd2);
15555
15556 if (data.words_cnt == 0)
15557 {
15558 if (data.devices_status == STATUS_CRACKED) break;
15559 if (data.devices_status == STATUS_ABORTED) break;
15560
15561 dictpos++;
15562
15563 continue;
15564 }
15565 }
15566 else if (attack_mode == ATTACK_MODE_BF)
15567 {
15568 local_free (css_buf);
15569 local_free (data.root_css_buf);
15570 local_free (data.markov_css_buf);
15571
15572 char *mask = dictfiles[dictpos];
15573
15574 logfile_sub_string (mask);
15575
15576 // base
15577
15578 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15579
15580 if (opts_type & OPTS_TYPE_PT_UNICODE)
15581 {
15582 uint css_cnt_unicode = css_cnt * 2;
15583
15584 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
15585
15586 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
15587 {
15588 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
15589
15590 css_buf_unicode[j + 1].cs_buf[0] = 0;
15591 css_buf_unicode[j + 1].cs_len = 1;
15592 }
15593
15594 free (css_buf);
15595
15596 css_buf = css_buf_unicode;
15597 css_cnt = css_cnt_unicode;
15598 }
15599
15600 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
15601
15602 uint mask_min = pw_min;
15603 uint mask_max = pw_max;
15604
15605 if (opts_type & OPTS_TYPE_PT_UNICODE)
15606 {
15607 mask_min *= 2;
15608 mask_max *= 2;
15609 }
15610
15611 if ((css_cnt < mask_min) || (css_cnt > mask_max))
15612 {
15613 if (css_cnt < mask_min)
15614 {
15615 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
15616 }
15617
15618 if (css_cnt > mask_max)
15619 {
15620 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
15621 }
15622
15623 // skip to next mask
15624
15625 dictpos++;
15626
15627 rd->dictpos = dictpos;
15628
15629 logfile_sub_msg ("STOP");
15630
15631 continue;
15632 }
15633
15634 uint save_css_cnt = css_cnt;
15635
15636 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15637 {
15638 if (opti_type & OPTI_TYPE_APPENDED_SALT)
15639 {
15640 uint salt_len = (uint) data.salts_buf[0].salt_len;
15641 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
15642
15643 uint css_cnt_salt = css_cnt + salt_len;
15644
15645 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
15646
15647 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
15648
15649 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
15650 {
15651 css_buf_salt[j].cs_buf[0] = salt_buf[i];
15652 css_buf_salt[j].cs_len = 1;
15653 }
15654
15655 free (css_buf);
15656
15657 css_buf = css_buf_salt;
15658 css_cnt = css_cnt_salt;
15659 }
15660 }
15661
15662 data.mask = mask;
15663 data.css_cnt = css_cnt;
15664 data.css_buf = css_buf;
15665
15666 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
15667
15668 uint uniq_tbls[SP_PW_MAX][CHARSIZ];
15669
15670 memset (uniq_tbls, 0, sizeof (uniq_tbls));
15671
15672 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15673
15674 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15675 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15676
15677 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15678
15679 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15680
15681 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15682 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15683
15684 data.root_css_buf = root_css_buf;
15685 data.markov_css_buf = markov_css_buf;
15686
15687 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15688
15689 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15690
15691 local_free (root_table_buf);
15692 local_free (markov_table_buf);
15693
15694 // copy + args
15695
15696 uint css_cnt_l = css_cnt;
15697 uint css_cnt_r;
15698
15699 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15700 {
15701 if (save_css_cnt < 6)
15702 {
15703 css_cnt_r = 1;
15704 }
15705 else if (save_css_cnt == 6)
15706 {
15707 css_cnt_r = 2;
15708 }
15709 else
15710 {
15711 if (opts_type & OPTS_TYPE_PT_UNICODE)
15712 {
15713 if (save_css_cnt == 8 || save_css_cnt == 10)
15714 {
15715 css_cnt_r = 2;
15716 }
15717 else
15718 {
15719 css_cnt_r = 4;
15720 }
15721 }
15722 else
15723 {
15724 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
15725 {
15726 css_cnt_r = 3;
15727 }
15728 else
15729 {
15730 css_cnt_r = 4;
15731 }
15732 }
15733 }
15734 }
15735 else
15736 {
15737 css_cnt_r = 1;
15738
15739 /* unfinished code?
15740 int sum = css_buf[css_cnt_r - 1].cs_len;
15741
15742 for (uint i = 1; i < 4 && i < css_cnt; i++)
15743 {
15744 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
15745
15746 css_cnt_r++;
15747
15748 sum *= css_buf[css_cnt_r - 1].cs_len;
15749 }
15750 */
15751 }
15752
15753 css_cnt_l -= css_cnt_r;
15754
15755 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
15756
15757 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15758 {
15759 hc_device_param_t *device_param = &data.devices_param[device_id];
15760
15761 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
15762 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
15763 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
15764
15765 device_param->kernel_params_mp_l_buf64[3] = 0;
15766 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
15767 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
15768 device_param->kernel_params_mp_l_buf32[6] = 0;
15769 device_param->kernel_params_mp_l_buf32[7] = 0;
15770 device_param->kernel_params_mp_l_buf32[8] = 0;
15771
15772 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
15773 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
15774 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
15775 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
15776
15777 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
15778 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
15779 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
15780
15781 device_param->kernel_params_mp_r_buf64[3] = 0;
15782 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
15783 device_param->kernel_params_mp_r_buf32[5] = 0;
15784 device_param->kernel_params_mp_r_buf32[6] = 0;
15785 device_param->kernel_params_mp_r_buf32[7] = 0;
15786
15787 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]);
15788 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]);
15789 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]);
15790
15791 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]);
15792 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]);
15793 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]);
15794
15795 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);
15796 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);
15797 }
15798 }
15799
15800 uint64_t words_base = data.words_cnt;
15801
15802 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
15803 {
15804 if (data.kernel_rules_cnt)
15805 {
15806 words_base /= data.kernel_rules_cnt;
15807 }
15808 }
15809 else if (data.attack_kern == ATTACK_KERN_COMBI)
15810 {
15811 if (data.combs_cnt)
15812 {
15813 words_base /= data.combs_cnt;
15814 }
15815 }
15816 else if (data.attack_kern == ATTACK_KERN_BF)
15817 {
15818 if (data.bfs_cnt)
15819 {
15820 words_base /= data.bfs_cnt;
15821 }
15822 }
15823
15824 data.words_base = words_base;
15825
15826 if (keyspace == 1)
15827 {
15828 log_info ("%llu", (unsigned long long int) words_base);
15829
15830 return (0);
15831 }
15832
15833 if (data.words_cur > data.words_base)
15834 {
15835 log_error ("ERROR: restore value greater keyspace");
15836
15837 return (-1);
15838 }
15839
15840 if (data.words_cur)
15841 {
15842 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
15843 {
15844 for (uint i = 0; i < data.salts_cnt; i++)
15845 {
15846 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
15847 }
15848 }
15849 else if (data.attack_kern == ATTACK_KERN_COMBI)
15850 {
15851 for (uint i = 0; i < data.salts_cnt; i++)
15852 {
15853 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
15854 }
15855 }
15856 else if (data.attack_kern == ATTACK_KERN_BF)
15857 {
15858 for (uint i = 0; i < data.salts_cnt; i++)
15859 {
15860 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
15861 }
15862 }
15863 }
15864
15865 /*
15866 * Inform user about possible slow speeds
15867 */
15868
15869 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
15870 {
15871 if (data.words_base < kernel_blocks_all)
15872 {
15873 if (quiet == 0)
15874 {
15875 log_info ("");
15876 log_info ("ATTENTION!");
15877 log_info (" The wordlist or mask you are using is too small.");
15878 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
15879 log_info (" The cracking speed will drop.");
15880 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
15881 log_info ("");
15882 }
15883 }
15884 }
15885
15886 /*
15887 * Update loopback file
15888 */
15889
15890 if (loopback == 1)
15891 {
15892 time_t now;
15893
15894 time (&now);
15895
15896 uint random_num = get_random_num (0, 9999);
15897
15898 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
15899
15900 data.loopback_file = loopback_file;
15901 }
15902
15903 /*
15904 * Update dictionary statistic
15905 */
15906
15907 if (keyspace == 0)
15908 {
15909 dictstat_fp = fopen (dictstat, "wb");
15910
15911 if (dictstat_fp)
15912 {
15913 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
15914
15915 fclose (dictstat_fp);
15916 }
15917 }
15918
15919 data.devices_status = STATUS_RUNNING;
15920
15921 if (initial_restore_done == 0)
15922 {
15923 if (data.restore_disable == 0) cycle_restore ();
15924
15925 initial_restore_done = 1;
15926 }
15927
15928 hc_timer_set (&data.timer_running);
15929
15930 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
15931 {
15932 if ((quiet == 0) && (status == 0) && (benchmark == 0))
15933 {
15934 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
15935 if (quiet == 0) fflush (stdout);
15936 }
15937 }
15938 else if (wordlist_mode == WL_MODE_STDIN)
15939 {
15940 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
15941 if (data.quiet == 0) log_info ("");
15942 }
15943
15944 time_t runtime_start;
15945
15946 time (&runtime_start);
15947
15948 data.runtime_start = runtime_start;
15949
15950 /**
15951 * create cracker threads
15952 */
15953
15954 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (devices_cnt, sizeof (hc_thread_t));
15955
15956 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15957 {
15958 hc_device_param_t *device_param = &devices_param[device_id];
15959
15960 device_param->device_id = device_id;
15961
15962 if (wordlist_mode == WL_MODE_STDIN)
15963 {
15964 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
15965 }
15966 else
15967 {
15968 hc_thread_create (c_threads[device_id], thread_calc, device_param);
15969 }
15970 }
15971
15972 // wait for crack threads to exit
15973
15974 hc_thread_wait (devices_cnt, c_threads);
15975
15976 local_free (c_threads);
15977
15978 data.restore = 0;
15979
15980 // finalize task
15981
15982 logfile_sub_var_uint ("status-after-work", data.devices_status);
15983
15984 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
15985
15986 if (data.devices_status == STATUS_CRACKED) break;
15987 if (data.devices_status == STATUS_ABORTED) break;
15988
15989 if (data.devices_status == STATUS_BYPASS)
15990 {
15991 data.devices_status = STATUS_RUNNING;
15992 }
15993
15994 if (induction_dictionaries_cnt)
15995 {
15996 unlink (induction_dictionaries[0]);
15997 }
15998
15999 free (induction_dictionaries);
16000
16001 if (attack_mode != ATTACK_MODE_BF)
16002 {
16003 induction_dictionaries = scan_directory (induction_directory);
16004
16005 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16006 }
16007
16008 if (benchmark == 0)
16009 {
16010 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16011 {
16012 if (quiet == 0) clear_prompt ();
16013
16014 if (quiet == 0) log_info ("");
16015
16016 if (status == 1)
16017 {
16018 status_display ();
16019 }
16020 else
16021 {
16022 if (quiet == 0) status_display ();
16023 }
16024
16025 if (quiet == 0) log_info ("");
16026 }
16027 }
16028
16029 if (attack_mode == ATTACK_MODE_BF)
16030 {
16031 dictpos++;
16032
16033 rd->dictpos = dictpos;
16034 }
16035 else
16036 {
16037 if (induction_dictionaries_cnt)
16038 {
16039 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16040 }
16041 else
16042 {
16043 dictpos++;
16044
16045 rd->dictpos = dictpos;
16046 }
16047 }
16048
16049 time_t runtime_stop;
16050
16051 time (&runtime_stop);
16052
16053 data.runtime_stop = runtime_stop;
16054
16055 logfile_sub_uint (runtime_start);
16056 logfile_sub_uint (runtime_stop);
16057
16058 logfile_sub_msg ("STOP");
16059
16060 global_free (subid);
16061 }
16062
16063 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16064
16065 if (data.devices_status == STATUS_CRACKED) break;
16066 if (data.devices_status == STATUS_ABORTED) break;
16067 if (data.devices_status == STATUS_QUIT) break;
16068
16069 if (data.devices_status == STATUS_BYPASS)
16070 {
16071 data.devices_status = STATUS_RUNNING;
16072 }
16073 }
16074
16075 // 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
16076
16077 if (attack_mode == ATTACK_MODE_STRAIGHT)
16078 {
16079 if (data.wordlist_mode == WL_MODE_FILE)
16080 {
16081 if (data.dictfile == NULL)
16082 {
16083 if (dictfiles != NULL)
16084 {
16085 data.dictfile = dictfiles[0];
16086
16087 hc_timer_set (&data.timer_running);
16088 }
16089 }
16090 }
16091 }
16092 // NOTE: combi is okay because it is already set beforehand
16093 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16094 {
16095 if (data.dictfile == NULL)
16096 {
16097 if (dictfiles != NULL)
16098 {
16099 hc_timer_set (&data.timer_running);
16100
16101 data.dictfile = dictfiles[0];
16102 }
16103 }
16104 }
16105 else if (attack_mode == ATTACK_MODE_BF)
16106 {
16107 if (data.mask == NULL)
16108 {
16109 hc_timer_set (&data.timer_running);
16110
16111 data.mask = masks[0];
16112 }
16113 }
16114
16115 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16116 {
16117 data.devices_status = STATUS_EXHAUSTED;
16118 }
16119
16120 // if cracked / aborted remove last induction dictionary
16121
16122 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16123 {
16124 struct stat induct_stat;
16125
16126 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16127 {
16128 unlink (induction_dictionaries[file_pos]);
16129 }
16130 }
16131
16132 // wait for non-interactive threads
16133
16134 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16135 {
16136 hc_thread_wait (1, &ni_threads[thread_idx]);
16137 }
16138
16139 local_free (ni_threads);
16140
16141 // wait for interactive threads
16142
16143 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16144 {
16145 hc_thread_wait (1, &i_thread);
16146 }
16147
16148 // we dont need restore file anymore
16149 if (data.restore_disable == 0)
16150 {
16151 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16152 {
16153 unlink (eff_restore_file);
16154 unlink (new_restore_file);
16155 }
16156 else
16157 {
16158 cycle_restore ();
16159 }
16160 }
16161
16162 // finally save left hashes
16163
16164 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16165 {
16166 save_hash ();
16167 }
16168
16169 /**
16170 * Clean up
16171 */
16172
16173 if (benchmark == 1)
16174 {
16175 status_benchmark ();
16176
16177 log_info ("");
16178 }
16179 else
16180 {
16181 if (quiet == 0) clear_prompt ();
16182
16183 if (quiet == 0) log_info ("");
16184
16185 if (status == 1)
16186 {
16187 status_display ();
16188 }
16189 else
16190 {
16191 if (quiet == 0) status_display ();
16192 }
16193
16194 if (quiet == 0) log_info ("");
16195 }
16196
16197 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16198 {
16199 hc_device_param_t *device_param = &data.devices_param[device_id];
16200
16201 local_free (device_param->result);
16202
16203 local_free (device_param->pw_caches);
16204
16205 local_free (device_param->combs_buf);
16206
16207 local_free (device_param->hooks_buf);
16208
16209 local_free (device_param->device_name);
16210
16211 local_free (device_param->device_name_chksum);
16212
16213 local_free (device_param->device_version);
16214
16215 local_free (device_param->driver_version);
16216
16217 if (device_param->pws_buf) myfree (device_param->pws_buf);
16218 if (device_param->d_pws_buf) hc_clReleaseMemObject (device_param->d_pws_buf);
16219 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (device_param->d_pws_amp_buf);
16220 if (device_param->d_rules) hc_clReleaseMemObject (device_param->d_rules);
16221 if (device_param->d_rules_c) hc_clReleaseMemObject (device_param->d_rules_c);
16222 if (device_param->d_combs) hc_clReleaseMemObject (device_param->d_combs);
16223 if (device_param->d_combs_c) hc_clReleaseMemObject (device_param->d_combs_c);
16224 if (device_param->d_bfs) hc_clReleaseMemObject (device_param->d_bfs);
16225 if (device_param->d_bfs_c) hc_clReleaseMemObject (device_param->d_bfs_c);
16226 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (device_param->d_bitmap_s1_a);
16227 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (device_param->d_bitmap_s1_b);
16228 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (device_param->d_bitmap_s1_c);
16229 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (device_param->d_bitmap_s1_d);
16230 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (device_param->d_bitmap_s2_a);
16231 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (device_param->d_bitmap_s2_b);
16232 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (device_param->d_bitmap_s2_c);
16233 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (device_param->d_bitmap_s2_d);
16234 if (device_param->d_plain_bufs) hc_clReleaseMemObject (device_param->d_plain_bufs);
16235 if (device_param->d_digests_buf) hc_clReleaseMemObject (device_param->d_digests_buf);
16236 if (device_param->d_digests_shown) hc_clReleaseMemObject (device_param->d_digests_shown);
16237 if (device_param->d_salt_bufs) hc_clReleaseMemObject (device_param->d_salt_bufs);
16238 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (device_param->d_esalt_bufs);
16239 if (device_param->d_tmps) hc_clReleaseMemObject (device_param->d_tmps);
16240 if (device_param->d_hooks) hc_clReleaseMemObject (device_param->d_hooks);
16241 if (device_param->d_result) hc_clReleaseMemObject (device_param->d_result);
16242 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (device_param->d_scryptV_buf);
16243 if (device_param->d_root_css_buf) hc_clReleaseMemObject (device_param->d_root_css_buf);
16244 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (device_param->d_markov_css_buf);
16245 if (device_param->d_tm_c) hc_clReleaseMemObject (device_param->d_tm_c);
16246
16247 if (device_param->kernel1) hc_clReleaseKernel (device_param->kernel1);
16248 if (device_param->kernel12) hc_clReleaseKernel (device_param->kernel12);
16249 if (device_param->kernel2) hc_clReleaseKernel (device_param->kernel2);
16250 if (device_param->kernel23) hc_clReleaseKernel (device_param->kernel23);
16251 if (device_param->kernel3) hc_clReleaseKernel (device_param->kernel3);
16252 if (device_param->kernel_mp) hc_clReleaseKernel (device_param->kernel_mp);
16253 if (device_param->kernel_mp_l) hc_clReleaseKernel (device_param->kernel_mp_l);
16254 if (device_param->kernel_mp_r) hc_clReleaseKernel (device_param->kernel_mp_r);
16255 if (device_param->kernel_tb) hc_clReleaseKernel (device_param->kernel_tb);
16256 if (device_param->kernel_tm) hc_clReleaseKernel (device_param->kernel_tm);
16257 if (device_param->kernel_amp) hc_clReleaseKernel (device_param->kernel_amp);
16258
16259 if (device_param->program) hc_clReleaseProgram (device_param->program);
16260 if (device_param->program_mp) hc_clReleaseProgram (device_param->program_mp);
16261 if (device_param->program_amp) hc_clReleaseProgram (device_param->program_amp);
16262 if (device_param->command_queue) hc_clReleaseCommandQueue (device_param->command_queue);
16263 if (device_param->context) hc_clReleaseContext (device_param->context);
16264 }
16265
16266 // reset default fan speed
16267
16268 if (gpu_temp_disable == 0)
16269 {
16270 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16271 {
16272 hc_thread_mutex_lock (mux_adl);
16273
16274 for (uint i = 0; i < data.devices_cnt; i++)
16275 {
16276 if (data.hm_device[i].fan_supported == 1)
16277 {
16278 int fanspeed = temp_retain_fanspeed_value[i];
16279
16280 if (fanspeed == -1) continue;
16281
16282 int rc = hm_set_fanspeed_with_device_id_amd (i, fanspeed);
16283
16284 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", i);
16285 }
16286 }
16287
16288 hc_thread_mutex_unlock (mux_adl);
16289 }
16290 }
16291
16292 // reset power tuning
16293
16294 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16295 {
16296 hc_thread_mutex_lock (mux_adl);
16297
16298 for (uint i = 0; i < data.devices_cnt; i++)
16299 {
16300 if (data.hm_device[i].od_version == 6)
16301 {
16302 // check powertune capabilities first, if not available then skip device
16303
16304 int powertune_supported = 0;
16305
16306 if ((hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll, data.hm_device[i].adapter_index.amd, &powertune_supported)) != ADL_OK)
16307 {
16308 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16309
16310 return (-1);
16311 }
16312
16313 if (powertune_supported != 0)
16314 {
16315 // powercontrol settings
16316
16317 if ((hc_ADL_Overdrive_PowerControl_Set (data.hm_dll, data.hm_device[i].adapter_index.amd, od_power_control_status[i])) != ADL_OK)
16318 {
16319 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16320
16321 return (-1);
16322 }
16323
16324 // clocks
16325
16326 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16327
16328 performance_state->iNumberOfPerformanceLevels = 2;
16329
16330 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[i].state.aLevels[0].iEngineClock;
16331 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[i].state.aLevels[1].iEngineClock;
16332 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[i].state.aLevels[0].iMemoryClock;
16333 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[i].state.aLevels[1].iMemoryClock;
16334
16335 if ((hc_ADL_Overdrive_State_Set (data.hm_dll, data.hm_device[i].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
16336 {
16337 log_info ("ERROR: Failed to restore ADL performance state");
16338
16339 return (-1);
16340 }
16341
16342 local_free (performance_state);
16343 }
16344 }
16345 }
16346
16347 hc_thread_mutex_unlock (mux_adl);
16348 }
16349
16350 if (gpu_temp_disable == 0)
16351 {
16352 if (vendor_id == VENDOR_ID_NV)
16353 {
16354 #ifdef LINUX
16355 hc_NVML_nvmlShutdown (data.hm_dll);
16356 #endif
16357
16358 #ifdef WIN
16359 NvAPI_Unload ();
16360 #endif
16361 }
16362
16363 if (vendor_id == VENDOR_ID_AMD)
16364 {
16365 hc_ADL_Main_Control_Destroy (data.hm_dll);
16366
16367 hm_close (data.hm_dll);
16368 }
16369
16370 #ifdef LINUX
16371 if (vendor_id == VENDOR_ID_NV)
16372 {
16373 hm_close (data.hm_dll);
16374 }
16375 #endif
16376 }
16377
16378 // free memory
16379
16380 local_free (masks);
16381
16382 local_free (dictstat_base);
16383
16384 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16385 {
16386 pot_t *pot_ptr = &pot[pot_pos];
16387
16388 hash_t *hash = &pot_ptr->hash;
16389
16390 local_free (hash->digest);
16391
16392 if (isSalted)
16393 {
16394 local_free (hash->salt);
16395 }
16396 }
16397
16398 local_free (pot);
16399
16400 local_free (all_kernel_rules_cnt);
16401 local_free (all_kernel_rules_buf);
16402
16403 local_free (wl_data->buf);
16404 local_free (wl_data);
16405
16406 local_free (bitmap_s1_a);
16407 local_free (bitmap_s1_b);
16408 local_free (bitmap_s1_c);
16409 local_free (bitmap_s1_d);
16410 local_free (bitmap_s2_a);
16411 local_free (bitmap_s2_b);
16412 local_free (bitmap_s2_c);
16413 local_free (bitmap_s2_d);
16414
16415 local_free (temp_retain_fanspeed_value);
16416 local_free (od_clock_mem_status);
16417 local_free (od_power_control_status);
16418
16419 global_free (devices_param);
16420
16421 global_free (kernel_rules_buf);
16422
16423 global_free (root_css_buf);
16424 global_free (markov_css_buf);
16425
16426 global_free (digests_buf);
16427 global_free (digests_shown);
16428 global_free (digests_shown_tmp);
16429
16430 global_free (salts_buf);
16431 global_free (salts_shown);
16432
16433 global_free (esalts_buf);
16434
16435 global_free (words_progress_done);
16436 global_free (words_progress_rejected);
16437 global_free (words_progress_restored);
16438
16439 if (pot_fp) fclose (pot_fp);
16440
16441 if (data.devices_status == STATUS_QUIT) break;
16442 }
16443
16444 // destroy others mutex
16445
16446 hc_thread_mutex_delete (mux_dispatcher);
16447 hc_thread_mutex_delete (mux_counter);
16448 hc_thread_mutex_delete (mux_display);
16449 hc_thread_mutex_delete (mux_adl);
16450
16451 // free memory
16452
16453 local_free (eff_restore_file);
16454 local_free (new_restore_file);
16455
16456 local_free (rd);
16457
16458 // loopback
16459
16460 local_free (loopback_file);
16461
16462 if (loopback == 1) unlink (loopback_file);
16463
16464 // induction directory
16465
16466 if (induction_dir == NULL)
16467 {
16468 if (attack_mode != ATTACK_MODE_BF)
16469 {
16470 if (rmdir (induction_directory) == -1)
16471 {
16472 if (errno == ENOENT)
16473 {
16474 // good, we can ignore
16475 }
16476 else if (errno == ENOTEMPTY)
16477 {
16478 // good, we can ignore
16479 }
16480 else
16481 {
16482 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
16483
16484 return (-1);
16485 }
16486 }
16487
16488 local_free (induction_directory);
16489 }
16490 }
16491
16492 // outfile-check directory
16493
16494 if (outfile_check_dir == NULL)
16495 {
16496 if (rmdir (outfile_check_directory) == -1)
16497 {
16498 if (errno == ENOENT)
16499 {
16500 // good, we can ignore
16501 }
16502 else if (errno == ENOTEMPTY)
16503 {
16504 // good, we can ignore
16505 }
16506 else
16507 {
16508 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
16509
16510 return (-1);
16511 }
16512 }
16513
16514 local_free (outfile_check_directory);
16515 }
16516
16517 time_t proc_stop;
16518
16519 time (&proc_stop);
16520
16521 logfile_top_uint (proc_start);
16522 logfile_top_uint (proc_stop);
16523
16524 logfile_top_msg ("STOP");
16525
16526 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
16527 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
16528
16529 if (data.devices_status == STATUS_ABORTED) return 2;
16530 if (data.devices_status == STATUS_QUIT) return 2;
16531 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
16532 if (data.devices_status == STATUS_EXHAUSTED) return 1;
16533 if (data.devices_status == STATUS_CRACKED) return 0;
16534
16535 return -1;
16536 }
Hashcat additions to support pwdhash