projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Added new hash mode -m 13000 = RAR5
[hashcat.git] / src / oclHashcat.c
1 /**
2 * Author......: Jens Steube <jens.steube@gmail.com>
3 * License.....: MIT
4 */
5
6 #include <common.h>
7 #include <shared.h>
8 #include <rp_kernel_on_cpu.h>
9 #include <getopt.h>
10
11 const char *PROGNAME = "oclHashcat";
12 const char *VERSION_TXT = "2.10";
13 const uint VERSION_BIN = 210;
14 const uint RESTORE_MIN = 210;
15
16 #define INCR_RULES 10000
17 #define INCR_SALTS 100000
18 #define INCR_MASKS 1000
19 #define INCR_POT 1000
20
21 #define USAGE 0
22 #define VERSION 0
23 #define QUIET 0
24 #define MARKOV_THRESHOLD 0
25 #define MARKOV_DISABLE 0
26 #define MARKOV_CLASSIC 0
27 #define BENCHMARK 0
28 #define BENCHMARK_MODE 1
29 #define RESTORE 0
30 #define RESTORE_TIMER 60
31 #define RESTORE_DISABLE 0
32 #define STATUS 0
33 #define STATUS_TIMER 10
34 #define STATUS_AUTOMAT 0
35 #define LOOPBACK 0
36 #define WEAK_HASH_THRESHOLD 100
37 #define SHOW 0
38 #define LEFT 0
39 #define USERNAME 0
40 #define REMOVE 0
41 #define REMOVE_TIMER 60
42 #define SKIP 0
43 #define LIMIT 0
44 #define KEYSPACE 0
45 #define POTFILE_DISABLE 0
46 #define DEBUG_MODE 0
47 #define RP_GEN 0
48 #define RP_GEN_FUNC_MIN 1
49 #define RP_GEN_FUNC_MAX 4
50 #define RP_GEN_SEED 0
51 #define RULE_BUF_L ":"
52 #define RULE_BUF_R ":"
53 #define FORCE 0
54 #define RUNTIME 0
55 #define HEX_CHARSET 0
56 #define HEX_SALT 0
57 #define HEX_WORDLIST 0
58 #define OUTFILE_FORMAT 3
59 #define OUTFILE_AUTOHEX 1
60 #define OUTFILE_CHECK_TIMER 5
61 #define ATTACK_MODE 0
62 #define HASH_MODE 0
63 #define SEGMENT_SIZE 32
64 #define INCREMENT 0
65 #define INCREMENT_MIN 1
66 #define INCREMENT_MAX PW_MAX
67 #define SEPARATOR ':'
68 #define BITMAP_MIN 16
69 #define BITMAP_MAX 24
70 #define GPU_TEMP_DISABLE 0
71 #define GPU_TEMP_ABORT 90
72 #define GPU_TEMP_RETAIN 80
73 #define WORKLOAD_PROFILE 2
74 #define KERNEL_ACCEL 0
75 #define KERNEL_LOOPS 0
76 #define KERNEL_RULES 1024
77 #define KERNEL_COMBS 1024
78 #define KERNEL_BFS 1024
79 #define KERNEL_THREADS 64
80 #define POWERTUNE_ENABLE 0
81 #define LOGFILE_DISABLE 0
82 #define SCRYPT_TMTO 0
83
84 #define WL_MODE_STDIN 1
85 #define WL_MODE_FILE 2
86 #define WL_MODE_MASK 3
87
88 #define HL_MODE_FILE 4
89 #define HL_MODE_ARG 5
90
91 #define HLFMT_HASHCAT 0
92 #define HLFMT_PWDUMP 1
93 #define HLFMT_PASSWD 2
94 #define HLFMT_SHADOW 3
95 #define HLFMT_DCC 4
96 #define HLFMT_DCC2 5
97 #define HLFMT_NETNTLM1 7
98 #define HLFMT_NETNTLM2 8
99 #define HLFMT_NSLDAP 9
100 #define HLFMT_NSLDAPS 10
101 #define HLFMTS_CNT 11
102
103 #define ATTACK_MODE_STRAIGHT 0
104 #define ATTACK_MODE_COMBI 1
105 #define ATTACK_MODE_TOGGLE 2
106 #define ATTACK_MODE_BF 3
107 #define ATTACK_MODE_PERM 4
108 #define ATTACK_MODE_TABLE 5
109 #define ATTACK_MODE_HYBRID1 6
110 #define ATTACK_MODE_HYBRID2 7
111 #define ATTACK_MODE_NONE 100
112
113 #define ATTACK_KERN_STRAIGHT 0
114 #define ATTACK_KERN_COMBI 1
115 #define ATTACK_KERN_BF 3
116 #define ATTACK_KERN_NONE 100
117
118 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
119 #define ATTACK_EXEC_INSIDE_KERNEL 11
120
121 #define COMBINATOR_MODE_BASE_LEFT 10001
122 #define COMBINATOR_MODE_BASE_RIGHT 10002
123
124 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
125 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
126
127 #define MAX_CUT_TRIES 4
128
129 #define MAX_DICTSTAT 10000
130
131 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 130
132
133 #define global_free(attr) \
134 { \
135 myfree ((void *) data.attr); \
136 \
137 data.attr = NULL; \
138 }
139
140 #define local_free(attr) \
141 { \
142 myfree ((void *) attr); \
143 \
144 attr = NULL; \
145 }
146
147 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
148 {
149 900,
150 0,
151 5100,
152 100,
153 1400,
154 10800,
155 1700,
156 5000,
157 10100,
158 6000,
159 6100,
160 6900,
161 11700,
162 11800,
163 400,
164 8900,
165 11900,
166 12000,
167 10900,
168 12100,
169 23,
170 2500,
171 5300,
172 5400,
173 5500,
174 5600,
175 7300,
176 7500,
177 8300,
178 11100,
179 11200,
180 11400,
181 121,
182 2611,
183 2711,
184 2811,
185 8400,
186 11,
187 2612,
188 7900,
189 21,
190 11000,
191 124,
192 10000,
193 3711,
194 7600,
195 12,
196 131,
197 132,
198 1731,
199 200,
200 300,
201 3100,
202 112,
203 12300,
204 8000,
205 141,
206 1441,
207 1600,
208 12600,
209 1421,
210 101,
211 111,
212 1711,
213 3000,
214 1000,
215 1100,
216 2100,
217 12800,
218 1500,
219 12400,
220 500,
221 3200,
222 7400,
223 1800,
224 122,
225 1722,
226 7100,
227 6300,
228 6700,
229 6400,
230 6500,
231 2400,
232 2410,
233 5700,
234 9200,
235 9300,
236 22,
237 501,
238 5800,
239 8100,
240 8500,
241 7200,
242 9900,
243 7700,
244 7800,
245 10300,
246 8600,
247 8700,
248 9100,
249 133,
250 11600,
251 12500,
252 13000,
253 6211,
254 6221,
255 6231,
256 6241,
257 8800,
258 12900,
259 12200,
260 9700,
261 9710,
262 9800,
263 9810,
264 9400,
265 9500,
266 9600,
267 10400,
268 10410,
269 10500,
270 10600,
271 10700,
272 9000,
273 5200,
274 6800,
275 6600,
276 8200,
277 11300,
278 12700
279 };
280
281 /**
282 * types
283 */
284
285 static void (*get_next_word_func) (char *, uint32_t, uint32_t *, uint32_t *);
286
287 /**
288 * globals
289 */
290
291 static unsigned int full01 = 0x01010101;
292 static unsigned int full80 = 0x80808080;
293
294 int SUPPRESS_OUTPUT = 0;
295
296 hc_thread_mutex_t mux_adl;
297 hc_thread_mutex_t mux_counter;
298 hc_thread_mutex_t mux_dispatcher;
299 hc_thread_mutex_t mux_display;
300
301 hc_global_data_t data;
302
303 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
304
305 const char *USAGE_MINI[] =
306 {
307 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
308 "",
309 "Try --help for more help.",
310 NULL
311 };
312
313 const char *USAGE_BIG[] =
314 {
315 "%s, advanced password recovery",
316 "",
317 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
318 "",
319 "=======",
320 "Options",
321 "=======",
322 "",
323 "* General:",
324 "",
325 " -m, --hash-type=NUM Hash-type, see references below",
326 " -a, --attack-mode=NUM Attack-mode, see references below",
327 " -V, --version Print version",
328 " -h, --help Print help",
329 " --quiet Suppress output",
330 "",
331 "* Benchmark:",
332 "",
333 " -b, --benchmark Run benchmark",
334 " --benchmark-mode=NUM Benchmark-mode, see references below",
335 "",
336 "* Misc:",
337 "",
338 " --hex-charset Assume charset is given in hex",
339 " --hex-salt Assume salt is given in hex",
340 " --hex-wordlist Assume words in wordlist is given in hex",
341 " --force Ignore warnings",
342 " --status Enable automatic update of the status-screen",
343 " --status-timer=NUM Seconds between status-screen update",
344 " --status-automat Display the status view in a machine readable format",
345 " --loopback Add new plains to induct directory",
346 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
347 "",
348 "* Markov:",
349 "",
350 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
351 " --markov-disable Disables markov-chains, emulates classic brute-force",
352 " --markov-classic Enables classic markov-chains, no per-position enhancement",
353 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
354 "",
355 "* Session:",
356 "",
357 " --runtime=NUM Abort session after NUM seconds of runtime",
358 " --session=STR Define specific session name",
359 " --restore Restore session from --session",
360 " --restore-disable Do not write restore file",
361 "",
362 "* Files:",
363 "",
364 " -o, --outfile=FILE Define outfile for recovered hash",
365 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
366 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
367 " --outfile-check-timer=NUM Seconds between outfile checks",
368 " -p, --separator=CHAR Separator char for hashlists and outfile",
369 " --show Show cracked passwords only",
370 " --left Show un-cracked passwords only",
371 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
372 " --remove Enable remove of hash once it is cracked",
373 " --remove-timer=NUM Update input hash file each NUM seconds",
374 " --potfile-disable Do not write potfile",
375 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
376 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
377 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
378 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
379 " --logfile-disable Disable the logfile",
380 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
381 "",
382 "* Resources:",
383 "",
384 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
385 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
386 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
387 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
388 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
389 " --opencl-platform=NUM OpenCL platform to use, in case multiple platforms are present",
390 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
391 " -n, --kernel-accel=NUM Workload tuning: 1, 8, 40, 80, 160",
392 " -u, --kernel-loops=NUM Workload fine-tuning: 8 - 1024",
393 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
394 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
395 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
396 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
397 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
398 "",
399 "* Distributed:",
400 "",
401 " -s, --skip=NUM Skip number of words",
402 " -l, --limit=NUM Limit number of words",
403 " --keyspace Show keyspace base:mod values and quit",
404 "",
405 "* Rules:",
406 "",
407 " -j, --rule-left=RULE Single rule applied to each word from left dict",
408 " -k, --rule-right=RULE Single rule applied to each word from right dict",
409 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
410 " -g, --generate-rules=NUM Generate NUM random rules",
411 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
412 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
413 " --generate-rules-seed=NUM Force RNG seed to NUM",
414 "",
415 "* Custom charsets:",
416 "",
417 " -1, --custom-charset1=CS User-defined charsets",
418 " -2, --custom-charset2=CS Example:",
419 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
420 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
421 "",
422 "* Increment:",
423 "",
424 " -i, --increment Enable increment mode",
425 " --increment-min=NUM Start incrementing at NUM",
426 " --increment-max=NUM Stop incrementing at NUM",
427 "",
428 "==========",
429 "References",
430 "==========",
431 "",
432 "* Workload Profile:",
433 "",
434 " 1 = Reduced performance profile (low latency desktop)",
435 " 2 = Default performance profile",
436 " 3 = Tuned performance profile (high latency desktop)",
437 "",
438 "* Benchmark Settings:",
439 "",
440 " 0 = Manual Tuning",
441 " 1 = Performance Tuning, default",
442 "",
443 "* Outfile Formats:",
444 "",
445 " 1 = hash[:salt]",
446 " 2 = plain",
447 " 3 = hash[:salt]:plain",
448 " 4 = hex_plain",
449 " 5 = hash[:salt]:hex_plain",
450 " 6 = plain:hex_plain",
451 " 7 = hash[:salt]:plain:hex_plain",
452 " 8 = crackpos",
453 " 9 = hash[:salt]:crackpos",
454 " 10 = plain:crackpos",
455 " 11 = hash[:salt]:plain:crackpos",
456 " 12 = hex_plain:crackpos",
457 " 13 = hash[:salt]:hex_plain:crackpos",
458 " 14 = plain:hex_plain:crackpos",
459 " 15 = hash[:salt]:plain:hex_plain:crackpos",
460 "",
461 "* Debug mode output formats (for hybrid mode only, by using rules):",
462 "",
463 " 1 = save finding rule",
464 " 2 = save original word",
465 " 3 = save original word and finding rule",
466 " 4 = save original word, finding rule and modified plain",
467 "",
468 "* Built-in charsets:",
469 "",
470 " ?l = abcdefghijklmnopqrstuvwxyz",
471 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
472 " ?d = 0123456789",
473 " ?s = !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~",
474 " ?a = ?l?u?d?s",
475 " ?b = 0x00 - 0xff",
476 "",
477 "* Attack modes:",
478 "",
479 " 0 = Straight",
480 " 1 = Combination",
481 " 3 = Brute-force",
482 " 6 = Hybrid dict + mask",
483 " 7 = Hybrid mask + dict",
484 "",
485 "* Hash types:",
486 "",
487 "[[ Roll-your-own: Raw Hashes ]]",
488 "",
489 " 900 = MD4",
490 " 0 = MD5",
491 " 5100 = Half MD5",
492 " 100 = SHA1",
493 " 10800 = SHA-384",
494 " 1400 = SHA-256",
495 " 1700 = SHA-512",
496 " 5000 = SHA-3(Keccak)",
497 " 10100 = SipHash",
498 " 6000 = RipeMD160",
499 " 6100 = Whirlpool",
500 " 6900 = GOST R 34.11-94",
501 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
502 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
503 "",
504 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
505 "",
506 " 10 = md5($pass.$salt)",
507 " 20 = md5($salt.$pass)",
508 " 30 = md5(unicode($pass).$salt)",
509 " 40 = md5($salt.unicode($pass))",
510 " 3800 = md5($salt.$pass.$salt)",
511 " 3710 = md5($salt.md5($pass))",
512 " 2600 = md5(md5($pass)",
513 " 4300 = md5(strtoupper(md5($pass)))",
514 " 4400 = md5(sha1($pass))",
515 " 110 = sha1($pass.$salt)",
516 " 120 = sha1($salt.$pass)",
517 " 130 = sha1(unicode($pass).$salt)",
518 " 140 = sha1($salt.unicode($pass))",
519 " 4500 = sha1(sha1($pass)",
520 " 4700 = sha1(md5($pass))",
521 " 4900 = sha1($salt.$pass.$salt)",
522 " 1410 = sha256($pass.$salt)",
523 " 1420 = sha256($salt.$pass)",
524 " 1430 = sha256(unicode($pass).$salt)",
525 " 1440 = sha256($salt.unicode($pass))",
526 " 1710 = sha512($pass.$salt)",
527 " 1720 = sha512($salt.$pass)",
528 " 1730 = sha512(unicode($pass).$salt)",
529 " 1740 = sha512($salt.unicode($pass))",
530 "",
531 "[[ Roll-your-own: Authenticated Hashes ]]",
532 "",
533 " 50 = HMAC-MD5 (key = $pass)",
534 " 60 = HMAC-MD5 (key = $salt)",
535 " 150 = HMAC-SHA1 (key = $pass)",
536 " 160 = HMAC-SHA1 (key = $salt)",
537 " 1450 = HMAC-SHA256 (key = $pass)",
538 " 1460 = HMAC-SHA256 (key = $salt)",
539 " 1750 = HMAC-SHA512 (key = $pass)",
540 " 1760 = HMAC-SHA512 (key = $salt)",
541 "",
542 "[[ Generic KDF ]]",
543 "",
544 " 400 = phpass",
545 " 8900 = scrypt",
546 " 11900 = PBKDF2-HMAC-MD5",
547 " 12000 = PBKDF2-HMAC-SHA1",
548 " 10900 = PBKDF2-HMAC-SHA256",
549 " 12100 = PBKDF2-HMAC-SHA512",
550 "",
551 "[[ Network protocols, Challenge-Response ]]",
552 "",
553 " 23 = Skype",
554 " 2500 = WPA/WPA2",
555 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
556 " 5300 = IKE-PSK MD5",
557 " 5400 = IKE-PSK SHA1",
558 " 5500 = NetNTLMv1",
559 " 5500 = NetNTLMv1 + ESS",
560 " 5600 = NetNTLMv2",
561 " 7300 = IPMI2 RAKP HMAC-SHA1",
562 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
563 " 8300 = DNSSEC (NSEC3)",
564 " 10200 = Cram MD5",
565 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
566 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
567 " 11400 = SIP digest authentication (MD5)",
568 "",
569 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
570 "",
571 " 121 = SMF (Simple Machines Forum)",
572 " 400 = phpBB3",
573 " 2611 = vBulletin < v3.8.5",
574 " 2711 = vBulletin > v3.8.5",
575 " 2811 = MyBB",
576 " 2811 = IPB (Invison Power Board)",
577 " 8400 = WBB3 (Woltlab Burning Board)",
578 " 11 = Joomla < 2.5.18",
579 " 400 = Joomla > 2.5.18",
580 " 400 = Wordpress",
581 " 2612 = PHPS",
582 " 7900 = Drupal7",
583 " 21 = osCommerce",
584 " 21 = xt:Commerce",
585 " 11000 = PrestaShop",
586 " 124 = Django (SHA-1)",
587 " 10000 = Django (PBKDF2-SHA256)",
588 " 3711 = Mediawiki B type",
589 " 7600 = Redmine",
590 "",
591 "[[ Database Server ]]",
592 "",
593 " 12 = PostgreSQL",
594 " 131 = MSSQL(2000)",
595 " 132 = MSSQL(2005)",
596 " 1731 = MSSQL(2012)",
597 " 1731 = MSSQL(2014)",
598 " 200 = MySQL323",
599 " 300 = MySQL4.1/MySQL5",
600 " 3100 = Oracle H: Type (Oracle 7+)",
601 " 112 = Oracle S: Type (Oracle 11+)",
602 " 12300 = Oracle T: Type (Oracle 12+)",
603 " 8000 = Sybase ASE",
604 "",
605 "[[ HTTP, SMTP, LDAP Server ]]",
606 "",
607 " 141 = EPiServer 6.x < v4",
608 " 1441 = EPiServer 6.x > v4",
609 " 1600 = Apache $apr1$",
610 " 12600 = ColdFusion 10+",
611 " 1421 = hMailServer",
612 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
613 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
614 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
615 "",
616 "[[ Checksums ]]",
617 "",
618 " 11500 = CRC32",
619 "",
620 "[[ Operating-Systems ]]",
621 "",
622 " 3000 = LM",
623 " 1000 = NTLM",
624 " 1100 = Domain Cached Credentials (DCC), MS Cache",
625 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
626 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
627 " 1500 = descrypt, DES(Unix), Traditional DES",
628 " 12400 = BSDiCrypt, Extended DES",
629 " 500 = md5crypt $1$, MD5(Unix)",
630 " 3200 = bcrypt $2*$, Blowfish(Unix)",
631 " 7400 = sha256crypt $5$, SHA256(Unix)",
632 " 1800 = sha512crypt $6$, SHA512(Unix)",
633 " 122 = OSX v10.4",
634 " 122 = OSX v10.5",
635 " 122 = OSX v10.6",
636 " 1722 = OSX v10.7",
637 " 7100 = OSX v10.8",
638 " 7100 = OSX v10.9",
639 " 7100 = OSX v10.10",
640 " 6300 = AIX {smd5}",
641 " 6700 = AIX {ssha1}",
642 " 6400 = AIX {ssha256}",
643 " 6500 = AIX {ssha512}",
644 " 2400 = Cisco-PIX",
645 " 2410 = Cisco-ASA",
646 " 500 = Cisco-IOS $1$",
647 " 5700 = Cisco-IOS $4$",
648 " 9200 = Cisco-IOS $8$",
649 " 9300 = Cisco-IOS $9$",
650 " 22 = Juniper Netscreen/SSG (ScreenOS)",
651 " 501 = Juniper IVE",
652 " 5800 = Android PIN",
653 " 8100 = Citrix Netscaler",
654 " 8500 = RACF",
655 " 7200 = GRUB 2",
656 " 9900 = Radmin2",
657 "",
658 "[[ Enterprise Application Software (EAS) ]]",
659 "",
660 " 7700 = SAP CODVN B (BCODE)",
661 " 7800 = SAP CODVN F/G (PASSCODE)",
662 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
663 " 8600 = Lotus Notes/Domino 5",
664 " 8700 = Lotus Notes/Domino 6",
665 " 9100 = Lotus Notes/Domino 8",
666 " 133 = PeopleSoft",
667 "",
668 "[[ Archives ]]",
669 "",
670 " 11600 = 7-Zip",
671 " 12500 = RAR3-hp",
672 " 13000 = RAR5",
673 "",
674 "[[ Full-Disk encryptions (FDE) ]]",
675 "",
676 " 62XY = TrueCrypt 5.0+",
677 " X = 1 = PBKDF2-HMAC-RipeMD160",
678 " X = 2 = PBKDF2-HMAC-SHA512",
679 " X = 3 = PBKDF2-HMAC-Whirlpool",
680 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
681 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
682 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
683 " Y = 3 = XTS 1536 bit (Ciphers: All)",
684 " 8800 = Android FDE < v4.3",
685 " 12900 = Android FDE (Samsung DEK)",
686 " 12200 = eCryptfs",
687 "",
688 "[[ Documents ]]",
689 "",
690 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
691 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
692 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
693 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
694 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
695 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
696 " 9400 = MS Office 2007",
697 " 9500 = MS Office 2010",
698 " 9600 = MS Office 2013",
699 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
700 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
701 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
702 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
703 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
704 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
705 "",
706 "[[ Password Managers ]]",
707 "",
708 " 9000 = Password Safe v2",
709 " 5200 = Password Safe v3",
710 " 6800 = Lastpass",
711 " 6600 = 1Password, agilekeychain",
712 " 8200 = 1Password, cloudkeychain",
713 " 11300 = Bitcoin/Litecoin wallet.dat",
714 " 12700 = Blockchain, My Wallet",
715 "",
716 NULL
717 };
718
719 /**
720 * oclHashcat specific functions
721 */
722
723 void status_display_automat ()
724 {
725 FILE *out = stdout;
726
727 fprintf (out, "STATUS\t%u\t", data.devices_status);
728
729 /**
730 * speed new
731 */
732
733 fprintf (out, "SPEED\t");
734
735 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
736 {
737 hc_device_param_t *device_param = &data.devices_param[device_id];
738
739 uint64_t speed_cnt = 0;
740 float speed_ms = 0;
741
742 for (int i = 0; i < SPEED_CACHE; i++)
743 {
744 float rec_ms;
745
746 hc_timer_get (device_param->speed_rec[i], rec_ms);
747
748 if (rec_ms > SPEED_MAXAGE) continue;
749
750 speed_cnt += device_param->speed_cnt[i];
751 speed_ms += device_param->speed_ms[i];
752 }
753
754 speed_cnt /= SPEED_CACHE;
755 speed_ms /= SPEED_CACHE;
756
757 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
758 }
759
760 /**
761 * words_cur
762 */
763
764 uint64_t words_cur = get_lowest_words_done ();
765
766 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
767
768 /**
769 * counter
770 */
771
772 uint salts_left = data.salts_cnt - data.salts_done;
773
774 if (salts_left == 0) salts_left = 1;
775
776 uint64_t progress_total = data.words_cnt * salts_left;
777
778 uint64_t all_done = 0;
779 uint64_t all_rejected = 0;
780 uint64_t all_restored = 0;
781
782 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
783 {
784 if (salts_left > 1)
785 {
786 // otherwise the final cracked status shows 0/XXX progress
787
788 if (data.salts_shown[salt_pos] == 1) continue;
789 }
790
791 all_done += data.words_progress_done[salt_pos];
792 all_rejected += data.words_progress_rejected[salt_pos];
793 all_restored += data.words_progress_restored[salt_pos];
794 }
795
796 uint64_t progress_cur = all_restored + all_done + all_rejected;
797 uint64_t progress_end = progress_total;
798
799 uint64_t progress_skip = 0;
800
801 if (data.skip)
802 {
803 progress_skip = MIN (data.skip, data.words_base) * salts_left;
804
805 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
806 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
807 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
808 }
809
810 if (data.limit)
811 {
812 progress_end = MIN (data.limit, data.words_base) * salts_left;
813
814 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
815 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
816 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
817 }
818
819 uint64_t progress_cur_relative_skip = progress_cur - progress_skip;
820 uint64_t progress_end_relative_skip = progress_end - progress_skip;
821
822 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
823
824 /**
825 * cracks
826 */
827
828 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
829 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
830
831 /**
832 * temperature
833 */
834
835 if (data.gpu_temp_disable == 0)
836 {
837 fprintf (out, "TEMP\t");
838
839 hc_thread_mutex_lock (mux_adl);
840
841 for (uint i = 0; i < data.devices_cnt; i++)
842 {
843 int temp = hm_get_temperature_with_device_id (i);
844
845 fprintf (out, "%d\t", temp);
846 }
847
848 hc_thread_mutex_unlock (mux_adl);
849 }
850
851 #ifdef _WIN
852 fputc ('\r', out);
853 fputc ('\n', out);
854 #endif
855
856 #ifdef _POSIX
857 fputc ('\n', out);
858 #endif
859
860 fflush (out);
861 }
862
863 void status_display ()
864 {
865 if (data.devices_status == STATUS_INIT) return;
866 if (data.devices_status == STATUS_STARTING) return;
867 if (data.devices_status == STATUS_BYPASS) return;
868
869 if (data.status_automat == 1)
870 {
871 status_display_automat ();
872
873 return;
874 }
875
876 char tmp_buf[1000];
877
878 uint tmp_len = 0;
879
880 log_info ("Session.Name...: %s", data.session);
881
882 char *status_type = strstatus (data.devices_status);
883
884 uint hash_mode = data.hash_mode;
885
886 char *hash_type = strhashtype (hash_mode); // not a bug
887
888 log_info ("Status.........: %s", status_type);
889
890 /**
891 * show rules
892 */
893
894 if (data.rp_files_cnt)
895 {
896 uint i;
897
898 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
899 {
900 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
901 }
902
903 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
904
905 log_info ("Rules.Type.....: %s", tmp_buf);
906
907 tmp_len = 0;
908 }
909
910 if (data.rp_gen)
911 {
912 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
913
914 if (data.rp_gen_seed)
915 {
916 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
917 }
918 }
919
920 /**
921 * show input
922 */
923
924 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
925 {
926 if (data.wordlist_mode == WL_MODE_FILE)
927 {
928 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
929 }
930 else if (data.wordlist_mode == WL_MODE_STDIN)
931 {
932 log_info ("Input.Mode.....: Pipe");
933 }
934 }
935 else if (data.attack_mode == ATTACK_MODE_COMBI)
936 {
937 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
938 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
939 }
940 else if (data.attack_mode == ATTACK_MODE_BF)
941 {
942 char *mask = data.mask;
943
944 if (mask != NULL)
945 {
946 uint mask_len = data.css_cnt;
947
948 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
949
950 if (mask_len > 0)
951 {
952 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
953 {
954 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
955 {
956 mask_len -= data.salts_buf[0].salt_len;
957 }
958 }
959
960 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
961
962 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
963 }
964
965 if (data.maskcnt > 1)
966 {
967 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
968
969 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
970 }
971
972 log_info ("Input.Mode.....: %s", tmp_buf);
973 }
974
975 tmp_len = 0;
976 }
977 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
978 {
979 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
980 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
981 }
982 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
983 {
984 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
985 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
986 }
987
988 if (data.digests_cnt == 1)
989 {
990 if (data.hash_mode == 2500)
991 {
992 wpa_t *wpa = (wpa_t *) data.esalts_buf;
993
994 uint pke[25];
995
996 char *pke_ptr = (char *) pke;
997
998 for (uint i = 0; i < 25; i++)
999 {
1000 pke[i] = byte_swap_32 (wpa->pke[i]);
1001 }
1002
1003 char mac1[6];
1004 char mac2[6];
1005
1006 memcpy (mac1, pke_ptr + 23, 6);
1007 memcpy (mac2, pke_ptr + 29, 6);
1008
1009 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1010 (char *) data.salts_buf[0].salt_buf,
1011 mac1[0] & 0xff,
1012 mac1[1] & 0xff,
1013 mac1[2] & 0xff,
1014 mac1[3] & 0xff,
1015 mac1[4] & 0xff,
1016 mac1[5] & 0xff,
1017 mac2[0] & 0xff,
1018 mac2[1] & 0xff,
1019 mac2[2] & 0xff,
1020 mac2[3] & 0xff,
1021 mac2[4] & 0xff,
1022 mac2[5] & 0xff);
1023 }
1024 else if (data.hash_mode == 5200)
1025 {
1026 log_info ("Hash.Target....: File (%s)", data.hashfile);
1027 }
1028 else if (data.hash_mode == 9000)
1029 {
1030 log_info ("Hash.Target....: File (%s)", data.hashfile);
1031 }
1032 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1033 {
1034 log_info ("Hash.Target....: File (%s)", data.hashfile);
1035 }
1036 else
1037 {
1038 char out_buf[4096];
1039
1040 ascii_digest (out_buf, 0, 0);
1041
1042 // limit length
1043 if (strlen (out_buf) > 40)
1044 {
1045 out_buf[41] = '.';
1046 out_buf[42] = '.';
1047 out_buf[43] = '.';
1048 out_buf[44] = 0;
1049 }
1050
1051 log_info ("Hash.Target....: %s", out_buf);
1052 }
1053 }
1054 else
1055 {
1056 if (data.hash_mode == 3000)
1057 {
1058 char out_buf1[4096];
1059 char out_buf2[4096];
1060
1061 ascii_digest (out_buf1, 0, 0);
1062 ascii_digest (out_buf2, 0, 1);
1063
1064 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1065 }
1066 else
1067 {
1068 log_info ("Hash.Target....: File (%s)", data.hashfile);
1069 }
1070 }
1071
1072 log_info ("Hash.Type......: %s", hash_type);
1073
1074 /**
1075 * speed new
1076 */
1077
1078 uint64_t speed_cnt[DEVICES_MAX];
1079 float speed_ms[DEVICES_MAX];
1080
1081 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1082 {
1083 hc_device_param_t *device_param = &data.devices_param[device_id];
1084
1085 // we need to clear values (set to 0) because in case the device does
1086 // not get new candidates it idles around but speed display would
1087 // show it as working.
1088 // if we instantly set it to 0 after reading it happens that the
1089 // speed can be shown as zero if the users refreshs to fast.
1090 // therefore, we add a timestamp when a stat was recorded and if its
1091 // to old we will not use it
1092
1093 speed_cnt[device_id] = 0;
1094 speed_ms[device_id] = 0;
1095
1096 for (int i = 0; i < SPEED_CACHE; i++)
1097 {
1098 float rec_ms;
1099
1100 hc_timer_get (device_param->speed_rec[i], rec_ms);
1101
1102 if (rec_ms > SPEED_MAXAGE) continue;
1103
1104 speed_cnt[device_id] += device_param->speed_cnt[i];
1105 speed_ms[device_id] += device_param->speed_ms[i];
1106 }
1107
1108 speed_cnt[device_id] /= SPEED_CACHE;
1109 speed_ms[device_id] /= SPEED_CACHE;
1110 }
1111
1112 float hashes_all_ms = 0;
1113
1114 float hashes_dev_ms[DEVICES_MAX];
1115
1116 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1117 {
1118 hashes_dev_ms[device_id] = 0;
1119
1120 if (speed_ms[device_id])
1121 {
1122 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1123
1124 hashes_all_ms += hashes_dev_ms[device_id];
1125 }
1126 }
1127
1128 /**
1129 * timers
1130 */
1131
1132 float ms_running = 0;
1133
1134 hc_timer_get (data.timer_running, ms_running);
1135
1136 float ms_paused = data.ms_paused;
1137
1138 if (data.devices_status == STATUS_PAUSED)
1139 {
1140 float ms_paused_tmp = 0;
1141
1142 hc_timer_get (data.timer_paused, ms_paused_tmp);
1143
1144 ms_paused += ms_paused_tmp;
1145 }
1146
1147 #ifdef WIN
1148
1149 __time64_t sec_run = ms_running / 1000;
1150
1151 #else
1152
1153 time_t sec_run = ms_running / 1000;
1154
1155 #endif
1156
1157 if (sec_run)
1158 {
1159 char display_run[32];
1160
1161 struct tm tm_run;
1162
1163 struct tm *tmp;
1164
1165 #ifdef WIN
1166
1167 tmp = _gmtime64 (&sec_run);
1168
1169 #else
1170
1171 tmp = gmtime (&sec_run);
1172
1173 #endif
1174
1175 if (tmp != NULL)
1176 {
1177 memcpy (&tm_run, tmp, sizeof (struct tm));
1178
1179 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1180
1181 char *start = ctime (&data.proc_start);
1182
1183 size_t start_len = strlen (start);
1184
1185 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1186 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1187
1188 log_info ("Time.Started...: %s (%s)", start, display_run);
1189 }
1190 }
1191 else
1192 {
1193 log_info ("Time.Started...: 0 secs");
1194 }
1195
1196 /**
1197 * counters
1198 */
1199
1200 uint salts_left = data.salts_cnt - data.salts_done;
1201
1202 if (salts_left == 0) salts_left = 1;
1203
1204 uint64_t progress_total = data.words_cnt * salts_left;
1205
1206 uint64_t all_done = 0;
1207 uint64_t all_rejected = 0;
1208 uint64_t all_restored = 0;
1209
1210 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1211 {
1212 if (salts_left > 1)
1213 {
1214 // otherwise the final cracked status shows 0/XXX progress
1215
1216 if (data.salts_shown[salt_pos] == 1) continue;
1217 }
1218
1219 all_done += data.words_progress_done[salt_pos];
1220 all_rejected += data.words_progress_rejected[salt_pos];
1221 all_restored += data.words_progress_restored[salt_pos];
1222 }
1223
1224 uint64_t progress_cur = all_restored + all_done + all_rejected;
1225 uint64_t progress_end = progress_total;
1226
1227 uint64_t progress_skip = 0;
1228
1229 if (data.skip)
1230 {
1231 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1232
1233 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1234 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1235 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1236 }
1237
1238 if (data.limit)
1239 {
1240 progress_end = MIN (data.limit, data.words_base) * salts_left;
1241
1242 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1243 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1244 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1245 }
1246
1247 uint64_t progress_cur_relative_skip = progress_cur - progress_skip;
1248 uint64_t progress_end_relative_skip = progress_end - progress_skip;
1249
1250 float speed_ms_real = ms_running - ms_paused;
1251 uint64_t speed_plains_real = all_done;
1252
1253 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1254 {
1255 if (data.devices_status != STATUS_CRACKED)
1256 {
1257 uint64_t words_per_ms = 0;
1258
1259 if (speed_plains_real && speed_ms_real)
1260 {
1261 words_per_ms = speed_plains_real / speed_ms_real;
1262 }
1263
1264 #ifdef WIN
1265 __time64_t sec_etc = 0;
1266 #else
1267 time_t sec_etc = 0;
1268 #endif
1269
1270 if (words_per_ms)
1271 {
1272 uint64_t progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1273
1274 uint64_t ms_left = progress_left_relative_skip / words_per_ms;
1275
1276 sec_etc = ms_left / 1000;
1277 }
1278
1279 if (sec_etc == 0)
1280 {
1281 log_info ("Time.Estimated.: 0 secs");
1282 }
1283 else if ((uint64_t) sec_etc > ETC_MAX)
1284 {
1285 log_info ("Time.Estimated.: > 10 Years");
1286 }
1287 else
1288 {
1289 char display_etc[32];
1290
1291 struct tm tm_etc;
1292
1293 struct tm *tmp;
1294
1295 #ifdef WIN
1296
1297 tmp = _gmtime64 (&sec_etc);
1298
1299 #else
1300
1301 tmp = gmtime (&sec_etc);
1302
1303 #endif
1304
1305 if (tmp != NULL)
1306 {
1307 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1308
1309 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1310
1311 time_t now;
1312
1313 time (&now);
1314
1315 now += sec_etc;
1316
1317 char *etc = ctime (&now);
1318
1319 size_t etc_len = strlen (etc);
1320
1321 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1322 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1323
1324 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1325 }
1326 }
1327 }
1328 }
1329
1330 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1331 {
1332 char display_dev_cur[16];
1333
1334 memset (display_dev_cur, 0, sizeof (display_dev_cur));
1335
1336 strncpy (display_dev_cur, "0.00", 4);
1337
1338 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1339
1340 log_info ("Speed.Dev.#%d...: %9sH/s", device_id + 1, display_dev_cur);
1341 }
1342
1343 char display_all_cur[16];
1344
1345 memset (display_all_cur, 0, sizeof (display_all_cur));
1346
1347 strncpy (display_all_cur, "0.00", 4);
1348
1349 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1350
1351 if (data.devices_cnt > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1352
1353 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1354 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1355
1356 log_info ("Recovered......: %u/%u (%.2f%%) Digests, %u/%u (%.2f%%) Salts", data.digests_done, data.digests_cnt, digests_percent * 100, data.salts_done, data.salts_cnt, salts_percent * 100);
1357
1358 // crack-per-time
1359
1360 if (data.digests_cnt > 100)
1361 {
1362 time_t now = time (NULL);
1363
1364 int cpt_cur_min = 0;
1365 int cpt_cur_hour = 0;
1366 int cpt_cur_day = 0;
1367
1368 for (int i = 0; i < CPT_BUF; i++)
1369 {
1370 const uint cracked = data.cpt_buf[i].cracked;
1371 const time_t timestamp = data.cpt_buf[i].timestamp;
1372
1373 if ((timestamp + 60) > now)
1374 {
1375 cpt_cur_min += cracked;
1376 }
1377
1378 if ((timestamp + 3600) > now)
1379 {
1380 cpt_cur_hour += cracked;
1381 }
1382
1383 if ((timestamp + 86400) > now)
1384 {
1385 cpt_cur_day += cracked;
1386 }
1387 }
1388
1389 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1390 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1391 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1392
1393 if ((data.cpt_start + 86400) < now)
1394 {
1395 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1396 cpt_cur_min,
1397 cpt_cur_hour,
1398 cpt_cur_day,
1399 cpt_avg_min,
1400 cpt_avg_hour,
1401 cpt_avg_day);
1402 }
1403 else if ((data.cpt_start + 3600) < now)
1404 {
1405 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1406 cpt_cur_min,
1407 cpt_cur_hour,
1408 cpt_avg_min,
1409 cpt_avg_hour,
1410 cpt_avg_day);
1411 }
1412 else if ((data.cpt_start + 60) < now)
1413 {
1414 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1415 cpt_cur_min,
1416 cpt_avg_min,
1417 cpt_avg_hour,
1418 cpt_avg_day);
1419 }
1420 else
1421 {
1422 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1423 cpt_avg_min,
1424 cpt_avg_hour,
1425 cpt_avg_day);
1426 }
1427 }
1428
1429 // Restore point
1430
1431 uint64_t restore_point = get_lowest_words_done ();
1432
1433 uint64_t restore_total = data.words_base;
1434
1435 float percent_restore = 0;
1436
1437 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1438
1439 if (progress_end_relative_skip)
1440 {
1441 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1442 {
1443 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1444 float percent_rejected = 0.0;
1445
1446 if (progress_cur)
1447 {
1448 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1449 }
1450
1451 log_info ("Progress.......: %llu/%llu (%.02f%%)", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip, percent_finished * 100);
1452 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1453
1454 if (data.restore_disable == 0)
1455 {
1456 if (percent_finished != 1)
1457 {
1458 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1459 }
1460 }
1461 }
1462 }
1463 else
1464 {
1465 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1466 {
1467 log_info ("Progress.......: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1468 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1469
1470 if (data.restore_disable == 0)
1471 {
1472 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1473 }
1474 }
1475 else
1476 {
1477 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1478 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1479
1480 // --restore not allowed if stdin is used -- really? why?
1481
1482 //if (data.restore_disable == 0)
1483 //{
1484 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1485 //}
1486 }
1487 }
1488
1489 if (data.gpu_temp_disable == 0)
1490 {
1491 hc_thread_mutex_lock (mux_adl);
1492
1493 for (uint i = 0; i < data.devices_cnt; i++)
1494 {
1495 if (data.hm_device[i].fan_supported == 1)
1496 {
1497 const int temperature = hm_get_temperature_with_device_id (i);
1498 const int utilization = hm_get_utilization_with_device_id (i);
1499 const int fanspeed = hm_get_fanspeed_with_device_id (i);
1500
1501 if (data.vendor_id == VENDOR_ID_AMD)
1502 {
1503 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, %2d%% Fan", i + 1, utilization, temperature, fanspeed);
1504 }
1505
1506 if (data.vendor_id == VENDOR_ID_NV)
1507 {
1508 #ifdef LINUX
1509 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, %2d%% Fan", i + 1, utilization, temperature, fanspeed);
1510 #else
1511 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, %2drpm Fan", i + 1, utilization, temperature, fanspeed);
1512 #endif
1513 }
1514 }
1515 else
1516 {
1517 const int temperature = hm_get_temperature_with_device_id (i);
1518 const int utilization = hm_get_utilization_with_device_id (i);
1519
1520 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, N/A Fan", i + 1, utilization, temperature);
1521 }
1522 }
1523
1524 hc_thread_mutex_unlock (mux_adl);
1525 }
1526 }
1527
1528 static void status_benchmark ()
1529 {
1530 if (data.devices_status == STATUS_INIT) return;
1531 if (data.devices_status == STATUS_STARTING) return;
1532
1533 if (data.words_cnt == 0) return;
1534
1535 uint64_t speed_cnt[DEVICES_MAX];
1536 float speed_ms[DEVICES_MAX];
1537
1538 uint device_id;
1539
1540 for (device_id = 0; device_id < data.devices_cnt; device_id++)
1541 {
1542 hc_device_param_t *device_param = &data.devices_param[device_id];
1543
1544 speed_cnt[device_id] = 0;
1545 speed_ms[device_id] = 0;
1546
1547 for (int i = 0; i < SPEED_CACHE; i++)
1548 {
1549 speed_cnt[device_id] += device_param->speed_cnt[i];
1550 speed_ms[device_id] += device_param->speed_ms[i];
1551 }
1552
1553 speed_cnt[device_id] /= SPEED_CACHE;
1554 speed_ms[device_id] /= SPEED_CACHE;
1555 }
1556
1557 float hashes_all_ms = 0;
1558
1559 float hashes_dev_ms[DEVICES_MAX];
1560
1561 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1562 {
1563 hashes_dev_ms[device_id] = 0;
1564
1565 if (speed_ms[device_id])
1566 {
1567 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1568
1569 hashes_all_ms += hashes_dev_ms[device_id];
1570 }
1571 }
1572
1573 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1574 {
1575 char display_dev_cur[16];
1576
1577 memset (display_dev_cur, 0, sizeof (display_dev_cur));
1578
1579 strncpy (display_dev_cur, "0.00", 4);
1580
1581 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1582
1583 log_info ("Speed.Dev.#%d.: %9sH/s", device_id + 1, display_dev_cur);
1584 }
1585
1586 char display_all_cur[16];
1587
1588 memset (display_all_cur, 0, sizeof (display_all_cur));
1589
1590 strncpy (display_all_cur, "0.00", 4);
1591
1592 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1593
1594 if (data.devices_cnt > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1595 }
1596
1597 /**
1598 * oclHashcat -only- functions
1599 */
1600
1601 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1602 {
1603 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1604 {
1605 if (attack_kern == ATTACK_KERN_STRAIGHT)
1606 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1607 else if (attack_kern == ATTACK_KERN_COMBI)
1608 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1609 else if (attack_kern == ATTACK_KERN_BF)
1610 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1611 }
1612 else
1613 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1614 }
1615
1616 static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *profile_dir, char *device_name_chksum, int vendor_id, char *cached_file)
1617 {
1618 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1619 {
1620 if (attack_kern == ATTACK_KERN_STRAIGHT)
1621 snprintf (cached_file, 255, "%s/kernels/%d/m%05d_a0.%s.kernel", profile_dir, vendor_id, (int) kern_type, device_name_chksum);
1622 else if (attack_kern == ATTACK_KERN_COMBI)
1623 snprintf (cached_file, 255, "%s/kernels/%d/m%05d_a1.%s.kernel", profile_dir, vendor_id, (int) kern_type, device_name_chksum);
1624 else if (attack_kern == ATTACK_KERN_BF)
1625 snprintf (cached_file, 255, "%s/kernels/%d/m%05d_a3.%s.kernel", profile_dir, vendor_id, (int) kern_type, device_name_chksum);
1626 }
1627 else
1628 {
1629 snprintf (cached_file, 255, "%s/kernels/%d/m%05d.%s.kernel", profile_dir, vendor_id, (int) kern_type, device_name_chksum);
1630 }
1631 }
1632
1633 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1634 {
1635 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1636 {
1637 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1638 }
1639 else
1640 {
1641 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1642 }
1643 }
1644
1645 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, char *device_name_chksum, int vendor_id, char *cached_file)
1646 {
1647 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1648 {
1649 snprintf (cached_file, 255, "%s/kernels/%d/markov_be.%s.kernel", profile_dir, vendor_id, device_name_chksum);
1650 }
1651 else
1652 {
1653 snprintf (cached_file, 255, "%s/kernels/%d/markov_le.%s.kernel", profile_dir, vendor_id, device_name_chksum);
1654 }
1655 }
1656
1657 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1658 {
1659 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1660 }
1661
1662 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, char *device_name_chksum, int vendor_id, char *cached_file)
1663 {
1664 snprintf (cached_file, 255, "%s/kernels/%d/amp_a%d.%s.kernel", profile_dir, vendor_id, attack_kern, device_name_chksum);
1665 }
1666
1667 static uint convert_from_hex (char *line_buf, const uint line_len)
1668 {
1669 if (line_len & 1) return (line_len); // not in hex
1670
1671 if (data.hex_wordlist == 1)
1672 {
1673 uint i;
1674 uint j;
1675
1676 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1677 {
1678 line_buf[i] = hex_to_char (&line_buf[j]);
1679 }
1680
1681 memset (line_buf + i, 0, line_len - i);
1682
1683 return (i);
1684 }
1685 else if (line_len >= 6) // $HEX[] = 6
1686 {
1687 if (line_buf[0] != '$') return (line_len);
1688 if (line_buf[1] != 'H') return (line_len);
1689 if (line_buf[2] != 'E') return (line_len);
1690 if (line_buf[3] != 'X') return (line_len);
1691 if (line_buf[4] != '[') return (line_len);
1692 if (line_buf[line_len - 1] != ']') return (line_len);
1693
1694 uint i;
1695 uint j;
1696
1697 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1698 {
1699 line_buf[i] = hex_to_char (&line_buf[j]);
1700 }
1701
1702 memset (line_buf + i, 0, line_len - i);
1703
1704 return (i);
1705 }
1706
1707 return (line_len);
1708 }
1709
1710 static uint count_lines (FILE *fd)
1711 {
1712 uint cnt = 0;
1713
1714 char *buf = (char *) mymalloc (BUFSIZ);
1715
1716 size_t nread_tmp = 0;
1717
1718 char *ptr = buf;
1719
1720 while (!feof (fd))
1721 {
1722 size_t nread = fread (buf, sizeof (char), BUFSIZ, fd);
1723 nread_tmp = nread;
1724
1725 if (nread < 1) continue;
1726
1727 ptr = buf;
1728
1729 do
1730 {
1731 if (*ptr++ == '\n') cnt++;
1732
1733 } while (nread--);
1734 }
1735
1736 // special case (if last line did not contain a newline char ... at the very end of the file)
1737
1738 if (nread_tmp > 3)
1739 {
1740 ptr -= 2;
1741
1742 if (*ptr != '\n')
1743 {
1744 ptr--;
1745
1746 if (*ptr != '\n') // needed ? different on windows systems?
1747 {
1748 cnt++;
1749 }
1750 }
1751 }
1752
1753 myfree (buf);
1754
1755 return cnt;
1756 }
1757
1758 static void clear_prompt ()
1759 {
1760 fputc ('\r', stdout);
1761
1762 for (size_t i = 0; i < strlen (PROMPT); i++)
1763 {
1764 fputc (' ', stdout);
1765 }
1766
1767 fputc ('\r', stdout);
1768
1769 fflush (stdout);
1770 }
1771
1772 static void gidd_to_pw_t (hc_device_param_t *device_param, const uint64_t gidd, pw_t *pw)
1773 {
1774 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1775 }
1776
1777 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1778 {
1779 char *outfile = data.outfile;
1780 uint quiet = data.quiet;
1781 FILE *pot_fp = data.pot_fp;
1782 uint loopback = data.loopback;
1783 uint debug_mode = data.debug_mode;
1784 char *debug_file = data.debug_file;
1785
1786 char debug_rule_buf[BLOCK_SIZE];
1787 int debug_rule_len = 0; // -1 error
1788 uint debug_plain_len = 0;
1789
1790 unsigned char debug_plain_ptr[BLOCK_SIZE];
1791
1792 // hash
1793
1794 char out_buf[4096]; memset (out_buf, 0, sizeof (out_buf));
1795
1796 ascii_digest (out_buf, salt_pos, digest_pos);
1797
1798 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1799
1800 // plain
1801
1802 plain_t plain;
1803
1804 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, idx * sizeof (plain_t), sizeof (plain_t), &plain, 0, NULL, NULL);
1805
1806 uint gidvid = plain.gidvid;
1807 uint il_pos = plain.il_pos;
1808
1809 uint64_t crackpos = device_param->words_off;
1810
1811 uint plain_buf[16];
1812
1813 unsigned char *plain_ptr = (unsigned char *) plain_buf;
1814 unsigned int plain_len = 0;
1815
1816 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1817 {
1818 uint64_t gidd = gidvid;
1819 uint64_t gidm = 0;
1820
1821 pw_t pw;
1822
1823 gidd_to_pw_t (device_param, gidd, &pw);
1824
1825 for (int i = 0, j = gidm; i < 16; i++, j++)
1826 {
1827 plain_buf[i] = pw.hi1[0][j];
1828 }
1829
1830 plain_len = pw.pw_len;
1831
1832 const uint off = device_param->innerloop_pos + il_pos;
1833
1834 if (debug_mode > 0)
1835 {
1836 debug_rule_len = 0;
1837
1838 // save rule
1839 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1840 {
1841 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1842
1843 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1844 }
1845
1846 // save plain
1847 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1848 {
1849 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1850
1851 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1852
1853 debug_plain_len = plain_len;
1854 }
1855 }
1856
1857 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1858
1859 crackpos += gidvid;
1860 crackpos *= data.kernel_rules_cnt;
1861 crackpos += device_param->innerloop_pos + il_pos;
1862
1863 if (plain_len > data.pw_max) plain_len = data.pw_max;
1864 }
1865 else if (data.attack_mode == ATTACK_MODE_COMBI)
1866 {
1867 uint64_t gidd = gidvid;
1868 uint64_t gidm = 0;
1869
1870 pw_t pw;
1871
1872 gidd_to_pw_t (device_param, gidd, &pw);
1873
1874 for (int i = 0, j = gidm; i < 16; i++, j++)
1875 {
1876 plain_buf[i] = pw.hi1[0][j];
1877 }
1878
1879 plain_len = pw.pw_len;
1880
1881 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1882 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1883
1884 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1885 {
1886 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1887 }
1888 else
1889 {
1890 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1891
1892 memcpy (plain_ptr, comb_buf, comb_len);
1893 }
1894
1895 plain_len += comb_len;
1896
1897 crackpos += gidvid;
1898 crackpos *= data.combs_cnt;
1899 crackpos += device_param->innerloop_pos + il_pos;
1900
1901 if (data.pw_max != PW_DICTMAX1)
1902 {
1903 if (plain_len > data.pw_max) plain_len = data.pw_max;
1904 }
1905 }
1906 else if (data.attack_mode == ATTACK_MODE_BF)
1907 {
1908 uint64_t l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1909 uint64_t r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1910
1911 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1912 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1913
1914 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1915 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1916
1917 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1918 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1919
1920 plain_len = data.css_cnt;
1921
1922 crackpos += gidvid;
1923 crackpos *= data.bfs_cnt;
1924 crackpos += device_param->innerloop_pos + il_pos;
1925 }
1926 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1927 {
1928 uint64_t gidd = gidvid;
1929 uint64_t gidm = 0;
1930
1931 pw_t pw;
1932
1933 gidd_to_pw_t (device_param, gidd, &pw);
1934
1935 for (int i = 0, j = gidm; i < 16; i++, j++)
1936 {
1937 plain_buf[i] = pw.hi1[0][j];
1938 }
1939
1940 plain_len = pw.pw_len;
1941
1942 uint64_t off = device_param->kernel_params_mp_buf64[3] + il_pos;
1943
1944 uint start = 0;
1945 uint stop = device_param->kernel_params_mp_buf32[4];
1946
1947 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
1948
1949 plain_len += start + stop;
1950
1951 crackpos += gidvid;
1952 crackpos *= data.combs_cnt;
1953 crackpos += device_param->innerloop_pos + il_pos;
1954
1955 if (data.pw_max != PW_DICTMAX1)
1956 {
1957 if (plain_len > data.pw_max) plain_len = data.pw_max;
1958 }
1959 }
1960 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1961 {
1962 uint64_t gidd = gidvid;
1963 uint64_t gidm = 0;
1964
1965 pw_t pw;
1966
1967 gidd_to_pw_t (device_param, gidd, &pw);
1968
1969 for (int i = 0, j = gidm; i < 16; i++, j++)
1970 {
1971 plain_buf[i] = pw.hi1[0][j];
1972 }
1973
1974 plain_len = pw.pw_len;
1975
1976 uint64_t off = device_param->kernel_params_mp_buf64[3] + il_pos;
1977
1978 uint start = 0;
1979 uint stop = device_param->kernel_params_mp_buf32[4];
1980
1981 memmove (plain_ptr + stop, plain_ptr, plain_len);
1982
1983 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
1984
1985 plain_len += start + stop;
1986
1987 crackpos += gidvid;
1988 crackpos *= data.combs_cnt;
1989 crackpos += device_param->innerloop_pos + il_pos;
1990
1991 if (data.pw_max != PW_DICTMAX1)
1992 {
1993 if (plain_len > data.pw_max) plain_len = data.pw_max;
1994 }
1995 }
1996
1997 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
1998 {
1999 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2000 {
2001 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2002 {
2003 plain_len = plain_len - data.salts_buf[0].salt_len;
2004 }
2005 }
2006
2007 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2008 {
2009 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2010 {
2011 plain_ptr[j] = plain_ptr[i];
2012 }
2013
2014 plain_len = plain_len / 2;
2015 }
2016 }
2017
2018 // if enabled, update also the potfile
2019
2020 if (pot_fp)
2021 {
2022 fprintf (pot_fp, "%s:", out_buf);
2023
2024 format_plain (pot_fp, plain_ptr, plain_len, 1);
2025
2026 fputc ('\n', pot_fp);
2027
2028 fflush (pot_fp);
2029 }
2030
2031 // outfile
2032
2033 FILE *out_fp = NULL;
2034
2035 if (outfile != NULL)
2036 {
2037 if ((out_fp = fopen (outfile, "ab")) == NULL)
2038 {
2039 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2040
2041 out_fp = stdout;
2042 }
2043 }
2044 else
2045 {
2046 out_fp = stdout;
2047
2048 if (quiet == 0) clear_prompt ();
2049 }
2050
2051 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2052
2053 if (outfile != NULL)
2054 {
2055 if (out_fp != stdout)
2056 {
2057 fclose (out_fp);
2058 }
2059 }
2060 else
2061 {
2062 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2063 {
2064 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2065 {
2066 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2067 if (quiet == 0) fflush (stdout);
2068 }
2069 }
2070 }
2071
2072 // loopback
2073
2074 if (loopback)
2075 {
2076 char *loopback_file = data.loopback_file;
2077
2078 FILE *fb_fp = NULL;
2079
2080 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2081 {
2082 format_plain (fb_fp, plain_ptr, plain_len, 1);
2083
2084 fputc ('\n', fb_fp);
2085
2086 fclose (fb_fp);
2087 }
2088 }
2089
2090 // (rule) debug mode
2091
2092 // the next check implies that:
2093 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2094 // - debug_mode > 0
2095
2096 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2097 {
2098 if (debug_rule_len < 0) debug_rule_len = 0;
2099
2100 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2101
2102 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2103
2104 if ((quiet == 0) && (debug_file == NULL))
2105 {
2106 fprintf (stdout, "%s", PROMPT);
2107 fflush (stdout);
2108 }
2109 }
2110 }
2111
2112 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2113 {
2114 salt_t *salt_buf = &data.salts_buf[salt_pos];
2115
2116 int found = 0;
2117
2118 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2119
2120 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2121
2122 if (found == 1)
2123 {
2124 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2125
2126 log_info_nn ("");
2127
2128 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);
2129
2130 uint cpt_cracked = 0;
2131
2132 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2133 {
2134 uint idx = salt_buf->digests_offset + digest_pos;
2135
2136 if (data.digests_shown_tmp[idx] == 0) continue;
2137
2138 if (data.digests_shown[idx] == 1) continue;
2139
2140 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2141 {
2142 data.digests_shown[idx] = 1;
2143
2144 data.digests_done++;
2145
2146 cpt_cracked++;
2147
2148 salt_buf->digests_done++;
2149
2150 if (salt_buf->digests_done == salt_buf->digests_cnt)
2151 {
2152 data.salts_shown[salt_pos] = 1;
2153
2154 data.salts_done++;
2155 }
2156 }
2157
2158 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2159
2160 check_hash (device_param, salt_pos, digest_pos);
2161 }
2162
2163 if (cpt_cracked > 0)
2164 {
2165 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2166 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2167
2168 data.cpt_pos++;
2169
2170 data.cpt_total += cpt_cracked;
2171
2172 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2173 }
2174
2175 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2176 {
2177 // we need to reset cracked state on the device
2178 // otherwise host thinks again and again the hash was cracked
2179 // and returns invalid password each time
2180
2181 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2182
2183 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);
2184 }
2185
2186 memset (device_param->result, 0, device_param->size_results);
2187
2188 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2189 }
2190 }
2191
2192 static void save_hash ()
2193 {
2194 char *hashfile = data.hashfile;
2195
2196 char new_hashfile[256];
2197 char old_hashfile[256];
2198
2199 memset (new_hashfile, 0, sizeof (new_hashfile));
2200 memset (old_hashfile, 0, sizeof (old_hashfile));
2201
2202 snprintf (new_hashfile, 255, "%s.new", hashfile);
2203 snprintf (old_hashfile, 255, "%s.old", hashfile);
2204
2205 unlink (new_hashfile);
2206
2207 char separator = data.separator;
2208
2209 FILE *fp = fopen (new_hashfile, "wb");
2210
2211 if (fp == NULL)
2212 {
2213 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2214
2215 exit (-1);
2216 }
2217
2218 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2219 {
2220 if (data.salts_shown[salt_pos] == 1) continue;
2221
2222 salt_t *salt_buf = &data.salts_buf[salt_pos];
2223
2224 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2225 {
2226 uint idx = salt_buf->digests_offset + digest_pos;
2227
2228 if (data.digests_shown[idx] == 1) continue;
2229
2230 if (data.hash_mode != 2500)
2231 {
2232 char out_buf[4096];
2233
2234 memset (out_buf, 0, sizeof (out_buf));
2235
2236 if (data.username == 1)
2237 {
2238 user_t *user = data.hash_info[idx]->user;
2239
2240 uint i;
2241
2242 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2243
2244 fputc (separator, fp);
2245 }
2246
2247 ascii_digest (out_buf, salt_pos, digest_pos);
2248
2249 fputs (out_buf, fp);
2250
2251 log_out (fp, "");
2252 }
2253 else
2254 {
2255 hccap_t hccap;
2256
2257 to_hccap_t (&hccap, salt_pos, digest_pos);
2258
2259 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2260 }
2261 }
2262 }
2263
2264 fflush (fp);
2265
2266 fclose (fp);
2267
2268 unlink (old_hashfile);
2269
2270 if (rename (hashfile, old_hashfile) != 0)
2271 {
2272 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2273
2274 exit (-1);
2275 }
2276
2277 unlink (hashfile);
2278
2279 if (rename (new_hashfile, hashfile) != 0)
2280 {
2281 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2282
2283 exit (-1);
2284 }
2285
2286 unlink (old_hashfile);
2287 }
2288
2289 static float find_kernel_blocks_div (const uint64_t total_left, const uint kernel_blocks_all)
2290 {
2291 // function called only in case kernel_blocks_all > words_left)
2292
2293 float kernel_blocks_div = (float) (total_left) / kernel_blocks_all;
2294
2295 kernel_blocks_div += kernel_blocks_div / 100;
2296
2297 uint32_t kernel_blocks_new = (uint32_t) (kernel_blocks_all * kernel_blocks_div);
2298
2299 while (kernel_blocks_new < total_left)
2300 {
2301 kernel_blocks_div += kernel_blocks_div / 100;
2302
2303 kernel_blocks_new = (uint32_t) (kernel_blocks_all * kernel_blocks_div);
2304 }
2305
2306 if (data.quiet == 0)
2307 {
2308 clear_prompt ();
2309
2310 log_info ("");
2311
2312 log_info ("INFO: approaching final keyspace, workload adjusted");
2313
2314 log_info ("");
2315
2316 fprintf (stdout, "%s", PROMPT);
2317
2318 fflush (stdout);
2319 }
2320
2321 if ((kernel_blocks_all * kernel_blocks_div) < 8) return 1;
2322
2323 return kernel_blocks_div;
2324 }
2325
2326 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num)
2327 {
2328 uint num_elements = num;
2329
2330 device_param->kernel_params_buf32[30] = data.combs_mode;
2331 device_param->kernel_params_buf32[31] = num;
2332
2333 uint kernel_threads = device_param->kernel_threads;
2334
2335 while (num_elements % kernel_threads) num_elements++;
2336
2337 cl_kernel kernel = NULL;
2338
2339 switch (kern_run)
2340 {
2341 case KERN_RUN_1: kernel = device_param->kernel1; break;
2342 case KERN_RUN_12: kernel = device_param->kernel12; break;
2343 case KERN_RUN_2: kernel = device_param->kernel2; break;
2344 case KERN_RUN_23: kernel = device_param->kernel23; break;
2345 case KERN_RUN_3: kernel = device_param->kernel3; break;
2346 }
2347
2348 hc_clSetKernelArg (kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2349 hc_clSetKernelArg (kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2350 hc_clSetKernelArg (kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2351 hc_clSetKernelArg (kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2352 hc_clSetKernelArg (kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2353 hc_clSetKernelArg (kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2354 hc_clSetKernelArg (kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2355 hc_clSetKernelArg (kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2356 hc_clSetKernelArg (kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2357 hc_clSetKernelArg (kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2358 hc_clSetKernelArg (kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2359
2360 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2361 {
2362 const size_t global_work_size[3] = { num_elements, 32, 1 };
2363 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2364
2365 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2366 }
2367 else
2368 {
2369 const size_t global_work_size[3] = { num_elements, 1, 1 };
2370 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2371
2372 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2373 }
2374
2375 hc_clFlush (device_param->command_queue);
2376
2377 hc_clFinish (device_param->command_queue);
2378 }
2379
2380 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2381 {
2382 uint num_elements = num;
2383
2384 switch (kern_run)
2385 {
2386 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2387 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2388 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2389 }
2390
2391 // causes problems with special threads like in bcrypt
2392 // const uint kernel_threads = device_param->kernel_threads;
2393
2394 const uint kernel_threads = KERNEL_THREADS;
2395
2396 while (num_elements % kernel_threads) num_elements++;
2397
2398 cl_kernel kernel = NULL;
2399
2400 switch (kern_run)
2401 {
2402 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2403 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2404 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2405 }
2406
2407 switch (kern_run)
2408 {
2409 case KERN_RUN_MP: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2410 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2411 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2412 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2413 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2414 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2415 break;
2416 case KERN_RUN_MP_R: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2417 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2418 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2419 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2420 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2421 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2422 break;
2423 case KERN_RUN_MP_L: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2424 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2425 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2426 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2427 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2428 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2429 hc_clSetKernelArg (kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2430 break;
2431 }
2432
2433 const size_t global_work_size[3] = { num_elements, 1, 1 };
2434 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2435
2436 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2437
2438 hc_clFlush (device_param->command_queue);
2439
2440 hc_clFinish (device_param->command_queue);
2441 }
2442
2443 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2444 {
2445 uint num_elements = num;
2446
2447 uint kernel_threads = device_param->kernel_threads;
2448
2449 while (num_elements % kernel_threads) num_elements++;
2450
2451 cl_kernel kernel = device_param->kernel_tb;
2452
2453 const size_t global_work_size[3] = { num_elements, 1, 1 };
2454 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2455
2456 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2457
2458 hc_clFlush (device_param->command_queue);
2459
2460 hc_clFinish (device_param->command_queue);
2461 }
2462
2463 static void run_kernel_tm (hc_device_param_t *device_param)
2464 {
2465 const uint num_elements = 1024; // fixed
2466
2467 const uint kernel_threads = 32;
2468
2469 cl_kernel kernel = device_param->kernel_tm;
2470
2471 const size_t global_work_size[3] = { num_elements, 1, 1 };
2472 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2473
2474 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2475
2476 hc_clFlush (device_param->command_queue);
2477
2478 hc_clFinish (device_param->command_queue);
2479 }
2480
2481 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2482 {
2483 uint num_elements = num;
2484
2485 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2486 device_param->kernel_params_amp_buf32[6] = num_elements;
2487
2488 // causes problems with special threads like in bcrypt
2489 // const uint kernel_threads = device_param->kernel_threads;
2490
2491 const uint kernel_threads = KERNEL_THREADS;
2492
2493 while (num_elements % kernel_threads) num_elements++;
2494
2495 cl_kernel kernel = device_param->kernel_amp;
2496
2497 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2498 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2499
2500 const size_t global_work_size[3] = { num_elements, 1, 1 };
2501 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2502
2503 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2504
2505 hc_clFlush (device_param->command_queue);
2506
2507 hc_clFinish (device_param->command_queue);
2508 }
2509
2510 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2511 {
2512 if (data.vendor_id == VENDOR_ID_AMD)
2513 {
2514 const cl_uchar zero = 0;
2515
2516 hc_clEnqueueFillBuffer (device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2517 }
2518
2519 if (data.vendor_id == VENDOR_ID_NV)
2520 {
2521 // NOTE: clEnqueueFillBuffer () always fails with -59
2522 // IOW, it's not supported by Nvidia ForceWare <= 352.21,
2523 // How's that possible, OpenCL 1.2 support is advertised??
2524 // We need to workaround...
2525
2526 #define FILLSZ 0x100000
2527
2528 char *tmp = (char *) mymalloc (FILLSZ);
2529
2530 memset (tmp, 0, FILLSZ);
2531
2532 for (uint i = 0; i < size; i += FILLSZ)
2533 {
2534 const int left = size - i;
2535
2536 const int fillsz = MIN (FILLSZ, left);
2537
2538 hc_clEnqueueWriteBuffer (device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2539 }
2540
2541 myfree (tmp);
2542 }
2543
2544 if (data.vendor_id == VENDOR_ID_GENERIC)
2545 {
2546 const cl_uchar zero = 0;
2547
2548 hc_clEnqueueFillBuffer (device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2549 }
2550 }
2551
2552 static int run_rule_engine (const int rule_len, const char *rule_buf)
2553 {
2554 if (rule_len == 0)
2555 {
2556 return 0;
2557 }
2558 else if (rule_len == 1)
2559 {
2560 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2561 }
2562
2563 return 1;
2564 }
2565
2566 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2567 {
2568 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2569 {
2570 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);
2571 }
2572 else if (data.attack_kern == ATTACK_KERN_COMBI)
2573 {
2574 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2575 }
2576 else if (data.attack_kern == ATTACK_KERN_BF)
2577 {
2578 const uint64_t off = device_param->words_off;
2579
2580 device_param->kernel_params_mp_l_buf64[3] = off;
2581
2582 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2583 }
2584 }
2585
2586 static void run_cracker (hc_device_param_t *device_param, const uint pw_cnt, const uint pws_cnt)
2587 {
2588 const uint kernel_loops = data.kernel_loops;
2589
2590 // init speed timer
2591
2592 uint speed_pos = device_param->speed_pos;
2593
2594 #ifdef _POSIX
2595 if (device_param->timer_speed.tv_sec == 0)
2596 {
2597 hc_timer_set (&device_param->timer_speed);
2598 }
2599 #endif
2600
2601 #ifdef _WIN
2602 if (device_param->timer_speed.QuadPart == 0)
2603 {
2604 hc_timer_set (&device_param->timer_speed);
2605 }
2606 #endif
2607
2608 // find higest password length, this is for optimization stuff
2609
2610 uint highest_pw_len = 0;
2611
2612 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2613 {
2614 }
2615 else if (data.attack_kern == ATTACK_KERN_COMBI)
2616 {
2617 }
2618 else if (data.attack_kern == ATTACK_KERN_BF)
2619 {
2620 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
2621 + device_param->kernel_params_mp_l_buf32[5];
2622 }
2623
2624 // bitslice optimization stuff
2625
2626 if (data.attack_mode == ATTACK_MODE_BF)
2627 {
2628 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2629 {
2630 run_kernel_tb (device_param, pws_cnt);
2631 }
2632 }
2633
2634 // iteration type
2635
2636 uint innerloop_step = 0;
2637 uint innerloop_cnt = 0;
2638
2639 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = kernel_loops;
2640 else innerloop_step = 1;
2641
2642 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
2643 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
2644 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
2645
2646 // loop start: most outer loop = salt iteration, then innerloops (if multi)
2647
2648 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2649 {
2650 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2651
2652 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2653
2654 if (data.devices_status == STATUS_CRACKED) break;
2655 if (data.devices_status == STATUS_ABORTED) break;
2656 if (data.devices_status == STATUS_QUIT) break;
2657 if (data.devices_status == STATUS_BYPASS) break;
2658
2659 if (data.salts_shown[salt_pos] == 1) continue;
2660
2661 salt_t *salt_buf = &data.salts_buf[salt_pos];
2662
2663 device_param->kernel_params_buf32[24] = salt_pos;
2664 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
2665 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
2666
2667 FILE *combs_fp = device_param->combs_fp;
2668
2669 if (data.attack_mode == ATTACK_MODE_COMBI)
2670 {
2671 rewind (combs_fp);
2672 }
2673
2674 // innerloops
2675
2676 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
2677 {
2678 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2679
2680 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2681
2682 if (data.devices_status == STATUS_CRACKED) break;
2683 if (data.devices_status == STATUS_ABORTED) break;
2684 if (data.devices_status == STATUS_QUIT) break;
2685 if (data.devices_status == STATUS_BYPASS) break;
2686
2687 uint innerloop_left = innerloop_cnt - innerloop_pos;
2688
2689 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
2690
2691 device_param->innerloop_pos = innerloop_pos;
2692 device_param->innerloop_left = innerloop_left;
2693
2694 device_param->kernel_params_buf32[27] = innerloop_left;
2695
2696 if (innerloop_left == 0) continue;
2697
2698 // initialize amplifiers
2699
2700 if (data.attack_mode == ATTACK_MODE_COMBI)
2701 {
2702 char line_buf[BUFSIZ];
2703
2704 uint i = 0;
2705
2706 while (i < innerloop_left)
2707 {
2708 if (feof (combs_fp)) break;
2709
2710 int line_len = fgetl (combs_fp, line_buf);
2711
2712 if (line_len >= PW_MAX1) continue;
2713
2714 line_len = convert_from_hex (line_buf, line_len);
2715
2716 char *line_buf_new = line_buf;
2717
2718 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
2719 {
2720 char rule_buf_out[BLOCK_SIZE];
2721
2722 memset (rule_buf_out, 0, sizeof (rule_buf_out));
2723
2724 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
2725
2726 if (rule_len_out < 0)
2727 {
2728 data.words_progress_rejected[salt_pos] += pw_cnt;
2729
2730 continue;
2731 }
2732
2733 line_len = rule_len_out;
2734
2735 line_buf_new = rule_buf_out;
2736 }
2737
2738 line_len = MIN (line_len, PW_DICTMAX);
2739
2740 char *ptr = (char *) device_param->combs_buf[i].i;
2741
2742 memcpy (ptr, line_buf_new, line_len);
2743
2744 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
2745
2746 if (data.opts_type & OPTS_TYPE_PT_UPPER)
2747 {
2748 uppercase (ptr, line_len);
2749 }
2750
2751 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2752 {
2753 if (data.opts_type & OPTS_TYPE_PT_ADD80)
2754 {
2755 ptr[line_len] = 0x80;
2756 }
2757
2758 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2759 {
2760 ptr[line_len] = 0x01;
2761 }
2762 }
2763
2764 device_param->combs_buf[i].pw_len = line_len;
2765
2766 i++;
2767 }
2768
2769 for (uint j = i; j < innerloop_left; j++)
2770 {
2771 device_param->combs_buf[j].i[0] = 0;
2772 device_param->combs_buf[j].i[1] = 0;
2773 device_param->combs_buf[j].i[2] = 0;
2774 device_param->combs_buf[j].i[3] = 0;
2775 device_param->combs_buf[j].i[4] = 0;
2776 device_param->combs_buf[j].i[5] = 0;
2777 device_param->combs_buf[j].i[6] = 0;
2778 device_param->combs_buf[j].i[7] = 0;
2779
2780 device_param->combs_buf[j].pw_len = 0;
2781 }
2782
2783 innerloop_left = i;
2784 }
2785 else if (data.attack_mode == ATTACK_MODE_BF)
2786 {
2787 uint64_t off = innerloop_pos;
2788
2789 device_param->kernel_params_mp_r_buf64[3] = off;
2790
2791 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
2792 }
2793 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2794 {
2795 uint64_t off = innerloop_pos;
2796
2797 device_param->kernel_params_mp_buf64[3] = off;
2798
2799 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2800 }
2801 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2802 {
2803 uint64_t off = innerloop_pos;
2804
2805 device_param->kernel_params_mp_buf64[3] = off;
2806
2807 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2808 }
2809
2810 // copy amplifiers
2811
2812 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2813 {
2814 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);
2815 }
2816 else if (data.attack_mode == ATTACK_MODE_COMBI)
2817 {
2818 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);
2819 }
2820 else if (data.attack_mode == ATTACK_MODE_BF)
2821 {
2822 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);
2823 }
2824 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2825 {
2826 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);
2827 }
2828 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2829 {
2830 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
2831 }
2832
2833 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2834 {
2835 if (data.attack_mode == ATTACK_MODE_BF)
2836 {
2837 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2838 {
2839 const uint size_tm = 32 * sizeof (bs_word_t);
2840
2841 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2842
2843 run_kernel_tm (device_param);
2844
2845 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2846 }
2847 }
2848
2849 if (highest_pw_len < 16)
2850 {
2851 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2852 }
2853 else if (highest_pw_len < 32)
2854 {
2855 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2856 }
2857 else
2858 {
2859 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2860 }
2861 }
2862 else
2863 {
2864 run_kernel_amp (device_param, pws_cnt);
2865
2866 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2867
2868 if (data.opts_type & OPTS_TYPE_HOOK12)
2869 {
2870 run_kernel (KERN_RUN_12, device_param, pws_cnt);
2871 }
2872
2873 uint iter = salt_buf->salt_iter;
2874
2875 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
2876 {
2877 uint loop_left = iter - loop_pos;
2878
2879 loop_left = MIN (loop_left, kernel_loops);
2880
2881 device_param->kernel_params_buf32[25] = loop_pos;
2882 device_param->kernel_params_buf32[26] = loop_left;
2883
2884 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2885
2886 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2887
2888 if (data.devices_status == STATUS_CRACKED) break;
2889 if (data.devices_status == STATUS_ABORTED) break;
2890 if (data.devices_status == STATUS_QUIT) break;
2891 }
2892
2893 if (data.opts_type & OPTS_TYPE_HOOK23)
2894 {
2895 run_kernel (KERN_RUN_23, device_param, pws_cnt);
2896
2897 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2898
2899 // do something with data
2900
2901 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2902 }
2903
2904 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2905 }
2906
2907 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2908
2909 if (data.devices_status == STATUS_CRACKED) break;
2910 if (data.devices_status == STATUS_ABORTED) break;
2911 if (data.devices_status == STATUS_QUIT) break;
2912
2913 /**
2914 * result
2915 */
2916
2917 hc_thread_mutex_lock (mux_display);
2918
2919 check_cracked (device_param, salt_pos);
2920
2921 hc_thread_mutex_unlock (mux_display);
2922
2923 /**
2924 * progress
2925 */
2926
2927 uint64_t perf_sum_all = (uint64_t) pw_cnt * (uint64_t) innerloop_left;
2928
2929 hc_thread_mutex_lock (mux_counter);
2930
2931 data.words_progress_done[salt_pos] += perf_sum_all;
2932
2933 hc_thread_mutex_unlock (mux_counter);
2934
2935 /**
2936 * speed
2937 */
2938
2939 float speed_ms;
2940
2941 hc_timer_get (device_param->timer_speed, speed_ms);
2942
2943 hc_timer_set (&device_param->timer_speed);
2944
2945 hc_thread_mutex_lock (mux_display);
2946
2947 device_param->speed_cnt[speed_pos] = perf_sum_all;
2948
2949 device_param->speed_ms[speed_pos] = speed_ms;
2950
2951 device_param->speed_rec[speed_pos] = device_param->timer_speed;
2952
2953 hc_thread_mutex_unlock (mux_display);
2954
2955 speed_pos++;
2956
2957 if (speed_pos == SPEED_CACHE)
2958 {
2959 speed_pos = 0;
2960 }
2961 }
2962 }
2963
2964 device_param->speed_pos = speed_pos;
2965 }
2966
2967 static void load_segment (wl_data_t *wl_data, FILE *fd)
2968 {
2969 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
2970
2971 wl_data->pos = 0;
2972
2973 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
2974
2975 wl_data->buf[wl_data->cnt] = 0;
2976
2977 if (wl_data->cnt == 0) return;
2978
2979 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
2980
2981 while (!feof (fd))
2982 {
2983 if (wl_data->cnt == wl_data->avail)
2984 {
2985 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
2986
2987 wl_data->avail += wl_data->incr;
2988 }
2989
2990 const int c = fgetc (fd);
2991
2992 if (c == EOF) break;
2993
2994 wl_data->buf[wl_data->cnt] = (char) c;
2995
2996 wl_data->cnt++;
2997
2998 if (c == '\n') break;
2999 }
3000
3001 // ensure stream ends with a newline
3002
3003 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3004 {
3005 wl_data->cnt++;
3006
3007 wl_data->buf[wl_data->cnt - 1] = '\n';
3008 }
3009
3010 return;
3011 }
3012
3013 static void get_next_word_lm (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
3014 {
3015 char *ptr = buf;
3016
3017 for (uint32_t i = 0; i < sz; i++, ptr++)
3018 {
3019 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3020
3021 if (i == 7)
3022 {
3023 *off = i;
3024 *len = i;
3025
3026 return;
3027 }
3028
3029 if (*ptr != '\n') continue;
3030
3031 *off = i + 1;
3032
3033 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3034
3035 *len = i;
3036
3037 return;
3038 }
3039
3040 *off = sz;
3041 *len = sz;
3042 }
3043
3044 static void get_next_word_uc (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
3045 {
3046 char *ptr = buf;
3047
3048 for (uint32_t i = 0; i < sz; i++, ptr++)
3049 {
3050 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3051
3052 if (*ptr != '\n') continue;
3053
3054 *off = i + 1;
3055
3056 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3057
3058 *len = i;
3059
3060 return;
3061 }
3062
3063 *off = sz;
3064 *len = sz;
3065 }
3066
3067 static void get_next_word_std (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
3068 {
3069 char *ptr = buf;
3070
3071 for (uint32_t i = 0; i < sz; i++, ptr++)
3072 {
3073 if (*ptr != '\n') continue;
3074
3075 *off = i + 1;
3076
3077 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3078
3079 *len = i;
3080
3081 return;
3082 }
3083
3084 *off = sz;
3085 *len = sz;
3086 }
3087
3088 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3089 {
3090 while (wl_data->pos < wl_data->cnt)
3091 {
3092 uint off;
3093 uint len;
3094
3095 char *ptr = wl_data->buf + wl_data->pos;
3096
3097 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3098
3099 wl_data->pos += off;
3100
3101 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3102 {
3103 char rule_buf_out[BLOCK_SIZE];
3104
3105 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3106
3107 int rule_len_out = -1;
3108
3109 if (len < BLOCK_SIZE)
3110 {
3111 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3112 }
3113
3114 if (rule_len_out < 0)
3115 {
3116 continue;
3117 }
3118
3119 if (rule_len_out > PW_MAX)
3120 {
3121 continue;
3122 }
3123 }
3124 else
3125 {
3126 if (len > PW_MAX)
3127 {
3128 continue;
3129 }
3130 }
3131
3132 *out_buf = ptr;
3133 *out_len = len;
3134
3135 return;
3136 }
3137
3138 if (feof (fd))
3139 {
3140 fprintf (stderr, "bug!!\n");
3141
3142 return;
3143 }
3144
3145 load_segment (wl_data, fd);
3146
3147 get_next_word (wl_data, fd, out_buf, out_len);
3148 }
3149
3150 #ifdef _POSIX
3151 static uint64_t count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3152 #endif
3153
3154 #ifdef _WIN
3155 static uint64_t count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3156 #endif
3157 {
3158 hc_signal (NULL);
3159
3160 dictstat_t d;
3161
3162 d.cnt = 0;
3163
3164 #ifdef _POSIX
3165 fstat (fileno (fd), &d.stat);
3166 #endif
3167
3168 #ifdef _WIN
3169 _fstat64 (fileno (fd), &d.stat);
3170 #endif
3171
3172 d.stat.st_mode = 0;
3173 d.stat.st_nlink = 0;
3174 d.stat.st_uid = 0;
3175 d.stat.st_gid = 0;
3176 d.stat.st_rdev = 0;
3177 d.stat.st_atime = 0;
3178
3179 #ifdef _POSIX
3180 d.stat.st_blksize = 0;
3181 d.stat.st_blocks = 0;
3182 #endif
3183
3184 if (d.stat.st_size == 0) return 0;
3185
3186 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3187
3188 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3189 {
3190 if (d_cache)
3191 {
3192 uint64_t cnt = d_cache->cnt;
3193
3194 uint64_t keyspace = cnt;
3195
3196 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3197 {
3198 keyspace *= data.kernel_rules_cnt;
3199 }
3200 else if (data.attack_kern == ATTACK_KERN_COMBI)
3201 {
3202 keyspace *= data.combs_cnt;
3203 }
3204
3205 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);
3206 if (data.quiet == 0) log_info ("");
3207
3208 hc_signal (sigHandler_default);
3209
3210 return (keyspace);
3211 }
3212 }
3213
3214 time_t now = 0;
3215 time_t prev = 0;
3216
3217 uint64_t comp = 0;
3218 uint64_t cnt = 0;
3219 uint64_t cnt2 = 0;
3220
3221 while (!feof (fd))
3222 {
3223 load_segment (wl_data, fd);
3224
3225 comp += wl_data->cnt;
3226
3227 uint32_t i = 0;
3228
3229 while (i < wl_data->cnt)
3230 {
3231 uint32_t len;
3232 uint32_t off;
3233
3234 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3235
3236 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3237 {
3238 char rule_buf_out[BLOCK_SIZE];
3239
3240 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3241
3242 int rule_len_out = -1;
3243
3244 if (len < BLOCK_SIZE)
3245 {
3246 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3247 }
3248
3249 if (rule_len_out < 0)
3250 {
3251 len = PW_MAX1;
3252 }
3253 else
3254 {
3255 len = rule_len_out;
3256 }
3257 }
3258
3259 if (len < PW_MAX1)
3260 {
3261 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3262 {
3263 cnt += data.kernel_rules_cnt;
3264 }
3265 else if (data.attack_kern == ATTACK_KERN_COMBI)
3266 {
3267 cnt += data.combs_cnt;
3268 }
3269
3270 d.cnt++;
3271 }
3272
3273 i += off;
3274
3275 cnt2++;
3276 }
3277
3278 time (&now);
3279
3280 if ((now - prev) == 0) continue;
3281
3282 float percent = (float) comp / (float) d.stat.st_size;
3283
3284 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);
3285
3286 time (&prev);
3287 }
3288
3289 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);
3290 if (data.quiet == 0) log_info ("");
3291
3292 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3293
3294 hc_signal (sigHandler_default);
3295
3296 return (cnt);
3297 }
3298
3299 static void pw_transpose_to_hi1 (const pw_t *p1, pw_t *p2)
3300 {
3301 memcpy (p2->hi1, p1->hi1, 64 * sizeof (uint));
3302 }
3303
3304 static uint pw_add_to_hc1 (hc_device_param_t *device_param, const uint8_t *pw_buf, const uint pw_len)
3305 {
3306 if (data.devices_status == STATUS_BYPASS) return 0;
3307
3308 pw_cache_t *pw_cache = device_param->pw_caches + pw_len;
3309
3310 uint cache_cnt = pw_cache->cnt;
3311
3312 uint8_t *pw_hc1 = pw_cache->pw_buf.hc1[cache_cnt];
3313
3314 memcpy (pw_hc1, pw_buf, pw_len);
3315
3316 memset (pw_hc1 + pw_len, 0, 256 - pw_len);
3317
3318 uint pws_cnt = device_param->pws_cnt;
3319
3320 cache_cnt++;
3321
3322 pw_t *pw = device_param->pws_buf + pws_cnt;
3323
3324 device_param->pw_transpose (&pw_cache->pw_buf, pw);
3325
3326 pw->pw_len = pw_len;
3327
3328 pws_cnt++;
3329
3330 device_param->pws_cnt = pws_cnt;
3331 device_param->pw_cnt = pws_cnt * 1;
3332
3333 cache_cnt = 0;
3334
3335 pw_cache->cnt = cache_cnt;
3336
3337 return pws_cnt;
3338 }
3339
3340 static void *thread_monitor (void *p)
3341 {
3342 uint runtime_check = 0;
3343 uint remove_check = 0;
3344 uint status_check = 0;
3345 uint hwmon_check = 0;
3346 uint restore_check = 0;
3347
3348 uint restore_left = data.restore_timer;
3349 uint remove_left = data.remove_timer;
3350 uint status_left = data.status_timer;
3351
3352 // these variables are mainly used for fan control (AMD only)
3353
3354 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3355
3356 // temperature controller "loopback" values
3357
3358 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3359 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3360
3361 int temp_threshold = 1; // degrees celcius
3362
3363 int fan_speed_min = 15; // in percentage
3364 int fan_speed_max = 100;
3365
3366 time_t last_temp_check_time;
3367
3368 uint sleep_time = 1;
3369
3370 if (data.runtime)
3371 {
3372 runtime_check = 1;
3373 }
3374
3375 if (data.restore_timer)
3376 {
3377 restore_check = 1;
3378 }
3379
3380 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3381 {
3382 remove_check = 1;
3383 }
3384
3385 if (data.status == 1)
3386 {
3387 status_check = 1;
3388 }
3389
3390 if (data.gpu_temp_disable == 0)
3391 {
3392 time (&last_temp_check_time);
3393
3394 hwmon_check = 1;
3395 }
3396
3397 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (hwmon_check == 0) && (restore_check == 0))
3398 {
3399 return (p);
3400 }
3401
3402 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3403 {
3404 hc_sleep (sleep_time);
3405
3406 if (data.devices_status != STATUS_RUNNING) continue;
3407
3408 if (hwmon_check == 1)
3409 {
3410 hc_thread_mutex_lock (mux_adl);
3411
3412 time_t temp_check_time;
3413
3414 time (&temp_check_time);
3415
3416 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3417
3418 if (Ta == 0) Ta = 1;
3419
3420 for (uint i = 0; i < data.devices_cnt; i++)
3421 {
3422 const int temperature = hm_get_temperature_with_device_id (i);
3423
3424 if (temperature > (int) data.gpu_temp_abort)
3425 {
3426 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", i + 1);
3427
3428 if (data.devices_status != STATUS_QUIT) myabort ();
3429
3430 break;
3431 }
3432
3433 const int gpu_temp_retain = data.gpu_temp_retain;
3434
3435 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3436 {
3437 if (data.hm_device[i].fan_supported == 1)
3438 {
3439 int temp_cur = temperature;
3440
3441 int temp_diff_new = gpu_temp_retain - temp_cur;
3442
3443 temp_diff_sum[i] = temp_diff_sum[i] + temp_diff_new;
3444
3445 // calculate Ta value (time difference in seconds between the last check and this check)
3446
3447 last_temp_check_time = temp_check_time;
3448
3449 float Kp = 1.8;
3450 float Ki = 0.005;
3451 float Kd = 6;
3452
3453 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3454
3455 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);
3456
3457 if (abs (fan_diff_required) >= temp_threshold)
3458 {
3459 const int fan_speed_cur = hm_get_fanspeed_with_device_id (i);
3460
3461 int fan_speed_level = fan_speed_cur;
3462
3463 if (fan_speed_chgd[i] == 0) fan_speed_level = temp_cur;
3464
3465 int fan_speed_new = fan_speed_level - fan_diff_required;
3466
3467 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3468 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3469
3470 if (fan_speed_new != fan_speed_cur)
3471 {
3472 int freely_change_fan_speed = (fan_speed_chgd[i] == 1);
3473 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3474
3475 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3476 {
3477 hm_set_fanspeed_with_device_id_amd (i, fan_speed_new);
3478
3479 fan_speed_chgd[i] = 1;
3480 }
3481
3482 temp_diff_old[i] = temp_diff_new;
3483 }
3484 }
3485 }
3486 }
3487 }
3488
3489 hc_thread_mutex_unlock (mux_adl);
3490 }
3491
3492 if (restore_check == 1)
3493 {
3494 restore_left--;
3495
3496 if (restore_left == 0)
3497 {
3498 if (data.restore_disable == 0) cycle_restore ();
3499
3500 restore_left = data.restore_timer;
3501 }
3502 }
3503
3504 if ((runtime_check == 1) && (data.runtime_start > 0))
3505 {
3506 time_t runtime_cur;
3507
3508 time (&runtime_cur);
3509
3510 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3511
3512 if (runtime_left <= 0)
3513 {
3514 if (data.benchmark == 0)
3515 {
3516 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3517 }
3518
3519 if (data.devices_status != STATUS_QUIT) myabort ();
3520 }
3521 }
3522
3523 if (remove_check == 1)
3524 {
3525 remove_left--;
3526
3527 if (remove_left == 0)
3528 {
3529 if (data.digests_saved != data.digests_done)
3530 {
3531 data.digests_saved = data.digests_done;
3532
3533 save_hash ();
3534 }
3535
3536 remove_left = data.remove_timer;
3537 }
3538 }
3539
3540 if (status_check == 1)
3541 {
3542 status_left--;
3543
3544 if (status_left == 0)
3545 {
3546 hc_thread_mutex_lock (mux_display);
3547
3548 if (data.quiet == 0) clear_prompt ();
3549
3550 if (data.quiet == 0) log_info ("");
3551
3552 status_display ();
3553
3554 if (data.quiet == 0) log_info ("");
3555
3556 hc_thread_mutex_unlock (mux_display);
3557
3558 status_left = data.status_timer;
3559 }
3560 }
3561 }
3562
3563 myfree (fan_speed_chgd);
3564
3565 myfree (temp_diff_old);
3566 myfree (temp_diff_sum);
3567
3568 p = NULL;
3569
3570 return (p);
3571 }
3572
3573 static void *thread_outfile_remove (void *p)
3574 {
3575 // some hash-dependent constants
3576 char *outfile_dir = data.outfile_check_directory;
3577 uint dgst_size = data.dgst_size;
3578 uint isSalted = data.isSalted;
3579 uint esalt_size = data.esalt_size;
3580 uint hash_mode = data.hash_mode;
3581
3582 uint outfile_check_timer = data.outfile_check_timer;
3583
3584 char separator = data.separator;
3585
3586 // some hash-dependent functions
3587 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3588 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3589
3590 // buffers
3591 hash_t hash_buf;
3592
3593 memset (&hash_buf, 0, sizeof (hash_buf));
3594
3595 hash_buf.digest = mymalloc (dgst_size);
3596
3597 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3598
3599 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3600
3601 uint digest_buf[64];
3602
3603 outfile_data_t *out_info = NULL;
3604
3605 char **out_files = NULL;
3606
3607 time_t folder_mtime = 0;
3608
3609 int out_cnt = 0;
3610
3611 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3612
3613 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3614 {
3615 hc_sleep (1);
3616
3617 if (data.devices_status != STATUS_RUNNING) continue;
3618
3619 check_left--;
3620
3621 if (check_left == 0)
3622 {
3623 struct stat outfile_check_stat;
3624
3625 if (stat (outfile_dir, &outfile_check_stat) == 0)
3626 {
3627 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3628
3629 if (is_dir == 1)
3630 {
3631 if (outfile_check_stat.st_mtime > folder_mtime)
3632 {
3633 char **out_files_new = scan_directory (outfile_dir);
3634
3635 int out_cnt_new = count_dictionaries (out_files_new);
3636
3637 outfile_data_t *out_info_new = NULL;
3638
3639 if (out_cnt_new > 0)
3640 {
3641 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3642
3643 for (int i = 0; i < out_cnt_new; i++)
3644 {
3645 out_info_new[i].file_name = out_files_new[i];
3646
3647 // check if there are files that we have seen/checked before (and not changed)
3648
3649 for (int j = 0; j < out_cnt; j++)
3650 {
3651 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
3652 {
3653 struct stat outfile_stat;
3654
3655 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
3656 {
3657 if (outfile_stat.st_ctime == out_info[j].ctime)
3658 {
3659 out_info_new[i].ctime = out_info[j].ctime;
3660 out_info_new[i].seek = out_info[j].seek;
3661 }
3662 }
3663 }
3664 }
3665 }
3666 }
3667
3668 local_free (out_info);
3669 local_free (out_files);
3670
3671 out_files = out_files_new;
3672 out_cnt = out_cnt_new;
3673 out_info = out_info_new;
3674
3675 folder_mtime = outfile_check_stat.st_mtime;
3676 }
3677
3678 for (int j = 0; j < out_cnt; j++)
3679 {
3680 FILE *fp = fopen (out_info[j].file_name, "rb");
3681
3682 if (fp != NULL)
3683 {
3684 //hc_thread_mutex_lock (mux_display);
3685
3686 #ifdef _POSIX
3687 struct stat outfile_stat;
3688
3689 fstat (fileno (fp), &outfile_stat);
3690 #endif
3691
3692 #ifdef _WIN
3693 struct stat64 outfile_stat;
3694
3695 _fstat64 (fileno (fp), &outfile_stat);
3696 #endif
3697
3698 if (outfile_stat.st_ctime > out_info[j].ctime)
3699 {
3700 out_info[j].ctime = outfile_stat.st_ctime;
3701 out_info[j].seek = 0;
3702 }
3703
3704 fseek (fp, out_info[j].seek, SEEK_SET);
3705
3706 while (!feof (fp))
3707 {
3708 char line_buf[BUFSIZ];
3709
3710 memset (line_buf, 0, BUFSIZ);
3711
3712 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
3713
3714 if (ptr == NULL) break;
3715
3716 int line_len = strlen (line_buf);
3717
3718 if (line_len <= 0) continue;
3719
3720 int iter = MAX_CUT_TRIES;
3721
3722 for (uint i = line_len - 1; i && iter; i--, line_len--)
3723 {
3724 if (line_buf[i] != separator) continue;
3725
3726 int parser_status = PARSER_OK;
3727
3728 if ((hash_mode != 2500) && (hash_mode != 6800))
3729 {
3730 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
3731 }
3732
3733 uint found = 0;
3734
3735 if (parser_status == PARSER_OK)
3736 {
3737 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
3738 {
3739 if (data.salts_shown[salt_pos] == 1) continue;
3740
3741 salt_t *salt_buf = &data.salts_buf[salt_pos];
3742
3743 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
3744 {
3745 uint idx = salt_buf->digests_offset + digest_pos;
3746
3747 if (data.digests_shown[idx] == 1) continue;
3748
3749 uint cracked = 0;
3750
3751 if (hash_mode == 6800)
3752 {
3753 if (i == salt_buf->salt_len)
3754 {
3755 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3756 }
3757 }
3758 else if (hash_mode == 2500)
3759 {
3760 // BSSID : MAC1 : MAC2 (:plain)
3761 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
3762 {
3763 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3764
3765 if (!cracked) continue;
3766
3767 // now compare MAC1 and MAC2 too, since we have this additional info
3768 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
3769 char *mac2_pos = mac1_pos + 12 + 1;
3770
3771 wpa_t *wpas = (wpa_t *) data.esalts_buf;
3772 wpa_t *wpa = &wpas[salt_pos];
3773
3774 uint pke[25];
3775
3776 char *pke_ptr = (char *) pke;
3777
3778 for (uint i = 0; i < 25; i++)
3779 {
3780 pke[i] = byte_swap_32 (wpa->pke[i]);
3781 }
3782
3783 unsigned char mac1[6];
3784 unsigned char mac2[6];
3785
3786 memcpy (mac1, pke_ptr + 23, 6);
3787 memcpy (mac2, pke_ptr + 29, 6);
3788
3789 // compare hex string(s) vs binary MAC address(es)
3790
3791 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3792 {
3793 if (mac1[i] != (unsigned char) hex_to_char (&mac1_pos[j]))
3794 {
3795 cracked = 0;
3796 break;
3797 }
3798 }
3799
3800 // early skip ;)
3801 if (!cracked) continue;
3802
3803 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3804 {
3805 if (mac2[i] != (unsigned char) hex_to_char (&mac2_pos[j]))
3806 {
3807 cracked = 0;
3808 break;
3809 }
3810 }
3811 }
3812 }
3813 else
3814 {
3815 char *digests_buf_ptr = (char *) data.digests_buf;
3816
3817 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
3818
3819 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
3820 }
3821
3822 if (cracked == 1)
3823 {
3824 found = 1;
3825
3826 data.digests_shown[idx] = 1;
3827
3828 data.digests_done++;
3829
3830 salt_buf->digests_done++;
3831
3832 if (salt_buf->digests_done == salt_buf->digests_cnt)
3833 {
3834 data.salts_shown[salt_pos] = 1;
3835
3836 data.salts_done++;
3837
3838 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
3839 }
3840 }
3841 }
3842
3843 if (data.devices_status == STATUS_CRACKED) break;
3844 }
3845 }
3846
3847 if (found) break;
3848
3849 if (data.devices_status == STATUS_CRACKED) break;
3850
3851 iter--;
3852 }
3853
3854 if (data.devices_status == STATUS_CRACKED) break;
3855 }
3856
3857 out_info[j].seek = ftell (fp);
3858
3859 //hc_thread_mutex_unlock (mux_display);
3860
3861 fclose (fp);
3862 }
3863 }
3864 }
3865 }
3866
3867 check_left = outfile_check_timer;
3868 }
3869 }
3870
3871 if (esalt_size) local_free (hash_buf.esalt);
3872
3873 if (isSalted) local_free (hash_buf.salt);
3874
3875 local_free (hash_buf.digest);
3876
3877 local_free (out_info);
3878
3879 local_free (out_files);
3880
3881 p = NULL;
3882
3883 return (p);
3884 }
3885
3886 static uint get_work (hc_device_param_t *device_param, const uint64_t max)
3887 {
3888 hc_thread_mutex_lock (mux_dispatcher);
3889
3890 const uint64_t words_cur = data.words_cur;
3891 const uint64_t words_base = (data.limit == 0) ? data.words_base : data.limit;
3892
3893 device_param->words_off = words_cur;
3894
3895 const uint64_t words_left = words_base - words_cur;
3896
3897 if (data.kernel_blocks_all > words_left)
3898 {
3899 if (data.kernel_blocks_div == 0)
3900 {
3901 data.kernel_blocks_div = find_kernel_blocks_div (words_left, data.kernel_blocks_all);
3902 }
3903 }
3904
3905 if (data.kernel_blocks_div)
3906 {
3907 if (device_param->kernel_blocks == device_param->kernel_blocks_user)
3908 {
3909 const uint32_t kernel_blocks_new = (float) device_param->kernel_blocks * data.kernel_blocks_div;
3910 const uint32_t kernel_power_new = kernel_blocks_new;
3911
3912 if (kernel_blocks_new < device_param->kernel_blocks)
3913 {
3914 device_param->kernel_blocks = kernel_blocks_new;
3915 device_param->kernel_power = kernel_power_new;
3916 }
3917 }
3918 }
3919
3920 const uint kernel_blocks = device_param->kernel_blocks;
3921
3922 uint work = MIN (words_left, kernel_blocks);
3923
3924 work = MIN (work, max);
3925
3926 data.words_cur += work;
3927
3928 hc_thread_mutex_unlock (mux_dispatcher);
3929
3930 return work;
3931 }
3932
3933 static void *thread_calc_stdin (void *p)
3934 {
3935 hc_device_param_t *device_param = (hc_device_param_t *) p;
3936
3937 const uint attack_kern = data.attack_kern;
3938
3939 const uint kernel_blocks = device_param->kernel_blocks;
3940
3941 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3942 {
3943 hc_thread_mutex_lock (mux_dispatcher);
3944
3945 if (feof (stdin) != 0)
3946 {
3947 hc_thread_mutex_unlock (mux_dispatcher);
3948
3949 break;
3950 }
3951
3952 uint words_cur = 0;
3953
3954 while (words_cur < kernel_blocks)
3955 {
3956 char buf[BUFSIZ];
3957
3958 char *line_buf = fgets (buf, sizeof (buf), stdin);
3959
3960 if (line_buf == NULL) break;
3961
3962 uint line_len = in_superchop (line_buf);
3963
3964 line_len = convert_from_hex (line_buf, line_len);
3965
3966 // post-process rule engine
3967
3968 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3969 {
3970 char rule_buf_out[BLOCK_SIZE];
3971
3972 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3973
3974 int rule_len_out = -1;
3975
3976 if (line_len < BLOCK_SIZE)
3977 {
3978 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
3979 }
3980
3981 if (rule_len_out < 0) continue;
3982
3983 line_buf = rule_buf_out;
3984 line_len = rule_len_out;
3985 }
3986
3987 if (line_len > PW_MAX)
3988 {
3989 continue;
3990 }
3991
3992 if (attack_kern == ATTACK_KERN_STRAIGHT)
3993 {
3994 if ((line_len < data.pw_min) || (line_len > data.pw_max))
3995 {
3996 hc_thread_mutex_lock (mux_counter);
3997
3998 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3999 {
4000 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4001 }
4002
4003 hc_thread_mutex_unlock (mux_counter);
4004
4005 continue;
4006 }
4007 }
4008 else if (attack_kern == ATTACK_KERN_COMBI)
4009 {
4010 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4011 // since we still need to combine the plains
4012
4013 if (line_len > data.pw_max)
4014 {
4015 hc_thread_mutex_lock (mux_counter);
4016
4017 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4018 {
4019 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4020 }
4021
4022 hc_thread_mutex_unlock (mux_counter);
4023
4024 continue;
4025 }
4026 }
4027
4028 device_param->pw_add (device_param, (uint8_t *) line_buf, line_len);
4029
4030 words_cur++;
4031
4032 if (data.devices_status == STATUS_CRACKED) break;
4033 if (data.devices_status == STATUS_ABORTED) break;
4034 if (data.devices_status == STATUS_QUIT) break;
4035 if (data.devices_status == STATUS_BYPASS) break;
4036 }
4037
4038 hc_thread_mutex_unlock (mux_dispatcher);
4039
4040 if (data.devices_status == STATUS_CRACKED) break;
4041 if (data.devices_status == STATUS_ABORTED) break;
4042 if (data.devices_status == STATUS_QUIT) break;
4043 if (data.devices_status == STATUS_BYPASS) break;
4044
4045 // we need 2 flushing because we have two independant caches and it can occur
4046 // that one buffer is already at threshold plus for that length also exists
4047 // more data in the 2nd buffer so it would overflow
4048
4049 // flush session 1
4050
4051 {
4052 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4053 {
4054 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4055
4056 const uint pw_cache_cnt = pw_cache->cnt;
4057
4058 if (pw_cache_cnt == 0) continue;
4059
4060 pw_cache->cnt = 0;
4061
4062 uint pws_cnt = device_param->pws_cnt;
4063
4064 pw_t *pw = device_param->pws_buf + pws_cnt;
4065
4066 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4067
4068 pw->pw_len = pw_len;
4069
4070 uint pw_cnt = device_param->pw_cnt;
4071
4072 pw_cnt += pw_cache_cnt;
4073
4074 device_param->pw_cnt = pw_cnt;
4075
4076 pws_cnt++;
4077
4078 device_param->pws_cnt = pws_cnt;
4079
4080 if (pws_cnt == device_param->kernel_power_user) break;
4081 }
4082
4083 const uint pw_cnt = device_param->pw_cnt;
4084 const uint pws_cnt = device_param->pws_cnt;
4085
4086 if (pws_cnt)
4087 {
4088 run_copy (device_param, pws_cnt);
4089
4090 run_cracker (device_param, pw_cnt, pws_cnt);
4091
4092 device_param->pw_cnt = 0;
4093 device_param->pws_cnt = 0;
4094 }
4095 }
4096
4097 // flush session 2
4098
4099 {
4100 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4101 {
4102 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4103
4104 const uint pw_cache_cnt = pw_cache->cnt;
4105
4106 if (pw_cache_cnt == 0) continue;
4107
4108 pw_cache->cnt = 0;
4109
4110 uint pws_cnt = device_param->pws_cnt;
4111
4112 pw_t *pw = device_param->pws_buf + pws_cnt;
4113
4114 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4115
4116 pw->pw_len = pw_len;
4117
4118 uint pw_cnt = device_param->pw_cnt;
4119
4120 pw_cnt += pw_cache_cnt;
4121
4122 device_param->pw_cnt = pw_cnt;
4123
4124 pws_cnt++;
4125
4126 device_param->pws_cnt = pws_cnt;
4127 }
4128
4129 const uint pw_cnt = device_param->pw_cnt;
4130 const uint pws_cnt = device_param->pws_cnt;
4131
4132 if (pws_cnt)
4133 {
4134 run_copy (device_param, pws_cnt);
4135
4136 run_cracker (device_param, pw_cnt, pws_cnt);
4137
4138 device_param->pw_cnt = 0;
4139 device_param->pws_cnt = 0;
4140 }
4141 }
4142 }
4143
4144 return NULL;
4145 }
4146
4147 static void *thread_calc (void *p)
4148 {
4149 hc_device_param_t *device_param = (hc_device_param_t *) p;
4150
4151 const uint attack_mode = data.attack_mode;
4152 const uint attack_kern = data.attack_kern;
4153
4154 if (attack_mode == ATTACK_MODE_BF)
4155 {
4156 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4157 {
4158 const uint work = get_work (device_param, -1);
4159
4160 if (work == 0) break;
4161
4162 const uint64_t words_off = device_param->words_off;
4163 const uint64_t words_fin = words_off + work;
4164
4165 const uint pw_cnt = work;
4166 const uint pws_cnt = work;
4167
4168 device_param->pw_cnt = pw_cnt;
4169 device_param->pws_cnt = pws_cnt;
4170
4171 if (pws_cnt)
4172 {
4173 run_copy (device_param, pws_cnt);
4174
4175 run_cracker (device_param, pw_cnt, pws_cnt);
4176
4177 device_param->pw_cnt = 0;
4178 device_param->pws_cnt = 0;
4179 }
4180
4181 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4182
4183 if (data.devices_status == STATUS_CRACKED) break;
4184 if (data.devices_status == STATUS_ABORTED) break;
4185 if (data.devices_status == STATUS_QUIT) break;
4186 if (data.devices_status == STATUS_BYPASS) break;
4187
4188 device_param->words_done = words_fin;
4189 }
4190 }
4191 else
4192 {
4193 const uint segment_size = data.segment_size;
4194
4195 char *dictfile = data.dictfile;
4196
4197 if (attack_mode == ATTACK_MODE_COMBI)
4198 {
4199 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4200 {
4201 dictfile = data.dictfile2;
4202 }
4203 }
4204
4205 FILE *fd = fopen (dictfile, "rb");
4206
4207 if (fd == NULL)
4208 {
4209 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4210
4211 return NULL;
4212 }
4213
4214 if (attack_mode == ATTACK_MODE_COMBI)
4215 {
4216 const uint combs_mode = data.combs_mode;
4217
4218 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4219 {
4220 const char *dictfilec = data.dictfile2;
4221
4222 FILE *combs_fp = fopen (dictfilec, "rb");
4223
4224 if (combs_fp == NULL)
4225 {
4226 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4227
4228 fclose (fd);
4229
4230 return NULL;
4231 }
4232
4233 device_param->combs_fp = combs_fp;
4234 }
4235 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4236 {
4237 const char *dictfilec = data.dictfile;
4238
4239 FILE *combs_fp = fopen (dictfilec, "rb");
4240
4241 if (combs_fp == NULL)
4242 {
4243 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4244
4245 fclose (fd);
4246
4247 return NULL;
4248 }
4249
4250 device_param->combs_fp = combs_fp;
4251 }
4252 }
4253
4254 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4255
4256 wl_data->buf = (char *) mymalloc (segment_size);
4257 wl_data->avail = segment_size;
4258 wl_data->incr = segment_size;
4259 wl_data->cnt = 0;
4260 wl_data->pos = 0;
4261
4262 uint64_t words_cur = 0;
4263
4264 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4265 {
4266 uint64_t words_off = 0;
4267 uint64_t words_fin = 0;
4268
4269 uint64_t max = -1;
4270
4271 while (max)
4272 {
4273 const uint work = get_work (device_param, max);
4274
4275 if (work == 0) break;
4276
4277 words_off = device_param->words_off;
4278 words_fin = words_off + work;
4279
4280 char *line_buf;
4281 uint line_len;
4282
4283 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4284
4285 max = 0;
4286
4287 for ( ; words_cur < words_fin; words_cur++)
4288 {
4289 get_next_word (wl_data, fd, &line_buf, &line_len);
4290
4291 line_len = convert_from_hex (line_buf, line_len);
4292
4293 // post-process rule engine
4294
4295 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4296 {
4297 char rule_buf_out[BLOCK_SIZE];
4298
4299 memset (rule_buf_out, 0, sizeof (rule_buf_out));
4300
4301 int rule_len_out = -1;
4302
4303 if (line_len < BLOCK_SIZE)
4304 {
4305 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4306 }
4307
4308 if (rule_len_out < 0) continue;
4309
4310 line_buf = rule_buf_out;
4311 line_len = rule_len_out;
4312 }
4313
4314 if (attack_kern == ATTACK_KERN_STRAIGHT)
4315 {
4316 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4317 {
4318 max++;
4319
4320 hc_thread_mutex_lock (mux_counter);
4321
4322 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4323 {
4324 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4325 }
4326
4327 hc_thread_mutex_unlock (mux_counter);
4328
4329 continue;
4330 }
4331 }
4332 else if (attack_kern == ATTACK_KERN_COMBI)
4333 {
4334 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4335 // since we still need to combine the plains
4336
4337 if (line_len > data.pw_max)
4338 {
4339 max++;
4340
4341 hc_thread_mutex_lock (mux_counter);
4342
4343 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4344 {
4345 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4346 }
4347
4348 hc_thread_mutex_unlock (mux_counter);
4349
4350 continue;
4351 }
4352 }
4353
4354 device_param->pw_add (device_param, (uint8_t *) line_buf, line_len);
4355
4356 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4357
4358 if (data.devices_status == STATUS_CRACKED) break;
4359 if (data.devices_status == STATUS_ABORTED) break;
4360 if (data.devices_status == STATUS_QUIT) break;
4361 if (data.devices_status == STATUS_BYPASS) break;
4362 }
4363
4364 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4365
4366 if (data.devices_status == STATUS_CRACKED) break;
4367 if (data.devices_status == STATUS_ABORTED) break;
4368 if (data.devices_status == STATUS_QUIT) break;
4369 if (data.devices_status == STATUS_BYPASS) break;
4370 }
4371
4372 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4373
4374 if (data.devices_status == STATUS_CRACKED) break;
4375 if (data.devices_status == STATUS_ABORTED) break;
4376 if (data.devices_status == STATUS_QUIT) break;
4377 if (data.devices_status == STATUS_BYPASS) break;
4378
4379 // we need 2 flushing because we have two independant caches and it can occur
4380 // that one buffer is already at threshold plus for that length also exists
4381 // more data in the 2nd buffer so it would overflow
4382
4383 //
4384 // flush session 1
4385 //
4386
4387 {
4388 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4389 {
4390 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4391
4392 const uint pw_cache_cnt = pw_cache->cnt;
4393
4394 if (pw_cache_cnt == 0) continue;
4395
4396 pw_cache->cnt = 0;
4397
4398 uint pws_cnt = device_param->pws_cnt;
4399
4400 pw_t *pw = device_param->pws_buf + pws_cnt;
4401
4402 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4403
4404 pw->pw_len = pw_len;
4405
4406 uint pw_cnt = device_param->pw_cnt;
4407
4408 pw_cnt += pw_cache_cnt;
4409
4410 device_param->pw_cnt = pw_cnt;
4411
4412 pws_cnt++;
4413
4414 device_param->pws_cnt = pws_cnt;
4415
4416 if (pws_cnt == device_param->kernel_power_user) break;
4417 }
4418
4419 const uint pw_cnt = device_param->pw_cnt;
4420 const uint pws_cnt = device_param->pws_cnt;
4421
4422 if (pws_cnt)
4423 {
4424 run_copy (device_param, pws_cnt);
4425
4426 run_cracker (device_param, pw_cnt, pws_cnt);
4427
4428 device_param->pw_cnt = 0;
4429 device_param->pws_cnt = 0;
4430 }
4431
4432 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4433
4434 if (data.devices_status == STATUS_CRACKED) break;
4435 if (data.devices_status == STATUS_ABORTED) break;
4436 if (data.devices_status == STATUS_QUIT) break;
4437 if (data.devices_status == STATUS_BYPASS) break;
4438 }
4439
4440 //
4441 // flush session 2
4442 //
4443
4444 {
4445 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4446 {
4447 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4448
4449 const uint pw_cache_cnt = pw_cache->cnt;
4450
4451 if (pw_cache_cnt == 0) continue;
4452
4453 pw_cache->cnt = 0;
4454
4455 uint pws_cnt = device_param->pws_cnt;
4456
4457 pw_t *pw = device_param->pws_buf + pws_cnt;
4458
4459 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4460
4461 pw->pw_len = pw_len;
4462
4463 uint pw_cnt = device_param->pw_cnt;
4464
4465 pw_cnt += pw_cache_cnt;
4466
4467 device_param->pw_cnt = pw_cnt;
4468
4469 pws_cnt++;
4470
4471 device_param->pws_cnt = pws_cnt;
4472 }
4473
4474 const uint pw_cnt = device_param->pw_cnt;
4475 const uint pws_cnt = device_param->pws_cnt;
4476
4477 if (pws_cnt)
4478 {
4479 run_copy (device_param, pws_cnt);
4480
4481 run_cracker (device_param, pw_cnt, pws_cnt);
4482
4483 device_param->pw_cnt = 0;
4484 device_param->pws_cnt = 0;
4485 }
4486
4487 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4488
4489 if (data.devices_status == STATUS_CRACKED) break;
4490 if (data.devices_status == STATUS_ABORTED) break;
4491 if (data.devices_status == STATUS_QUIT) break;
4492 if (data.devices_status == STATUS_BYPASS) break;
4493 }
4494
4495 if (words_fin == 0) break;
4496
4497 device_param->words_done = words_fin;
4498 }
4499
4500 if (attack_mode == ATTACK_MODE_COMBI)
4501 {
4502 fclose (device_param->combs_fp);
4503 }
4504
4505 free (wl_data->buf);
4506 free (wl_data);
4507
4508 fclose (fd);
4509 }
4510
4511 return NULL;
4512 }
4513
4514 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos, const uint kernel_loops)
4515 {
4516 salt_t *salt_buf = &data.salts_buf[salt_pos];
4517
4518 device_param->kernel_params_buf32[24] = salt_pos;
4519 device_param->kernel_params_buf32[27] = 1;
4520 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4521 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4522 device_param->kernel_params_buf32[30] = 0;
4523 device_param->kernel_params_buf32[31] = 1;
4524
4525 char *dictfile_old = data.dictfile;
4526 char *dictfile2_old = data.dictfile2;
4527 char *mask_old = data.mask;
4528
4529 const char *weak_hash_check = "weak-hash-check";
4530
4531 data.dictfile = (char *) weak_hash_check;
4532 data.dictfile2 = (char *) weak_hash_check;
4533 data.mask = (char *) weak_hash_check;
4534
4535 /**
4536 * run the kernel
4537 */
4538
4539 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4540 {
4541 run_kernel (KERN_RUN_1, device_param, 1);
4542 }
4543 else
4544 {
4545 run_kernel (KERN_RUN_1, device_param, 1);
4546
4547 const uint iter = salt_buf->salt_iter;
4548
4549 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
4550 {
4551 uint loop_left = iter - loop_pos;
4552
4553 loop_left = MIN (loop_left, kernel_loops);
4554
4555 device_param->kernel_params_buf32[25] = loop_pos;
4556 device_param->kernel_params_buf32[26] = loop_left;
4557
4558 run_kernel (KERN_RUN_2, device_param, 1);
4559 }
4560
4561 run_kernel (KERN_RUN_3, device_param, 1);
4562 }
4563
4564 /**
4565 * result
4566 */
4567
4568 check_cracked (device_param, salt_pos);
4569
4570 /**
4571 * cleanup
4572 */
4573
4574 device_param->kernel_params_buf32[24] = 0;
4575 device_param->kernel_params_buf32[25] = 0;
4576 device_param->kernel_params_buf32[26] = 0;
4577 device_param->kernel_params_buf32[27] = 0;
4578 device_param->kernel_params_buf32[28] = 0;
4579 device_param->kernel_params_buf32[29] = 0;
4580 device_param->kernel_params_buf32[30] = 0;
4581 device_param->kernel_params_buf32[31] = 0;
4582
4583 data.dictfile = dictfile_old;
4584 data.dictfile2 = dictfile2_old;
4585 data.mask = mask_old;
4586 }
4587
4588 // hlfmt hashcat
4589
4590 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4591 {
4592 if (data.username == 0)
4593 {
4594 *hashbuf_pos = line_buf;
4595 *hashbuf_len = line_len;
4596 }
4597 else
4598 {
4599 char *pos = line_buf;
4600 int len = line_len;
4601
4602 for (int i = 0; i < line_len; i++, pos++, len--)
4603 {
4604 if (line_buf[i] == data.separator)
4605 {
4606 pos++;
4607
4608 len--;
4609
4610 break;
4611 }
4612 }
4613
4614 *hashbuf_pos = pos;
4615 *hashbuf_len = len;
4616 }
4617 }
4618
4619 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4620 {
4621 char *pos = NULL;
4622 int len = 0;
4623
4624 int sep_cnt = 0;
4625
4626 for (int i = 0; i < line_len; i++)
4627 {
4628 if (line_buf[i] == data.separator)
4629 {
4630 sep_cnt++;
4631
4632 continue;
4633 }
4634
4635 if (sep_cnt == 0)
4636 {
4637 if (pos == NULL) pos = line_buf + i;
4638
4639 len++;
4640 }
4641 }
4642
4643 *userbuf_pos = pos;
4644 *userbuf_len = len;
4645 }
4646
4647 // hlfmt pwdump
4648
4649 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
4650 {
4651 int sep_cnt = 0;
4652
4653 int sep2_len = 0;
4654 int sep3_len = 0;
4655
4656 for (int i = 0; i < line_len; i++)
4657 {
4658 if (line_buf[i] == ':')
4659 {
4660 sep_cnt++;
4661
4662 continue;
4663 }
4664
4665 if (sep_cnt == 2) sep2_len++;
4666 if (sep_cnt == 3) sep3_len++;
4667 }
4668
4669 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4670
4671 return 0;
4672 }
4673
4674 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4675 {
4676 char *pos = NULL;
4677 int len = 0;
4678
4679 int sep_cnt = 0;
4680
4681 for (int i = 0; i < line_len; i++)
4682 {
4683 if (line_buf[i] == ':')
4684 {
4685 sep_cnt++;
4686
4687 continue;
4688 }
4689
4690 if (data.hash_mode == 1000)
4691 {
4692 if (sep_cnt == 3)
4693 {
4694 if (pos == NULL) pos = line_buf + i;
4695
4696 len++;
4697 }
4698 }
4699 else if (data.hash_mode == 3000)
4700 {
4701 if (sep_cnt == 2)
4702 {
4703 if (pos == NULL) pos = line_buf + i;
4704
4705 len++;
4706 }
4707 }
4708 }
4709
4710 *hashbuf_pos = pos;
4711 *hashbuf_len = len;
4712 }
4713
4714 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4715 {
4716 char *pos = NULL;
4717 int len = 0;
4718
4719 int sep_cnt = 0;
4720
4721 for (int i = 0; i < line_len; i++)
4722 {
4723 if (line_buf[i] == ':')
4724 {
4725 sep_cnt++;
4726
4727 continue;
4728 }
4729
4730 if (sep_cnt == 0)
4731 {
4732 if (pos == NULL) pos = line_buf + i;
4733
4734 len++;
4735 }
4736 }
4737
4738 *userbuf_pos = pos;
4739 *userbuf_len = len;
4740 }
4741
4742 // hlfmt passwd
4743
4744 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
4745 {
4746 int sep_cnt = 0;
4747
4748 char sep5_first = 0;
4749 char sep6_first = 0;
4750
4751 for (int i = 0; i < line_len; i++)
4752 {
4753 if (line_buf[i] == ':')
4754 {
4755 sep_cnt++;
4756
4757 continue;
4758 }
4759
4760 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
4761 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
4762 }
4763
4764 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
4765
4766 return 0;
4767 }
4768
4769 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4770 {
4771 char *pos = NULL;
4772 int len = 0;
4773
4774 int sep_cnt = 0;
4775
4776 for (int i = 0; i < line_len; i++)
4777 {
4778 if (line_buf[i] == ':')
4779 {
4780 sep_cnt++;
4781
4782 continue;
4783 }
4784
4785 if (sep_cnt == 1)
4786 {
4787 if (pos == NULL) pos = line_buf + i;
4788
4789 len++;
4790 }
4791 }
4792
4793 *hashbuf_pos = pos;
4794 *hashbuf_len = len;
4795 }
4796
4797 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4798 {
4799 char *pos = NULL;
4800 int len = 0;
4801
4802 int sep_cnt = 0;
4803
4804 for (int i = 0; i < line_len; i++)
4805 {
4806 if (line_buf[i] == ':')
4807 {
4808 sep_cnt++;
4809
4810 continue;
4811 }
4812
4813 if (sep_cnt == 0)
4814 {
4815 if (pos == NULL) pos = line_buf + i;
4816
4817 len++;
4818 }
4819 }
4820
4821 *userbuf_pos = pos;
4822 *userbuf_len = len;
4823 }
4824
4825 // hlfmt shadow
4826
4827 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
4828 {
4829 int sep_cnt = 0;
4830
4831 for (int i = 0; i < line_len; i++)
4832 {
4833 if (line_buf[i] == ':') sep_cnt++;
4834 }
4835
4836 if (sep_cnt == 8) return 1;
4837
4838 return 0;
4839 }
4840
4841 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4842 {
4843 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
4844 }
4845
4846 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4847 {
4848 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
4849 }
4850
4851 // hlfmt main
4852
4853 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4854 {
4855 switch (hashfile_format)
4856 {
4857 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4858 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4859 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4860 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4861 }
4862 }
4863
4864 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4865 {
4866 switch (hashfile_format)
4867 {
4868 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
4869 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
4870 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
4871 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
4872 }
4873 }
4874
4875 static uint hlfmt_detect (FILE *fp, uint max_check)
4876 {
4877 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
4878
4879 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
4880 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
4881
4882 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
4883
4884 uint num_check = 0;
4885
4886 while (!feof (fp))
4887 {
4888 char line_buf[BUFSIZ];
4889
4890 int line_len = fgetl (fp, line_buf);
4891
4892 if (line_len == 0) continue;
4893
4894 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
4895 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
4896 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
4897
4898 if (num_check == max_check) break;
4899
4900 num_check++;
4901 }
4902
4903 uint hashlist_format = HLFMT_HASHCAT;
4904
4905 for (int i = 1; i < HLFMTS_CNT; i++)
4906 {
4907 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
4908
4909 hashlist_format = i;
4910 }
4911
4912 free (formats_cnt);
4913
4914 return hashlist_format;
4915 }
4916
4917 /**
4918 * some further helper function
4919 */
4920
4921 // wrapper around mymalloc for ADL
4922
4923 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
4924 {
4925 return mymalloc (iSize);
4926 }
4927
4928 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)
4929 {
4930 uint64_t collisions = 0;
4931
4932 const uint dgst_pos0 = data.dgst_pos0;
4933 const uint dgst_pos1 = data.dgst_pos1;
4934 const uint dgst_pos2 = data.dgst_pos2;
4935 const uint dgst_pos3 = data.dgst_pos3;
4936
4937 memset (bitmap_a, 0, bitmap_size);
4938 memset (bitmap_b, 0, bitmap_size);
4939 memset (bitmap_c, 0, bitmap_size);
4940 memset (bitmap_d, 0, bitmap_size);
4941
4942 for (uint i = 0; i < digests_cnt; i++)
4943 {
4944 uint *digest_ptr = (uint *) digests_buf_ptr;
4945
4946 digests_buf_ptr += dgst_size;
4947
4948 const uint val0 = 1 << (digest_ptr[dgst_pos0] & 0x1f);
4949 const uint val1 = 1 << (digest_ptr[dgst_pos1] & 0x1f);
4950 const uint val2 = 1 << (digest_ptr[dgst_pos2] & 0x1f);
4951 const uint val3 = 1 << (digest_ptr[dgst_pos3] & 0x1f);
4952
4953 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
4954 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
4955 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
4956 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
4957
4958 if (bitmap_a[idx0] & val0) collisions++;
4959 if (bitmap_b[idx1] & val1) collisions++;
4960 if (bitmap_c[idx2] & val2) collisions++;
4961 if (bitmap_d[idx3] & val3) collisions++;
4962
4963 bitmap_a[idx0] |= val0;
4964 bitmap_b[idx1] |= val1;
4965 bitmap_c[idx2] |= val2;
4966 bitmap_d[idx3] |= val3;
4967
4968 if (collisions >= collisions_max) return 0x7fffffff;
4969 }
4970
4971 return collisions;
4972 }
4973
4974 /**
4975 * main
4976 */
4977
4978 int main (int argc, char **argv)
4979 {
4980 /**
4981 * To help users a bit
4982 */
4983
4984 char *compute = getenv ("COMPUTE");
4985
4986 if (compute)
4987 {
4988 char display[100];
4989
4990 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
4991
4992 putenv (display);
4993 }
4994 else
4995 {
4996 if (getenv ("DISPLAY") == NULL)
4997 putenv ((char *) "DISPLAY=:0");
4998 }
4999
5000 /*
5001 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5002 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5003
5004 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5005 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5006 */
5007
5008 /**
5009 * Real init
5010 */
5011
5012 memset (&data, 0, sizeof (hc_global_data_t));
5013
5014 time_t proc_start;
5015
5016 time (&proc_start);
5017
5018 data.proc_start = proc_start;
5019
5020 int myargc = argc;
5021 char **myargv = argv;
5022
5023 hc_thread_mutex_init (mux_dispatcher);
5024 hc_thread_mutex_init (mux_counter);
5025 hc_thread_mutex_init (mux_display);
5026 hc_thread_mutex_init (mux_adl);
5027
5028 /**
5029 * commandline parameters
5030 */
5031
5032 uint usage = USAGE;
5033 uint version = VERSION;
5034 uint quiet = QUIET;
5035 uint benchmark = BENCHMARK;
5036 uint benchmark_mode = BENCHMARK_MODE;
5037 uint show = SHOW;
5038 uint left = LEFT;
5039 uint username = USERNAME;
5040 uint remove = REMOVE;
5041 uint remove_timer = REMOVE_TIMER;
5042 uint64_t skip = SKIP;
5043 uint64_t limit = LIMIT;
5044 uint keyspace = KEYSPACE;
5045 uint potfile_disable = POTFILE_DISABLE;
5046 uint debug_mode = DEBUG_MODE;
5047 char *debug_file = NULL;
5048 char *induction_dir = NULL;
5049 char *outfile_check_dir = NULL;
5050 uint force = FORCE;
5051 uint runtime = RUNTIME;
5052 uint hash_mode = HASH_MODE;
5053 uint attack_mode = ATTACK_MODE;
5054 uint markov_disable = MARKOV_DISABLE;
5055 uint markov_classic = MARKOV_CLASSIC;
5056 uint markov_threshold = MARKOV_THRESHOLD;
5057 char *markov_hcstat = NULL;
5058 char *outfile = NULL;
5059 uint outfile_format = OUTFILE_FORMAT;
5060 uint outfile_autohex = OUTFILE_AUTOHEX;
5061 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5062 uint restore = RESTORE;
5063 uint restore_timer = RESTORE_TIMER;
5064 uint restore_disable = RESTORE_DISABLE;
5065 uint status = STATUS;
5066 uint status_timer = STATUS_TIMER;
5067 uint status_automat = STATUS_AUTOMAT;
5068 uint loopback = LOOPBACK;
5069 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5070 char *session = NULL;
5071 uint hex_charset = HEX_CHARSET;
5072 uint hex_salt = HEX_SALT;
5073 uint hex_wordlist = HEX_WORDLIST;
5074 uint rp_gen = RP_GEN;
5075 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5076 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5077 uint rp_gen_seed = RP_GEN_SEED;
5078 char *rule_buf_l = (char *) RULE_BUF_L;
5079 char *rule_buf_r = (char *) RULE_BUF_R;
5080 uint increment = INCREMENT;
5081 uint increment_min = INCREMENT_MIN;
5082 uint increment_max = INCREMENT_MAX;
5083 char *cpu_affinity = NULL;
5084 char *opencl_devices = NULL;
5085 char *opencl_platform = NULL;
5086 char *truecrypt_keyfiles = NULL;
5087 uint workload_profile = WORKLOAD_PROFILE;
5088 uint kernel_accel = KERNEL_ACCEL;
5089 uint kernel_loops = KERNEL_LOOPS;
5090 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5091 uint gpu_temp_abort = GPU_TEMP_ABORT;
5092 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5093 uint powertune_enable = POWERTUNE_ENABLE;
5094 uint logfile_disable = LOGFILE_DISABLE;
5095 uint segment_size = SEGMENT_SIZE;
5096 uint scrypt_tmto = SCRYPT_TMTO;
5097 char separator = SEPARATOR;
5098 uint bitmap_min = BITMAP_MIN;
5099 uint bitmap_max = BITMAP_MAX;
5100 char *custom_charset_1 = NULL;
5101 char *custom_charset_2 = NULL;
5102 char *custom_charset_3 = NULL;
5103 char *custom_charset_4 = NULL;
5104
5105 #define IDX_HELP 'h'
5106 #define IDX_VERSION 'V'
5107 #define IDX_VERSION_LOWER 'v'
5108 #define IDX_QUIET 0xff02
5109 #define IDX_SHOW 0xff03
5110 #define IDX_LEFT 0xff04
5111 #define IDX_REMOVE 0xff05
5112 #define IDX_REMOVE_TIMER 0xff37
5113 #define IDX_SKIP 's'
5114 #define IDX_LIMIT 'l'
5115 #define IDX_KEYSPACE 0xff35
5116 #define IDX_POTFILE_DISABLE 0xff06
5117 #define IDX_DEBUG_MODE 0xff43
5118 #define IDX_DEBUG_FILE 0xff44
5119 #define IDX_INDUCTION_DIR 0xff46
5120 #define IDX_OUTFILE_CHECK_DIR 0xff47
5121 #define IDX_USERNAME 0xff07
5122 #define IDX_FORCE 0xff08
5123 #define IDX_RUNTIME 0xff09
5124 #define IDX_BENCHMARK 'b'
5125 #define IDX_BENCHMARK_MODE 0xff32
5126 #define IDX_HASH_MODE 'm'
5127 #define IDX_ATTACK_MODE 'a'
5128 #define IDX_RP_FILE 'r'
5129 #define IDX_RP_GEN 'g'
5130 #define IDX_RP_GEN_FUNC_MIN 0xff10
5131 #define IDX_RP_GEN_FUNC_MAX 0xff11
5132 #define IDX_RP_GEN_SEED 0xff34
5133 #define IDX_RULE_BUF_L 'j'
5134 #define IDX_RULE_BUF_R 'k'
5135 #define IDX_INCREMENT 'i'
5136 #define IDX_INCREMENT_MIN 0xff12
5137 #define IDX_INCREMENT_MAX 0xff13
5138 #define IDX_OUTFILE 'o'
5139 #define IDX_OUTFILE_FORMAT 0xff14
5140 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5141 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5142 #define IDX_RESTORE 0xff15
5143 #define IDX_RESTORE_DISABLE 0xff27
5144 #define IDX_STATUS 0xff17
5145 #define IDX_STATUS_TIMER 0xff18
5146 #define IDX_STATUS_AUTOMAT 0xff50
5147 #define IDX_LOOPBACK 0xff38
5148 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5149 #define IDX_SESSION 0xff19
5150 #define IDX_HEX_CHARSET 0xff20
5151 #define IDX_HEX_SALT 0xff21
5152 #define IDX_HEX_WORDLIST 0xff40
5153 #define IDX_MARKOV_DISABLE 0xff22
5154 #define IDX_MARKOV_CLASSIC 0xff23
5155 #define IDX_MARKOV_THRESHOLD 't'
5156 #define IDX_MARKOV_HCSTAT 0xff24
5157 #define IDX_CPU_AFFINITY 0xff25
5158 #define IDX_OPENCL_DEVICES 'd'
5159 #define IDX_OPENCL_PLATFORM 0xff72
5160 #define IDX_WORKLOAD_PROFILE 'w'
5161 #define IDX_KERNEL_ACCEL 'n'
5162 #define IDX_KERNEL_LOOPS 'u'
5163 #define IDX_GPU_TEMP_DISABLE 0xff29
5164 #define IDX_GPU_TEMP_ABORT 0xff30
5165 #define IDX_GPU_TEMP_RETAIN 0xff31
5166 #define IDX_POWERTUNE_ENABLE 0xff41
5167 #define IDX_LOGFILE_DISABLE 0xff51
5168 #define IDX_TRUECRYPT_KEYFILES 0xff52
5169 #define IDX_SCRYPT_TMTO 0xff61
5170 #define IDX_SEGMENT_SIZE 'c'
5171 #define IDX_SEPARATOR 'p'
5172 #define IDX_BITMAP_MIN 0xff70
5173 #define IDX_BITMAP_MAX 0xff71
5174 #define IDX_CUSTOM_CHARSET_1 '1'
5175 #define IDX_CUSTOM_CHARSET_2 '2'
5176 #define IDX_CUSTOM_CHARSET_3 '3'
5177 #define IDX_CUSTOM_CHARSET_4 '4'
5178
5179 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5180
5181 struct option long_options[] =
5182 {
5183 {"help", no_argument, 0, IDX_HELP},
5184 {"version", no_argument, 0, IDX_VERSION},
5185 {"quiet", no_argument, 0, IDX_QUIET},
5186 {"show", no_argument, 0, IDX_SHOW},
5187 {"left", no_argument, 0, IDX_LEFT},
5188 {"username", no_argument, 0, IDX_USERNAME},
5189 {"remove", no_argument, 0, IDX_REMOVE},
5190 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5191 {"skip", required_argument, 0, IDX_SKIP},
5192 {"limit", required_argument, 0, IDX_LIMIT},
5193 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5194 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5195 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5196 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5197 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5198 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5199 {"force", no_argument, 0, IDX_FORCE},
5200 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5201 {"benchmark-mode", required_argument, 0, IDX_BENCHMARK_MODE},
5202 {"restore", no_argument, 0, IDX_RESTORE},
5203 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5204 {"status", no_argument, 0, IDX_STATUS},
5205 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5206 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5207 {"loopback", no_argument, 0, IDX_LOOPBACK},
5208 {"weak-hash-threshold",
5209 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5210 {"session", required_argument, 0, IDX_SESSION},
5211 {"runtime", required_argument, 0, IDX_RUNTIME},
5212 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5213 {"generate-rules-func-min",
5214 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5215 {"generate-rules-func-max",
5216 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5217 {"generate-rules-seed",
5218 required_argument, 0, IDX_RP_GEN_SEED},
5219 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5220 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5221 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5222 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5223 {"rules-file", required_argument, 0, IDX_RP_FILE},
5224 {"outfile", required_argument, 0, IDX_OUTFILE},
5225 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5226 {"outfile-autohex-disable",
5227 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5228 {"outfile-check-timer",
5229 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5230 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5231 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5232 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5233 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5234 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5235 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5236 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5237 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5238 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5239 {"opencl-platform", required_argument, 0, IDX_OPENCL_PLATFORM},
5240 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5241 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5242 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5243 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5244 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5245 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5246 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5247 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5248 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5249 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5250 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5251 // deprecated
5252 {"seperator", required_argument, 0, IDX_SEPARATOR},
5253 {"separator", required_argument, 0, IDX_SEPARATOR},
5254 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5255 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5256 {"increment", no_argument, 0, IDX_INCREMENT},
5257 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5258 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5259 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5260 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5261 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5262 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5263
5264 {0, 0, 0, 0}
5265 };
5266
5267 uint rp_files_cnt = 0;
5268
5269 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5270
5271 int option_index;
5272 int c;
5273
5274 optind = 1;
5275 optopt = 0;
5276 option_index = 0;
5277
5278 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5279 {
5280 switch (c)
5281 {
5282 case IDX_HELP: usage = 1; break;
5283 case IDX_VERSION:
5284 case IDX_VERSION_LOWER: version = 1; break;
5285 case IDX_RESTORE: restore = 1; break;
5286 case IDX_SESSION: session = optarg; break;
5287 case IDX_SHOW: show = 1; break;
5288 case IDX_LEFT: left = 1; break;
5289 case '?': return (-1);
5290 }
5291 }
5292
5293 if (optopt != 0)
5294 {
5295 log_error ("ERROR: Invalid argument specified");
5296
5297 return (-1);
5298 }
5299
5300 /**
5301 * exit functions
5302 */
5303
5304 if (version)
5305 {
5306 log_info (VERSION_TXT);
5307
5308 return (0);
5309 }
5310
5311 if (usage)
5312 {
5313 usage_big_print (PROGNAME);
5314
5315 return (0);
5316 }
5317
5318 /**
5319 * session needs to be set, always!
5320 */
5321
5322 if (session == NULL) session = (char *) PROGNAME;
5323
5324 /**
5325 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5326 */
5327
5328 char *exec_path = get_exec_path ();
5329
5330 #ifdef LINUX
5331
5332 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5333 char *resolved_exec_path = realpath (exec_path, NULL);
5334
5335 char *install_dir = get_install_dir (resolved_exec_path);
5336 char *profile_dir = NULL;
5337 char *session_dir = NULL;
5338 char *shared_dir = NULL;
5339
5340 if (strcmp (install_dir, resolved_install_folder) == 0)
5341 {
5342 struct passwd *pw = getpwuid (getuid ());
5343
5344 const char *homedir = pw->pw_dir;
5345
5346 profile_dir = get_profile_dir (homedir);
5347 session_dir = get_session_dir (profile_dir);
5348 shared_dir = strdup (SHARED_FOLDER);
5349
5350 mkdir (profile_dir, 0700);
5351 mkdir (session_dir, 0700);
5352 }
5353 else
5354 {
5355 profile_dir = install_dir;
5356 session_dir = install_dir;
5357 shared_dir = install_dir;
5358 }
5359
5360 myfree (resolved_install_folder);
5361 myfree (resolved_exec_path);
5362
5363 #else
5364
5365 char *install_dir = get_install_dir (exec_path);
5366 char *profile_dir = install_dir;
5367 char *session_dir = install_dir;
5368 char *shared_dir = install_dir;
5369
5370 #endif
5371
5372 data.install_dir = install_dir;
5373 data.profile_dir = profile_dir;
5374 data.session_dir = session_dir;
5375 data.shared_dir = shared_dir;
5376
5377 myfree (exec_path);
5378
5379 /**
5380 * session
5381 */
5382
5383 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5384
5385 data.session = session;
5386
5387 char *eff_restore_file = (char *) mymalloc (session_size);
5388 char *new_restore_file = (char *) mymalloc (session_size);
5389
5390 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5391 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5392
5393 data.eff_restore_file = eff_restore_file;
5394 data.new_restore_file = new_restore_file;
5395
5396 if (((show == 1) || (left == 1)) && (restore == 1))
5397 {
5398 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5399 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5400
5401 return (-1);
5402 }
5403
5404 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5405 if ((show == 1) || (left == 1))
5406 {
5407 restore_disable = 1;
5408
5409 restore = 0;
5410 }
5411
5412 data.restore_disable = restore_disable;
5413
5414 restore_data_t *rd = init_restore (argc, argv);
5415
5416 data.rd = rd;
5417
5418 /**
5419 * restore file
5420 */
5421
5422 if (restore == 1)
5423 {
5424 read_restore (eff_restore_file, rd);
5425
5426 if (rd->version_bin < RESTORE_MIN)
5427 {
5428 log_error ("ERROR: Incompatible restore-file version");
5429
5430 return (-1);
5431 }
5432
5433 myargc = rd->argc;
5434 myargv = rd->argv;
5435
5436 #ifdef _POSIX
5437 rd->pid = getpid ();
5438 #elif _WIN
5439 rd->pid = GetCurrentProcessId ();
5440 #endif
5441 }
5442
5443 uint hash_mode_chgd = 0;
5444 uint runtime_chgd = 0;
5445 uint kernel_loops_chgd = 0;
5446 uint kernel_accel_chgd = 0;
5447 uint attack_mode_chgd = 0;
5448 uint outfile_format_chgd = 0;
5449 uint rp_gen_seed_chgd = 0;
5450 uint remove_timer_chgd = 0;
5451 uint increment_min_chgd = 0;
5452 uint increment_max_chgd = 0;
5453 uint gpu_temp_abort_chgd = 0;
5454 uint gpu_temp_retain_chgd = 0;
5455
5456 optind = 1;
5457 optopt = 0;
5458 option_index = 0;
5459
5460 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5461 {
5462 switch (c)
5463 {
5464 //case IDX_HELP: usage = 1; break;
5465 //case IDX_VERSION: version = 1; break;
5466 //case IDX_RESTORE: restore = 1; break;
5467 case IDX_QUIET: quiet = 1; break;
5468 //case IDX_SHOW: show = 1; break;
5469 case IDX_SHOW: break;
5470 //case IDX_LEFT: left = 1; break;
5471 case IDX_LEFT: break;
5472 case IDX_USERNAME: username = 1; break;
5473 case IDX_REMOVE: remove = 1; break;
5474 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5475 remove_timer_chgd = 1; break;
5476 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5477 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5478 case IDX_DEBUG_FILE: debug_file = optarg; break;
5479 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5480 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5481 case IDX_FORCE: force = 1; break;
5482 case IDX_SKIP: skip = atoll (optarg); break;
5483 case IDX_LIMIT: limit = atoll (optarg); break;
5484 case IDX_KEYSPACE: keyspace = 1; break;
5485 case IDX_BENCHMARK: benchmark = 1; break;
5486 case IDX_BENCHMARK_MODE: benchmark_mode = atoi (optarg); break;
5487 case IDX_RESTORE: break;
5488 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5489 case IDX_STATUS: status = 1; break;
5490 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5491 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5492 case IDX_LOOPBACK: loopback = 1; break;
5493 case IDX_WEAK_HASH_THRESHOLD:
5494 weak_hash_threshold = atoi (optarg); break;
5495 //case IDX_SESSION: session = optarg; break;
5496 case IDX_SESSION: break;
5497 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5498 hash_mode_chgd = 1; break;
5499 case IDX_RUNTIME: runtime = atoi (optarg);
5500 runtime_chgd = 1; break;
5501 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5502 attack_mode_chgd = 1; break;
5503 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5504 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5505 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5506 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5507 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5508 rp_gen_seed_chgd = 1; break;
5509 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5510 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5511 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5512 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5513 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5514 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5515 case IDX_OUTFILE: outfile = optarg; break;
5516 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5517 outfile_format_chgd = 1; break;
5518 case IDX_OUTFILE_AUTOHEX_DISABLE:
5519 outfile_autohex = 0; break;
5520 case IDX_OUTFILE_CHECK_TIMER:
5521 outfile_check_timer = atoi (optarg); break;
5522 case IDX_HEX_CHARSET: hex_charset = 1; break;
5523 case IDX_HEX_SALT: hex_salt = 1; break;
5524 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5525 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5526 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5527 case IDX_OPENCL_PLATFORM: opencl_platform = optarg; break;
5528 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg); break;
5529 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5530 kernel_accel_chgd = 1; break;
5531 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5532 kernel_loops_chgd = 1; break;
5533 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5534 case IDX_GPU_TEMP_ABORT: gpu_temp_abort_chgd = 1;
5535 gpu_temp_abort = atoi (optarg); break;
5536 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain_chgd = 1;
5537 gpu_temp_retain = atoi (optarg); break;
5538 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5539 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5540 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5541 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5542 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5543 case IDX_SEPARATOR: separator = optarg[0]; break;
5544 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5545 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5546 case IDX_INCREMENT: increment = 1; break;
5547 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5548 increment_min_chgd = 1; break;
5549 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5550 increment_max_chgd = 1; break;
5551 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5552 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5553 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5554 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5555
5556 default:
5557 log_error ("ERROR: Invalid argument specified");
5558 return (-1);
5559 }
5560 }
5561
5562 if (optopt != 0)
5563 {
5564 log_error ("ERROR: Invalid argument specified");
5565
5566 return (-1);
5567 }
5568
5569 /**
5570 * Inform user things getting started,
5571 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5572 * - we do not need to check algorithm_pos
5573 */
5574
5575 if (quiet == 0)
5576 {
5577 if (benchmark == 1)
5578 {
5579 log_info ("%s v%.2f starting in benchmark-mode...", PROGNAME, (float) VERSION_BIN / 100);
5580
5581 log_info ("");
5582 }
5583 else if (restore == 1)
5584 {
5585 log_info ("%s v%.2f starting in restore-mode...", PROGNAME, (float) VERSION_BIN / 100);
5586
5587 log_info ("");
5588 }
5589 else
5590 {
5591 log_info ("%s v%.2f starting...", PROGNAME, (float) VERSION_BIN / 100);
5592
5593 log_info ("");
5594 }
5595 }
5596
5597 /**
5598 * sanity check
5599 */
5600
5601 if (attack_mode > 7)
5602 {
5603 log_error ("ERROR: Invalid attack-mode specified");
5604
5605 return (-1);
5606 }
5607
5608 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5609 {
5610 log_error ("ERROR: Invalid runtime specified");
5611
5612 return (-1);
5613 }
5614
5615 if (hash_mode_chgd && hash_mode > 13000) // just added to remove compiler warnings for hash_mode_chgd
5616 {
5617 log_error ("ERROR: Invalid hash-type specified");
5618
5619 return (-1);
5620 }
5621
5622 // renamed hash modes
5623
5624 if (hash_mode_chgd)
5625 {
5626 int n = -1;
5627
5628 switch (hash_mode)
5629 {
5630 case 123: n = 124;
5631 break;
5632 }
5633
5634 if (n >= 0)
5635 {
5636 log_error ("Old -m specified, use -m %d instead", n);
5637
5638 return (-1);
5639 }
5640 }
5641
5642 if (username == 1)
5643 {
5644 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5645 {
5646 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5647
5648 return (-1);
5649 }
5650 }
5651
5652 if (outfile_format > 16)
5653 {
5654 log_error ("ERROR: Invalid outfile-format specified");
5655
5656 return (-1);
5657 }
5658
5659 if (left == 1)
5660 {
5661 if (outfile_format_chgd == 1)
5662 {
5663 if (outfile_format > 1)
5664 {
5665 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5666
5667 return (-1);
5668 }
5669 }
5670 else
5671 {
5672 outfile_format = OUTFILE_FMT_HASH;
5673 }
5674 }
5675
5676 if (show == 1)
5677 {
5678 if (outfile_format_chgd == 1)
5679 {
5680 if ((outfile_format > 7) && (outfile_format < 16))
5681 {
5682 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
5683
5684 return (-1);
5685 }
5686 }
5687 }
5688
5689 if (increment_min < INCREMENT_MIN)
5690 {
5691 log_error ("ERROR: Invalid increment-min specified");
5692
5693 return (-1);
5694 }
5695
5696 if (increment_max > INCREMENT_MAX)
5697 {
5698 log_error ("ERROR: Invalid increment-max specified");
5699
5700 return (-1);
5701 }
5702
5703 if (increment_min > increment_max)
5704 {
5705 log_error ("ERROR: Invalid increment-min specified");
5706
5707 return (-1);
5708 }
5709
5710 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
5711 {
5712 log_error ("ERROR: increment is not allowed in attack-mode 0");
5713
5714 return (-1);
5715 }
5716
5717 if ((increment == 0) && (increment_min_chgd == 1))
5718 {
5719 log_error ("ERROR: increment-min is only supported together with increment switch");
5720
5721 return (-1);
5722 }
5723
5724 if ((increment == 0) && (increment_max_chgd == 1))
5725 {
5726 log_error ("ERROR: increment-max is only supported together with increment switch");
5727
5728 return (-1);
5729 }
5730
5731 if (rp_files_cnt && rp_gen)
5732 {
5733 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
5734
5735 return (-1);
5736 }
5737
5738 if (rp_files_cnt || rp_gen)
5739 {
5740 if (attack_mode != ATTACK_MODE_STRAIGHT)
5741 {
5742 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
5743
5744 return (-1);
5745 }
5746 }
5747
5748 if (rp_gen_func_min > rp_gen_func_max)
5749 {
5750 log_error ("ERROR: Invalid rp-gen-func-min specified");
5751
5752 return (-1);
5753 }
5754
5755 if (kernel_accel_chgd == 1)
5756 {
5757 if (workload_profile != WORKLOAD_PROFILE)
5758 {
5759 log_error ("ERROR: kernel-accel parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5760
5761 return (-1);
5762 }
5763
5764 if (kernel_accel < 1)
5765 {
5766 log_error ("ERROR: Invalid kernel-accel specified");
5767
5768 return (-1);
5769 }
5770
5771 if (kernel_accel > 800)
5772 {
5773 log_error ("ERROR: Invalid kernel-accel specified");
5774
5775 return (-1);
5776 }
5777 }
5778
5779 if (kernel_loops_chgd == 1)
5780 {
5781 if (workload_profile != WORKLOAD_PROFILE)
5782 {
5783 log_error ("ERROR: kernel-loops parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5784
5785 return (-1);
5786 }
5787
5788 if (kernel_loops < 1)
5789 {
5790 log_error ("ERROR: Invalid kernel-loops specified");
5791
5792 return (-1);
5793 }
5794
5795 if (kernel_loops > 1024)
5796 {
5797 log_error ("ERROR: Invalid kernel-loops specified");
5798
5799 return (-1);
5800 }
5801 }
5802
5803 if (benchmark == 1)
5804 {
5805 if (workload_profile != WORKLOAD_PROFILE)
5806 {
5807 log_error ("ERROR: Using the workload-profile in benchmark mode is not allowed");
5808
5809 return (-1);
5810 }
5811 }
5812
5813 if ((workload_profile < 1) || (workload_profile > 3))
5814 {
5815 log_error ("ERROR: workload-profile %i not available", workload_profile);
5816
5817 return (-1);
5818 }
5819
5820 if (show == 1 || left == 1)
5821 {
5822 attack_mode = ATTACK_MODE_NONE;
5823
5824 if (remove == 1)
5825 {
5826 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
5827
5828 return (-1);
5829 }
5830
5831 if (potfile_disable == 1)
5832 {
5833 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
5834
5835 return (-1);
5836 }
5837 }
5838
5839 uint attack_kern = ATTACK_KERN_NONE;
5840
5841 switch (attack_mode)
5842 {
5843 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
5844 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
5845 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
5846 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
5847 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
5848 }
5849
5850 if (benchmark == 0)
5851 {
5852 if (keyspace == 1)
5853 {
5854 int num_additional_params = 1;
5855
5856 if (attack_kern == ATTACK_KERN_COMBI)
5857 {
5858 num_additional_params = 2;
5859 }
5860
5861 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
5862
5863 if (keyspace_wordlist_specified == 0) optind--;
5864 }
5865
5866 if (attack_kern == ATTACK_KERN_NONE)
5867 {
5868 if ((optind + 1) != myargc)
5869 {
5870 usage_mini_print (myargv[0]);
5871
5872 return (-1);
5873 }
5874 }
5875 else if (attack_kern == ATTACK_KERN_STRAIGHT)
5876 {
5877 if ((optind + 1) > myargc)
5878 {
5879 usage_mini_print (myargv[0]);
5880
5881 return (-1);
5882 }
5883 }
5884 else if (attack_kern == ATTACK_KERN_COMBI)
5885 {
5886 if ((optind + 3) != myargc)
5887 {
5888 usage_mini_print (myargv[0]);
5889
5890 return (-1);
5891 }
5892 }
5893 else if (attack_kern == ATTACK_KERN_BF)
5894 {
5895 if ((optind + 1) > myargc)
5896 {
5897 usage_mini_print (myargv[0]);
5898
5899 return (-1);
5900 }
5901 }
5902 else
5903 {
5904 usage_mini_print (myargv[0]);
5905
5906 return (-1);
5907 }
5908 }
5909 else
5910 {
5911 if (myargv[optind] != 0)
5912 {
5913 log_error ("ERROR: Invalid argument for benchmark mode specified");
5914
5915 return (-1);
5916 }
5917
5918 if (attack_mode_chgd == 1)
5919 {
5920 if (attack_mode != ATTACK_MODE_BF)
5921 {
5922 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
5923
5924 return (-1);
5925 }
5926 }
5927
5928 if (benchmark_mode == 0)
5929 {
5930 // nothing to do
5931 }
5932 else if (benchmark_mode == 1)
5933 {
5934 if (kernel_accel_chgd == 1 || kernel_loops_chgd == 1)
5935 {
5936 log_error ("ERROR: Benchmark-mode 1 does not allow kernel-accel or kernel-loops changed");
5937
5938 return (-1);
5939 }
5940 }
5941 else
5942 {
5943 log_error ("ERROR: Benchmark-mode must be 0 or 1");
5944
5945 return (-1);
5946 }
5947 }
5948
5949 if (skip != 0 && limit != 0)
5950 {
5951 limit += skip;
5952 }
5953
5954 if (keyspace == 1)
5955 {
5956 if (show == 1)
5957 {
5958 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
5959
5960 return (-1);
5961 }
5962 else if (left == 1)
5963 {
5964 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
5965
5966 return (-1);
5967 }
5968
5969 potfile_disable = 1;
5970
5971 restore_disable = 1;
5972
5973 restore = 0;
5974
5975 weak_hash_threshold = 0;
5976
5977 quiet = 1;
5978 }
5979
5980 if (remove_timer_chgd == 1)
5981 {
5982 if (remove == 0)
5983 {
5984 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
5985
5986 return (-1);
5987 }
5988
5989 if (remove_timer < 1)
5990 {
5991 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
5992
5993 return (-1);
5994 }
5995 }
5996
5997 if (loopback == 1)
5998 {
5999 if (attack_mode == ATTACK_MODE_BF)
6000 {
6001 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6002
6003 return (-1);
6004 }
6005 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6006 {
6007 if ((rp_files_cnt == 0) && (rp_gen == 0))
6008 {
6009 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6010
6011 return (-1);
6012 }
6013 }
6014 }
6015
6016 if (debug_mode > 0)
6017 {
6018 if (attack_mode != ATTACK_MODE_STRAIGHT)
6019 {
6020 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6021
6022 return (-1);
6023 }
6024
6025 if ((rp_files_cnt == 0) && (rp_gen == 0))
6026 {
6027 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6028
6029 return (-1);
6030 }
6031 }
6032
6033 if (debug_mode > 4)
6034 {
6035 log_error ("ERROR: Invalid debug-mode specified");
6036
6037 return (-1);
6038 }
6039
6040 if (debug_file != NULL)
6041 {
6042 if (debug_mode < 1)
6043 {
6044 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6045
6046 return (-1);
6047 }
6048 }
6049
6050 if (induction_dir != NULL)
6051 {
6052 if (attack_mode == ATTACK_MODE_BF)
6053 {
6054 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6055
6056 return (-1);
6057 }
6058 }
6059
6060 /**
6061 * induction directory
6062 */
6063
6064 char *induction_directory = NULL;
6065
6066 if (attack_mode != ATTACK_MODE_BF)
6067 {
6068 if (induction_dir == NULL)
6069 {
6070 induction_directory = (char *) mymalloc (session_size);
6071
6072 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6073
6074 // create induction folder if it does not already exist
6075
6076 if (keyspace == 0)
6077 {
6078 if (rmdir (induction_directory) == -1)
6079 {
6080 if (errno == ENOENT)
6081 {
6082 // good, we can ignore
6083 }
6084 else if (errno == ENOTEMPTY)
6085 {
6086 char *induction_directory_mv = (char *) mymalloc (session_size);
6087
6088 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6089
6090 if (rename (induction_directory, induction_directory_mv) != 0)
6091 {
6092 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6093
6094 return (-1);
6095 }
6096 }
6097 else
6098 {
6099 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6100
6101 return (-1);
6102 }
6103 }
6104
6105 if (mkdir (induction_directory, 0700) == -1)
6106 {
6107 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6108
6109 return (-1);
6110 }
6111 }
6112 }
6113 else
6114 {
6115 induction_directory = induction_dir;
6116 }
6117 }
6118
6119 data.induction_directory = induction_directory;
6120
6121 /**
6122 * loopback
6123 */
6124
6125 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6126
6127 char *loopback_file = (char *) mymalloc (loopback_size);
6128
6129 /**
6130 * outfile-check directory
6131 */
6132
6133 char *outfile_check_directory = NULL;
6134
6135 if (outfile_check_dir == NULL)
6136 {
6137 outfile_check_directory = (char *) mymalloc (session_size);
6138
6139 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6140 }
6141 else
6142 {
6143 outfile_check_directory = outfile_check_dir;
6144 }
6145
6146 data.outfile_check_directory = outfile_check_directory;
6147
6148 if (keyspace == 0)
6149 {
6150 struct stat outfile_check_stat;
6151
6152 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6153 {
6154 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6155
6156 if (is_dir == 0)
6157 {
6158 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6159
6160 return (-1);
6161 }
6162 }
6163 else if (outfile_check_dir == NULL)
6164 {
6165 if (mkdir (outfile_check_directory, 0700) == -1)
6166 {
6167 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6168
6169 return (-1);
6170 }
6171 }
6172 }
6173
6174 /**
6175 * special other stuff
6176 */
6177
6178 if (hash_mode == 9710)
6179 {
6180 outfile_format = 5;
6181 outfile_format_chgd = 1;
6182 }
6183
6184 if (hash_mode == 9810)
6185 {
6186 outfile_format = 5;
6187 outfile_format_chgd = 1;
6188 }
6189
6190 if (hash_mode == 10410)
6191 {
6192 outfile_format = 5;
6193 outfile_format_chgd = 1;
6194 }
6195
6196 /**
6197 * store stuff
6198 */
6199
6200 data.hash_mode = hash_mode;
6201 data.restore = restore;
6202 data.restore_timer = restore_timer;
6203 data.restore_disable = restore_disable;
6204 data.status = status;
6205 data.status_timer = status_timer;
6206 data.status_automat = status_automat;
6207 data.loopback = loopback;
6208 data.runtime = runtime;
6209 data.remove = remove;
6210 data.remove_timer = remove_timer;
6211 data.debug_mode = debug_mode;
6212 data.debug_file = debug_file;
6213 data.username = username;
6214 data.quiet = quiet;
6215 data.outfile = outfile;
6216 data.outfile_format = outfile_format;
6217 data.outfile_autohex = outfile_autohex;
6218 data.hex_charset = hex_charset;
6219 data.hex_salt = hex_salt;
6220 data.hex_wordlist = hex_wordlist;
6221 data.separator = separator;
6222 data.rp_files = rp_files;
6223 data.rp_files_cnt = rp_files_cnt;
6224 data.rp_gen = rp_gen;
6225 data.rp_gen_seed = rp_gen_seed;
6226 data.force = force;
6227 data.benchmark = benchmark;
6228 data.skip = skip;
6229 data.limit = limit;
6230 data.powertune_enable = powertune_enable;
6231 data.logfile_disable = logfile_disable;
6232 data.truecrypt_keyfiles = truecrypt_keyfiles;
6233 data.scrypt_tmto = scrypt_tmto;
6234
6235 /**
6236 * cpu affinity
6237 */
6238
6239 if (cpu_affinity)
6240 {
6241 set_cpu_affinity (cpu_affinity);
6242 }
6243
6244 if (rp_gen_seed_chgd == 0)
6245 {
6246 srand (proc_start);
6247 }
6248 else
6249 {
6250 srand (rp_gen_seed);
6251 }
6252
6253 /**
6254 * logfile init
6255 */
6256
6257 if (logfile_disable == 0)
6258 {
6259 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6260
6261 char *logfile = (char *) mymalloc (logfile_size);
6262
6263 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6264
6265 data.logfile = logfile;
6266
6267 char *topid = logfile_generate_topid ();
6268
6269 data.topid = topid;
6270 }
6271
6272 // logfile_append() checks for logfile_disable internally to make it easier from here
6273
6274 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6275 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6276 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6277 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6278 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6279 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6280 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6281 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6282 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6283 #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));
6284
6285 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6286 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6287 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6288 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6289 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6290 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6291 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6292 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6293
6294 logfile_top_msg ("START");
6295
6296 logfile_top_uint (attack_mode);
6297 logfile_top_uint (attack_kern);
6298 logfile_top_uint (benchmark);
6299 logfile_top_uint (benchmark_mode);
6300 logfile_top_uint (bitmap_min);
6301 logfile_top_uint (bitmap_max);
6302 logfile_top_uint (debug_mode);
6303 logfile_top_uint (force);
6304 logfile_top_uint (kernel_accel);
6305 logfile_top_uint (kernel_loops);
6306 logfile_top_uint (gpu_temp_abort);
6307 logfile_top_uint (gpu_temp_disable);
6308 logfile_top_uint (gpu_temp_retain);
6309 logfile_top_uint (hash_mode);
6310 logfile_top_uint (hex_charset);
6311 logfile_top_uint (hex_salt);
6312 logfile_top_uint (hex_wordlist);
6313 logfile_top_uint (increment);
6314 logfile_top_uint (increment_max);
6315 logfile_top_uint (increment_min);
6316 logfile_top_uint (keyspace);
6317 logfile_top_uint (left);
6318 logfile_top_uint (logfile_disable);
6319 logfile_top_uint (loopback);
6320 logfile_top_uint (markov_classic);
6321 logfile_top_uint (markov_disable);
6322 logfile_top_uint (markov_threshold);
6323 logfile_top_uint (outfile_autohex);
6324 logfile_top_uint (outfile_check_timer);
6325 logfile_top_uint (outfile_format);
6326 logfile_top_uint (potfile_disable);
6327 logfile_top_uint (powertune_enable);
6328 logfile_top_uint (scrypt_tmto);
6329 logfile_top_uint (quiet);
6330 logfile_top_uint (remove);
6331 logfile_top_uint (remove_timer);
6332 logfile_top_uint (restore);
6333 logfile_top_uint (restore_disable);
6334 logfile_top_uint (restore_timer);
6335 logfile_top_uint (rp_gen);
6336 logfile_top_uint (rp_gen_func_max);
6337 logfile_top_uint (rp_gen_func_min);
6338 logfile_top_uint (rp_gen_seed);
6339 logfile_top_uint (runtime);
6340 logfile_top_uint (segment_size);
6341 logfile_top_uint (show);
6342 logfile_top_uint (status);
6343 logfile_top_uint (status_automat);
6344 logfile_top_uint (status_timer);
6345 logfile_top_uint (usage);
6346 logfile_top_uint (username);
6347 logfile_top_uint (version);
6348 logfile_top_uint (weak_hash_threshold);
6349 logfile_top_uint (workload_profile);
6350 logfile_top_uint64 (limit);
6351 logfile_top_uint64 (skip);
6352 logfile_top_char (separator);
6353 logfile_top_string (cpu_affinity);
6354 logfile_top_string (custom_charset_1);
6355 logfile_top_string (custom_charset_2);
6356 logfile_top_string (custom_charset_3);
6357 logfile_top_string (custom_charset_4);
6358 logfile_top_string (debug_file);
6359 logfile_top_string (opencl_devices);
6360 logfile_top_string (opencl_platform);
6361 logfile_top_string (induction_dir);
6362 logfile_top_string (markov_hcstat);
6363 logfile_top_string (outfile);
6364 logfile_top_string (outfile_check_dir);
6365 logfile_top_string (rule_buf_l);
6366 logfile_top_string (rule_buf_r);
6367 logfile_top_string (session);
6368 logfile_top_string (truecrypt_keyfiles);
6369
6370 /**
6371 * devices
6372 */
6373
6374 uint opencl_devicemask = devices_to_devicemask (opencl_devices);
6375
6376 /**
6377 * benchmark
6378 */
6379
6380 if (benchmark == 1)
6381 {
6382 /**
6383 * disable useless stuff for benchmark
6384 */
6385
6386 restore_timer = 0;
6387 status_timer = 0;
6388 restore_disable = 1;
6389 potfile_disable = 1;
6390 weak_hash_threshold = 0;
6391
6392 data.restore_timer = restore_timer;
6393 data.status_timer = status_timer;
6394 data.restore_disable = restore_disable;
6395
6396 if (benchmark_mode == 1)
6397 {
6398 markov_disable = 1;
6399 }
6400
6401 /**
6402 * force attack mode to be bruteforce
6403 */
6404
6405 attack_mode = ATTACK_MODE_BF;
6406 attack_kern = ATTACK_KERN_BF;
6407
6408 if (runtime_chgd == 0)
6409 {
6410 runtime = 4;
6411
6412 if (benchmark_mode == 1) runtime = 17;
6413
6414 data.runtime = runtime;
6415 }
6416 }
6417
6418 /**
6419 * config
6420 */
6421
6422 uint hash_type = 0;
6423 uint salt_type = 0;
6424 uint attack_exec = 0;
6425 uint opts_type = 0;
6426 uint kern_type = 0;
6427 uint dgst_size = 0;
6428 uint esalt_size = 0;
6429 uint opti_type = 0;
6430 uint dgst_pos0 = -1;
6431 uint dgst_pos1 = -1;
6432 uint dgst_pos2 = -1;
6433 uint dgst_pos3 = -1;
6434
6435 int (*parse_func) (char *, uint, hash_t *);
6436 int (*sort_by_digest) (const void *, const void *);
6437
6438 uint algorithm_pos = 0;
6439 uint algorithm_max = 1;
6440
6441 uint *algorithms = default_benchmark_algorithms;
6442
6443 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6444
6445 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6446 {
6447 /*
6448 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6449 * the following algos are skipped entirely
6450 */
6451
6452 if (algorithm_pos > 0)
6453 {
6454 local_free (rd);
6455
6456 rd = init_restore (argc, argv);
6457
6458 data.rd = rd;
6459 }
6460
6461 /**
6462 * update hash_mode in case of multihash benchmark
6463 */
6464
6465 if (benchmark == 1)
6466 {
6467 if (hash_mode_chgd == 0)
6468 {
6469 hash_mode = algorithms[algorithm_pos];
6470
6471 data.hash_mode = hash_mode;
6472 }
6473
6474 quiet = 1;
6475
6476 data.quiet = quiet;
6477 }
6478
6479 switch (hash_mode)
6480 {
6481 case 0: hash_type = HASH_TYPE_MD5;
6482 salt_type = SALT_TYPE_NONE;
6483 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6484 opts_type = OPTS_TYPE_PT_GENERATE_LE
6485 | OPTS_TYPE_PT_ADD80
6486 | OPTS_TYPE_PT_ADDBITS14;
6487 kern_type = KERN_TYPE_MD5;
6488 dgst_size = DGST_SIZE_4_4;
6489 parse_func = md5_parse_hash;
6490 sort_by_digest = sort_by_digest_4_4;
6491 opti_type = OPTI_TYPE_ZERO_BYTE
6492 | OPTI_TYPE_PRECOMPUTE_INIT
6493 | OPTI_TYPE_PRECOMPUTE_MERKLE
6494 | OPTI_TYPE_MEET_IN_MIDDLE
6495 | OPTI_TYPE_EARLY_SKIP
6496 | OPTI_TYPE_NOT_ITERATED
6497 | OPTI_TYPE_NOT_SALTED
6498 | OPTI_TYPE_RAW_HASH;
6499 dgst_pos0 = 0;
6500 dgst_pos1 = 3;
6501 dgst_pos2 = 2;
6502 dgst_pos3 = 1;
6503 break;
6504
6505 case 10: hash_type = HASH_TYPE_MD5;
6506 salt_type = SALT_TYPE_INTERN;
6507 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6508 opts_type = OPTS_TYPE_PT_GENERATE_LE
6509 | OPTS_TYPE_ST_ADD80
6510 | OPTS_TYPE_ST_ADDBITS14;
6511 kern_type = KERN_TYPE_MD5_PWSLT;
6512 dgst_size = DGST_SIZE_4_4;
6513 parse_func = md5s_parse_hash;
6514 sort_by_digest = sort_by_digest_4_4;
6515 opti_type = OPTI_TYPE_ZERO_BYTE
6516 | OPTI_TYPE_PRECOMPUTE_INIT
6517 | OPTI_TYPE_PRECOMPUTE_MERKLE
6518 | OPTI_TYPE_MEET_IN_MIDDLE
6519 | OPTI_TYPE_EARLY_SKIP
6520 | OPTI_TYPE_NOT_ITERATED
6521 | OPTI_TYPE_APPENDED_SALT
6522 | OPTI_TYPE_RAW_HASH;
6523 dgst_pos0 = 0;
6524 dgst_pos1 = 3;
6525 dgst_pos2 = 2;
6526 dgst_pos3 = 1;
6527 break;
6528
6529 case 11: hash_type = HASH_TYPE_MD5;
6530 salt_type = SALT_TYPE_INTERN;
6531 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6532 opts_type = OPTS_TYPE_PT_GENERATE_LE
6533 | OPTS_TYPE_ST_ADD80
6534 | OPTS_TYPE_ST_ADDBITS14;
6535 kern_type = KERN_TYPE_MD5_PWSLT;
6536 dgst_size = DGST_SIZE_4_4;
6537 parse_func = joomla_parse_hash;
6538 sort_by_digest = sort_by_digest_4_4;
6539 opti_type = OPTI_TYPE_ZERO_BYTE
6540 | OPTI_TYPE_PRECOMPUTE_INIT
6541 | OPTI_TYPE_PRECOMPUTE_MERKLE
6542 | OPTI_TYPE_MEET_IN_MIDDLE
6543 | OPTI_TYPE_EARLY_SKIP
6544 | OPTI_TYPE_NOT_ITERATED
6545 | OPTI_TYPE_APPENDED_SALT
6546 | OPTI_TYPE_RAW_HASH;
6547 dgst_pos0 = 0;
6548 dgst_pos1 = 3;
6549 dgst_pos2 = 2;
6550 dgst_pos3 = 1;
6551 break;
6552
6553 case 12: hash_type = HASH_TYPE_MD5;
6554 salt_type = SALT_TYPE_INTERN;
6555 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6556 opts_type = OPTS_TYPE_PT_GENERATE_LE
6557 | OPTS_TYPE_ST_ADD80
6558 | OPTS_TYPE_ST_ADDBITS14;
6559 kern_type = KERN_TYPE_MD5_PWSLT;
6560 dgst_size = DGST_SIZE_4_4;
6561 parse_func = postgresql_parse_hash;
6562 sort_by_digest = sort_by_digest_4_4;
6563 opti_type = OPTI_TYPE_ZERO_BYTE
6564 | OPTI_TYPE_PRECOMPUTE_INIT
6565 | OPTI_TYPE_PRECOMPUTE_MERKLE
6566 | OPTI_TYPE_MEET_IN_MIDDLE
6567 | OPTI_TYPE_EARLY_SKIP
6568 | OPTI_TYPE_NOT_ITERATED
6569 | OPTI_TYPE_APPENDED_SALT
6570 | OPTI_TYPE_RAW_HASH;
6571 dgst_pos0 = 0;
6572 dgst_pos1 = 3;
6573 dgst_pos2 = 2;
6574 dgst_pos3 = 1;
6575 break;
6576
6577 case 20: hash_type = HASH_TYPE_MD5;
6578 salt_type = SALT_TYPE_INTERN;
6579 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6580 opts_type = OPTS_TYPE_PT_GENERATE_LE
6581 | OPTS_TYPE_PT_ADD80
6582 | OPTS_TYPE_PT_ADDBITS14;
6583 kern_type = KERN_TYPE_MD5_SLTPW;
6584 dgst_size = DGST_SIZE_4_4;
6585 parse_func = md5s_parse_hash;
6586 sort_by_digest = sort_by_digest_4_4;
6587 opti_type = OPTI_TYPE_ZERO_BYTE
6588 | OPTI_TYPE_PRECOMPUTE_INIT
6589 | OPTI_TYPE_PRECOMPUTE_MERKLE
6590 | OPTI_TYPE_EARLY_SKIP
6591 | OPTI_TYPE_NOT_ITERATED
6592 | OPTI_TYPE_PREPENDED_SALT
6593 | OPTI_TYPE_RAW_HASH;
6594 dgst_pos0 = 0;
6595 dgst_pos1 = 3;
6596 dgst_pos2 = 2;
6597 dgst_pos3 = 1;
6598 break;
6599
6600 case 21: hash_type = HASH_TYPE_MD5;
6601 salt_type = SALT_TYPE_INTERN;
6602 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6603 opts_type = OPTS_TYPE_PT_GENERATE_LE
6604 | OPTS_TYPE_PT_ADD80
6605 | OPTS_TYPE_PT_ADDBITS14;
6606 kern_type = KERN_TYPE_MD5_SLTPW;
6607 dgst_size = DGST_SIZE_4_4;
6608 parse_func = osc_parse_hash;
6609 sort_by_digest = sort_by_digest_4_4;
6610 opti_type = OPTI_TYPE_ZERO_BYTE
6611 | OPTI_TYPE_PRECOMPUTE_INIT
6612 | OPTI_TYPE_PRECOMPUTE_MERKLE
6613 | OPTI_TYPE_EARLY_SKIP
6614 | OPTI_TYPE_NOT_ITERATED
6615 | OPTI_TYPE_PREPENDED_SALT
6616 | OPTI_TYPE_RAW_HASH;
6617 dgst_pos0 = 0;
6618 dgst_pos1 = 3;
6619 dgst_pos2 = 2;
6620 dgst_pos3 = 1;
6621 break;
6622
6623 case 22: hash_type = HASH_TYPE_MD5;
6624 salt_type = SALT_TYPE_EMBEDDED;
6625 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6626 opts_type = OPTS_TYPE_PT_GENERATE_LE
6627 | OPTS_TYPE_PT_ADD80
6628 | OPTS_TYPE_PT_ADDBITS14;
6629 kern_type = KERN_TYPE_MD5_SLTPW;
6630 dgst_size = DGST_SIZE_4_4;
6631 parse_func = netscreen_parse_hash;
6632 sort_by_digest = sort_by_digest_4_4;
6633 opti_type = OPTI_TYPE_ZERO_BYTE
6634 | OPTI_TYPE_PRECOMPUTE_INIT
6635 | OPTI_TYPE_PRECOMPUTE_MERKLE
6636 | OPTI_TYPE_EARLY_SKIP
6637 | OPTI_TYPE_NOT_ITERATED
6638 | OPTI_TYPE_PREPENDED_SALT
6639 | OPTI_TYPE_RAW_HASH;
6640 dgst_pos0 = 0;
6641 dgst_pos1 = 3;
6642 dgst_pos2 = 2;
6643 dgst_pos3 = 1;
6644 break;
6645
6646 case 23: hash_type = HASH_TYPE_MD5;
6647 salt_type = SALT_TYPE_EMBEDDED;
6648 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6649 opts_type = OPTS_TYPE_PT_GENERATE_LE
6650 | OPTS_TYPE_PT_ADD80
6651 | OPTS_TYPE_PT_ADDBITS14;
6652 kern_type = KERN_TYPE_MD5_SLTPW;
6653 dgst_size = DGST_SIZE_4_4;
6654 parse_func = skype_parse_hash;
6655 sort_by_digest = sort_by_digest_4_4;
6656 opti_type = OPTI_TYPE_ZERO_BYTE
6657 | OPTI_TYPE_PRECOMPUTE_INIT
6658 | OPTI_TYPE_PRECOMPUTE_MERKLE
6659 | OPTI_TYPE_EARLY_SKIP
6660 | OPTI_TYPE_NOT_ITERATED
6661 | OPTI_TYPE_PREPENDED_SALT
6662 | OPTI_TYPE_RAW_HASH;
6663 dgst_pos0 = 0;
6664 dgst_pos1 = 3;
6665 dgst_pos2 = 2;
6666 dgst_pos3 = 1;
6667 break;
6668
6669 case 30: hash_type = HASH_TYPE_MD5;
6670 salt_type = SALT_TYPE_INTERN;
6671 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6672 opts_type = OPTS_TYPE_PT_GENERATE_LE
6673 | OPTS_TYPE_PT_UNICODE
6674 | OPTS_TYPE_ST_ADD80
6675 | OPTS_TYPE_ST_ADDBITS14;
6676 kern_type = KERN_TYPE_MD5_PWUSLT;
6677 dgst_size = DGST_SIZE_4_4;
6678 parse_func = md5s_parse_hash;
6679 sort_by_digest = sort_by_digest_4_4;
6680 opti_type = OPTI_TYPE_ZERO_BYTE
6681 | OPTI_TYPE_PRECOMPUTE_INIT
6682 | OPTI_TYPE_PRECOMPUTE_MERKLE
6683 | OPTI_TYPE_MEET_IN_MIDDLE
6684 | OPTI_TYPE_EARLY_SKIP
6685 | OPTI_TYPE_NOT_ITERATED
6686 | OPTI_TYPE_APPENDED_SALT
6687 | OPTI_TYPE_RAW_HASH;
6688 dgst_pos0 = 0;
6689 dgst_pos1 = 3;
6690 dgst_pos2 = 2;
6691 dgst_pos3 = 1;
6692 break;
6693
6694 case 40: hash_type = HASH_TYPE_MD5;
6695 salt_type = SALT_TYPE_INTERN;
6696 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6697 opts_type = OPTS_TYPE_PT_GENERATE_LE
6698 | OPTS_TYPE_PT_ADD80
6699 | OPTS_TYPE_PT_ADDBITS14
6700 | OPTS_TYPE_PT_UNICODE;
6701 kern_type = KERN_TYPE_MD5_SLTPWU;
6702 dgst_size = DGST_SIZE_4_4;
6703 parse_func = md5s_parse_hash;
6704 sort_by_digest = sort_by_digest_4_4;
6705 opti_type = OPTI_TYPE_ZERO_BYTE
6706 | OPTI_TYPE_PRECOMPUTE_INIT
6707 | OPTI_TYPE_PRECOMPUTE_MERKLE
6708 | OPTI_TYPE_EARLY_SKIP
6709 | OPTI_TYPE_NOT_ITERATED
6710 | OPTI_TYPE_PREPENDED_SALT
6711 | OPTI_TYPE_RAW_HASH;
6712 dgst_pos0 = 0;
6713 dgst_pos1 = 3;
6714 dgst_pos2 = 2;
6715 dgst_pos3 = 1;
6716 break;
6717
6718 case 50: hash_type = HASH_TYPE_MD5;
6719 salt_type = SALT_TYPE_INTERN;
6720 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6721 opts_type = OPTS_TYPE_PT_GENERATE_LE
6722 | OPTS_TYPE_ST_ADD80
6723 | OPTS_TYPE_ST_ADDBITS14;
6724 kern_type = KERN_TYPE_HMACMD5_PW;
6725 dgst_size = DGST_SIZE_4_4;
6726 parse_func = hmacmd5_parse_hash;
6727 sort_by_digest = sort_by_digest_4_4;
6728 opti_type = OPTI_TYPE_ZERO_BYTE
6729 | OPTI_TYPE_NOT_ITERATED;
6730 dgst_pos0 = 0;
6731 dgst_pos1 = 3;
6732 dgst_pos2 = 2;
6733 dgst_pos3 = 1;
6734 break;
6735
6736 case 60: hash_type = HASH_TYPE_MD5;
6737 salt_type = SALT_TYPE_INTERN;
6738 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6739 opts_type = OPTS_TYPE_PT_GENERATE_LE
6740 | OPTS_TYPE_PT_ADD80
6741 | OPTS_TYPE_PT_ADDBITS14;
6742 kern_type = KERN_TYPE_HMACMD5_SLT;
6743 dgst_size = DGST_SIZE_4_4;
6744 parse_func = hmacmd5_parse_hash;
6745 sort_by_digest = sort_by_digest_4_4;
6746 opti_type = OPTI_TYPE_ZERO_BYTE
6747 | OPTI_TYPE_NOT_ITERATED;
6748 dgst_pos0 = 0;
6749 dgst_pos1 = 3;
6750 dgst_pos2 = 2;
6751 dgst_pos3 = 1;
6752 break;
6753
6754 case 100: hash_type = HASH_TYPE_SHA1;
6755 salt_type = SALT_TYPE_NONE;
6756 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6757 opts_type = OPTS_TYPE_PT_GENERATE_BE
6758 | OPTS_TYPE_PT_ADD80
6759 | OPTS_TYPE_PT_ADDBITS15;
6760 kern_type = KERN_TYPE_SHA1;
6761 dgst_size = DGST_SIZE_4_5;
6762 parse_func = sha1_parse_hash;
6763 sort_by_digest = sort_by_digest_4_5;
6764 opti_type = OPTI_TYPE_ZERO_BYTE
6765 | OPTI_TYPE_PRECOMPUTE_INIT
6766 | OPTI_TYPE_PRECOMPUTE_MERKLE
6767 | OPTI_TYPE_EARLY_SKIP
6768 | OPTI_TYPE_NOT_ITERATED
6769 | OPTI_TYPE_NOT_SALTED
6770 | OPTI_TYPE_RAW_HASH;
6771 dgst_pos0 = 3;
6772 dgst_pos1 = 4;
6773 dgst_pos2 = 2;
6774 dgst_pos3 = 1;
6775 break;
6776
6777 case 101: hash_type = HASH_TYPE_SHA1;
6778 salt_type = SALT_TYPE_NONE;
6779 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6780 opts_type = OPTS_TYPE_PT_GENERATE_BE
6781 | OPTS_TYPE_PT_ADD80
6782 | OPTS_TYPE_PT_ADDBITS15;
6783 kern_type = KERN_TYPE_SHA1;
6784 dgst_size = DGST_SIZE_4_5;
6785 parse_func = sha1b64_parse_hash;
6786 sort_by_digest = sort_by_digest_4_5;
6787 opti_type = OPTI_TYPE_ZERO_BYTE
6788 | OPTI_TYPE_PRECOMPUTE_INIT
6789 | OPTI_TYPE_PRECOMPUTE_MERKLE
6790 | OPTI_TYPE_EARLY_SKIP
6791 | OPTI_TYPE_NOT_ITERATED
6792 | OPTI_TYPE_NOT_SALTED
6793 | OPTI_TYPE_RAW_HASH;
6794 dgst_pos0 = 3;
6795 dgst_pos1 = 4;
6796 dgst_pos2 = 2;
6797 dgst_pos3 = 1;
6798 break;
6799
6800 case 110: hash_type = HASH_TYPE_SHA1;
6801 salt_type = SALT_TYPE_INTERN;
6802 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6803 opts_type = OPTS_TYPE_PT_GENERATE_BE
6804 | OPTS_TYPE_ST_ADD80
6805 | OPTS_TYPE_ST_ADDBITS15;
6806 kern_type = KERN_TYPE_SHA1_PWSLT;
6807 dgst_size = DGST_SIZE_4_5;
6808 parse_func = sha1s_parse_hash;
6809 sort_by_digest = sort_by_digest_4_5;
6810 opti_type = OPTI_TYPE_ZERO_BYTE
6811 | OPTI_TYPE_PRECOMPUTE_INIT
6812 | OPTI_TYPE_PRECOMPUTE_MERKLE
6813 | OPTI_TYPE_EARLY_SKIP
6814 | OPTI_TYPE_NOT_ITERATED
6815 | OPTI_TYPE_APPENDED_SALT
6816 | OPTI_TYPE_RAW_HASH;
6817 dgst_pos0 = 3;
6818 dgst_pos1 = 4;
6819 dgst_pos2 = 2;
6820 dgst_pos3 = 1;
6821 break;
6822
6823 case 111: hash_type = HASH_TYPE_SHA1;
6824 salt_type = SALT_TYPE_EMBEDDED;
6825 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6826 opts_type = OPTS_TYPE_PT_GENERATE_BE
6827 | OPTS_TYPE_ST_ADD80
6828 | OPTS_TYPE_ST_ADDBITS15;
6829 kern_type = KERN_TYPE_SHA1_PWSLT;
6830 dgst_size = DGST_SIZE_4_5;
6831 parse_func = sha1b64s_parse_hash;
6832 sort_by_digest = sort_by_digest_4_5;
6833 opti_type = OPTI_TYPE_ZERO_BYTE
6834 | OPTI_TYPE_PRECOMPUTE_INIT
6835 | OPTI_TYPE_PRECOMPUTE_MERKLE
6836 | OPTI_TYPE_EARLY_SKIP
6837 | OPTI_TYPE_NOT_ITERATED
6838 | OPTI_TYPE_APPENDED_SALT
6839 | OPTI_TYPE_RAW_HASH;
6840 dgst_pos0 = 3;
6841 dgst_pos1 = 4;
6842 dgst_pos2 = 2;
6843 dgst_pos3 = 1;
6844 break;
6845
6846 case 112: hash_type = HASH_TYPE_SHA1;
6847 salt_type = SALT_TYPE_INTERN;
6848 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6849 opts_type = OPTS_TYPE_PT_GENERATE_BE
6850 | OPTS_TYPE_ST_ADD80
6851 | OPTS_TYPE_ST_ADDBITS15
6852 | OPTS_TYPE_ST_HEX;
6853 kern_type = KERN_TYPE_SHA1_PWSLT;
6854 dgst_size = DGST_SIZE_4_5;
6855 parse_func = oracles_parse_hash;
6856 sort_by_digest = sort_by_digest_4_5;
6857 opti_type = OPTI_TYPE_ZERO_BYTE
6858 | OPTI_TYPE_PRECOMPUTE_INIT
6859 | OPTI_TYPE_PRECOMPUTE_MERKLE
6860 | OPTI_TYPE_EARLY_SKIP
6861 | OPTI_TYPE_NOT_ITERATED
6862 | OPTI_TYPE_APPENDED_SALT
6863 | OPTI_TYPE_RAW_HASH;
6864 dgst_pos0 = 3;
6865 dgst_pos1 = 4;
6866 dgst_pos2 = 2;
6867 dgst_pos3 = 1;
6868 break;
6869
6870 case 120: hash_type = HASH_TYPE_SHA1;
6871 salt_type = SALT_TYPE_INTERN;
6872 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6873 opts_type = OPTS_TYPE_PT_GENERATE_BE
6874 | OPTS_TYPE_PT_ADD80
6875 | OPTS_TYPE_PT_ADDBITS15;
6876 kern_type = KERN_TYPE_SHA1_SLTPW;
6877 dgst_size = DGST_SIZE_4_5;
6878 parse_func = sha1s_parse_hash;
6879 sort_by_digest = sort_by_digest_4_5;
6880 opti_type = OPTI_TYPE_ZERO_BYTE
6881 | OPTI_TYPE_PRECOMPUTE_INIT
6882 | OPTI_TYPE_PRECOMPUTE_MERKLE
6883 | OPTI_TYPE_EARLY_SKIP
6884 | OPTI_TYPE_NOT_ITERATED
6885 | OPTI_TYPE_PREPENDED_SALT
6886 | OPTI_TYPE_RAW_HASH;
6887 dgst_pos0 = 3;
6888 dgst_pos1 = 4;
6889 dgst_pos2 = 2;
6890 dgst_pos3 = 1;
6891 break;
6892
6893 case 121: hash_type = HASH_TYPE_SHA1;
6894 salt_type = SALT_TYPE_INTERN;
6895 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6896 opts_type = OPTS_TYPE_PT_GENERATE_BE
6897 | OPTS_TYPE_PT_ADD80
6898 | OPTS_TYPE_PT_ADDBITS15
6899 | OPTS_TYPE_ST_LOWER;
6900 kern_type = KERN_TYPE_SHA1_SLTPW;
6901 dgst_size = DGST_SIZE_4_5;
6902 parse_func = smf_parse_hash;
6903 sort_by_digest = sort_by_digest_4_5;
6904 opti_type = OPTI_TYPE_ZERO_BYTE
6905 | OPTI_TYPE_PRECOMPUTE_INIT
6906 | OPTI_TYPE_PRECOMPUTE_MERKLE
6907 | OPTI_TYPE_EARLY_SKIP
6908 | OPTI_TYPE_NOT_ITERATED
6909 | OPTI_TYPE_PREPENDED_SALT
6910 | OPTI_TYPE_RAW_HASH;
6911 dgst_pos0 = 3;
6912 dgst_pos1 = 4;
6913 dgst_pos2 = 2;
6914 dgst_pos3 = 1;
6915 break;
6916
6917 case 122: hash_type = HASH_TYPE_SHA1;
6918 salt_type = SALT_TYPE_EMBEDDED;
6919 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6920 opts_type = OPTS_TYPE_PT_GENERATE_BE
6921 | OPTS_TYPE_PT_ADD80
6922 | OPTS_TYPE_PT_ADDBITS15
6923 | OPTS_TYPE_ST_HEX;
6924 kern_type = KERN_TYPE_SHA1_SLTPW;
6925 dgst_size = DGST_SIZE_4_5;
6926 parse_func = osx1_parse_hash;
6927 sort_by_digest = sort_by_digest_4_5;
6928 opti_type = OPTI_TYPE_ZERO_BYTE
6929 | OPTI_TYPE_PRECOMPUTE_INIT
6930 | OPTI_TYPE_PRECOMPUTE_MERKLE
6931 | OPTI_TYPE_EARLY_SKIP
6932 | OPTI_TYPE_NOT_ITERATED
6933 | OPTI_TYPE_PREPENDED_SALT
6934 | OPTI_TYPE_RAW_HASH;
6935 dgst_pos0 = 3;
6936 dgst_pos1 = 4;
6937 dgst_pos2 = 2;
6938 dgst_pos3 = 1;
6939 break;
6940
6941 case 124: hash_type = HASH_TYPE_SHA1;
6942 salt_type = SALT_TYPE_EMBEDDED;
6943 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6944 opts_type = OPTS_TYPE_PT_GENERATE_BE
6945 | OPTS_TYPE_PT_ADD80
6946 | OPTS_TYPE_PT_ADDBITS15;
6947 kern_type = KERN_TYPE_SHA1_SLTPW;
6948 dgst_size = DGST_SIZE_4_5;
6949 parse_func = djangosha1_parse_hash;
6950 sort_by_digest = sort_by_digest_4_5;
6951 opti_type = OPTI_TYPE_ZERO_BYTE
6952 | OPTI_TYPE_PRECOMPUTE_INIT
6953 | OPTI_TYPE_PRECOMPUTE_MERKLE
6954 | OPTI_TYPE_EARLY_SKIP
6955 | OPTI_TYPE_NOT_ITERATED
6956 | OPTI_TYPE_PREPENDED_SALT
6957 | OPTI_TYPE_RAW_HASH;
6958 dgst_pos0 = 3;
6959 dgst_pos1 = 4;
6960 dgst_pos2 = 2;
6961 dgst_pos3 = 1;
6962 break;
6963
6964 case 130: hash_type = HASH_TYPE_SHA1;
6965 salt_type = SALT_TYPE_INTERN;
6966 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6967 opts_type = OPTS_TYPE_PT_GENERATE_BE
6968 | OPTS_TYPE_PT_UNICODE
6969 | OPTS_TYPE_ST_ADD80
6970 | OPTS_TYPE_ST_ADDBITS15;
6971 kern_type = KERN_TYPE_SHA1_PWUSLT;
6972 dgst_size = DGST_SIZE_4_5;
6973 parse_func = sha1s_parse_hash;
6974 sort_by_digest = sort_by_digest_4_5;
6975 opti_type = OPTI_TYPE_ZERO_BYTE
6976 | OPTI_TYPE_PRECOMPUTE_INIT
6977 | OPTI_TYPE_PRECOMPUTE_MERKLE
6978 | OPTI_TYPE_EARLY_SKIP
6979 | OPTI_TYPE_NOT_ITERATED
6980 | OPTI_TYPE_APPENDED_SALT
6981 | OPTI_TYPE_RAW_HASH;
6982 dgst_pos0 = 3;
6983 dgst_pos1 = 4;
6984 dgst_pos2 = 2;
6985 dgst_pos3 = 1;
6986 break;
6987
6988 case 131: hash_type = HASH_TYPE_SHA1;
6989 salt_type = SALT_TYPE_EMBEDDED;
6990 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6991 opts_type = OPTS_TYPE_PT_GENERATE_BE
6992 | OPTS_TYPE_PT_UNICODE
6993 | OPTS_TYPE_PT_UPPER
6994 | OPTS_TYPE_ST_ADD80
6995 | OPTS_TYPE_ST_ADDBITS15
6996 | OPTS_TYPE_ST_HEX;
6997 kern_type = KERN_TYPE_SHA1_PWUSLT;
6998 dgst_size = DGST_SIZE_4_5;
6999 parse_func = mssql2000_parse_hash;
7000 sort_by_digest = sort_by_digest_4_5;
7001 opti_type = OPTI_TYPE_ZERO_BYTE
7002 | OPTI_TYPE_PRECOMPUTE_INIT
7003 | OPTI_TYPE_PRECOMPUTE_MERKLE
7004 | OPTI_TYPE_EARLY_SKIP
7005 | OPTI_TYPE_NOT_ITERATED
7006 | OPTI_TYPE_APPENDED_SALT
7007 | OPTI_TYPE_RAW_HASH;
7008 dgst_pos0 = 3;
7009 dgst_pos1 = 4;
7010 dgst_pos2 = 2;
7011 dgst_pos3 = 1;
7012 break;
7013
7014 case 132: hash_type = HASH_TYPE_SHA1;
7015 salt_type = SALT_TYPE_EMBEDDED;
7016 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7017 opts_type = OPTS_TYPE_PT_GENERATE_BE
7018 | OPTS_TYPE_PT_UNICODE
7019 | OPTS_TYPE_ST_ADD80
7020 | OPTS_TYPE_ST_ADDBITS15
7021 | OPTS_TYPE_ST_HEX;
7022 kern_type = KERN_TYPE_SHA1_PWUSLT;
7023 dgst_size = DGST_SIZE_4_5;
7024 parse_func = mssql2005_parse_hash;
7025 sort_by_digest = sort_by_digest_4_5;
7026 opti_type = OPTI_TYPE_ZERO_BYTE
7027 | OPTI_TYPE_PRECOMPUTE_INIT
7028 | OPTI_TYPE_PRECOMPUTE_MERKLE
7029 | OPTI_TYPE_EARLY_SKIP
7030 | OPTI_TYPE_NOT_ITERATED
7031 | OPTI_TYPE_APPENDED_SALT
7032 | OPTI_TYPE_RAW_HASH;
7033 dgst_pos0 = 3;
7034 dgst_pos1 = 4;
7035 dgst_pos2 = 2;
7036 dgst_pos3 = 1;
7037 break;
7038
7039 case 133: hash_type = HASH_TYPE_SHA1;
7040 salt_type = SALT_TYPE_EMBEDDED;
7041 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7042 opts_type = OPTS_TYPE_PT_GENERATE_BE
7043 | OPTS_TYPE_PT_UNICODE
7044 | OPTS_TYPE_ST_ADD80
7045 | OPTS_TYPE_ST_ADDBITS15;
7046 kern_type = KERN_TYPE_SHA1_PWUSLT;
7047 dgst_size = DGST_SIZE_4_5;
7048 parse_func = peoplesoft_parse_hash;
7049 sort_by_digest = sort_by_digest_4_5;
7050 opti_type = OPTI_TYPE_ZERO_BYTE
7051 | OPTI_TYPE_PRECOMPUTE_INIT
7052 | OPTI_TYPE_PRECOMPUTE_MERKLE
7053 | OPTI_TYPE_EARLY_SKIP
7054 | OPTI_TYPE_NOT_ITERATED
7055 | OPTI_TYPE_APPENDED_SALT
7056 | OPTI_TYPE_RAW_HASH;
7057 dgst_pos0 = 3;
7058 dgst_pos1 = 4;
7059 dgst_pos2 = 2;
7060 dgst_pos3 = 1;
7061 break;
7062
7063 case 140: hash_type = HASH_TYPE_SHA1;
7064 salt_type = SALT_TYPE_INTERN;
7065 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7066 opts_type = OPTS_TYPE_PT_GENERATE_BE
7067 | OPTS_TYPE_PT_ADD80
7068 | OPTS_TYPE_PT_ADDBITS15
7069 | OPTS_TYPE_PT_UNICODE;
7070 kern_type = KERN_TYPE_SHA1_SLTPWU;
7071 dgst_size = DGST_SIZE_4_5;
7072 parse_func = sha1s_parse_hash;
7073 sort_by_digest = sort_by_digest_4_5;
7074 opti_type = OPTI_TYPE_ZERO_BYTE
7075 | OPTI_TYPE_PRECOMPUTE_INIT
7076 | OPTI_TYPE_PRECOMPUTE_MERKLE
7077 | OPTI_TYPE_EARLY_SKIP
7078 | OPTI_TYPE_NOT_ITERATED
7079 | OPTI_TYPE_PREPENDED_SALT
7080 | OPTI_TYPE_RAW_HASH;
7081 dgst_pos0 = 3;
7082 dgst_pos1 = 4;
7083 dgst_pos2 = 2;
7084 dgst_pos3 = 1;
7085 break;
7086
7087 case 141: hash_type = HASH_TYPE_SHA1;
7088 salt_type = SALT_TYPE_EMBEDDED;
7089 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7090 opts_type = OPTS_TYPE_PT_GENERATE_BE
7091 | OPTS_TYPE_PT_ADD80
7092 | OPTS_TYPE_PT_ADDBITS15
7093 | OPTS_TYPE_PT_UNICODE
7094 | OPTS_TYPE_ST_BASE64;
7095 kern_type = KERN_TYPE_SHA1_SLTPWU;
7096 dgst_size = DGST_SIZE_4_5;
7097 parse_func = episerver_parse_hash;
7098 sort_by_digest = sort_by_digest_4_5;
7099 opti_type = OPTI_TYPE_ZERO_BYTE
7100 | OPTI_TYPE_PRECOMPUTE_INIT
7101 | OPTI_TYPE_PRECOMPUTE_MERKLE
7102 | OPTI_TYPE_EARLY_SKIP
7103 | OPTI_TYPE_NOT_ITERATED
7104 | OPTI_TYPE_PREPENDED_SALT
7105 | OPTI_TYPE_RAW_HASH;
7106 dgst_pos0 = 3;
7107 dgst_pos1 = 4;
7108 dgst_pos2 = 2;
7109 dgst_pos3 = 1;
7110 break;
7111
7112 case 150: hash_type = HASH_TYPE_SHA1;
7113 salt_type = SALT_TYPE_INTERN;
7114 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7115 opts_type = OPTS_TYPE_PT_GENERATE_BE
7116 | OPTS_TYPE_ST_ADD80
7117 | OPTS_TYPE_ST_ADDBITS15;
7118 kern_type = KERN_TYPE_HMACSHA1_PW;
7119 dgst_size = DGST_SIZE_4_5;
7120 parse_func = hmacsha1_parse_hash;
7121 sort_by_digest = sort_by_digest_4_5;
7122 opti_type = OPTI_TYPE_ZERO_BYTE
7123 | OPTI_TYPE_NOT_ITERATED;
7124 dgst_pos0 = 3;
7125 dgst_pos1 = 4;
7126 dgst_pos2 = 2;
7127 dgst_pos3 = 1;
7128 break;
7129
7130 case 160: hash_type = HASH_TYPE_SHA1;
7131 salt_type = SALT_TYPE_INTERN;
7132 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7133 opts_type = OPTS_TYPE_PT_GENERATE_BE
7134 | OPTS_TYPE_PT_ADD80
7135 | OPTS_TYPE_PT_ADDBITS15;
7136 kern_type = KERN_TYPE_HMACSHA1_SLT;
7137 dgst_size = DGST_SIZE_4_5;
7138 parse_func = hmacsha1_parse_hash;
7139 sort_by_digest = sort_by_digest_4_5;
7140 opti_type = OPTI_TYPE_ZERO_BYTE
7141 | OPTI_TYPE_NOT_ITERATED;
7142 dgst_pos0 = 3;
7143 dgst_pos1 = 4;
7144 dgst_pos2 = 2;
7145 dgst_pos3 = 1;
7146 break;
7147
7148 case 190: hash_type = HASH_TYPE_SHA1;
7149 salt_type = SALT_TYPE_NONE;
7150 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7151 opts_type = OPTS_TYPE_PT_GENERATE_BE
7152 | OPTS_TYPE_PT_ADD80
7153 | OPTS_TYPE_PT_ADDBITS15;
7154 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7155 dgst_size = DGST_SIZE_4_5;
7156 parse_func = sha1linkedin_parse_hash;
7157 sort_by_digest = sort_by_digest_4_5;
7158 opti_type = OPTI_TYPE_ZERO_BYTE
7159 | OPTI_TYPE_PRECOMPUTE_INIT
7160 | OPTI_TYPE_EARLY_SKIP
7161 | OPTI_TYPE_NOT_ITERATED
7162 | OPTI_TYPE_NOT_SALTED;
7163 dgst_pos0 = 0;
7164 dgst_pos1 = 4;
7165 dgst_pos2 = 3;
7166 dgst_pos3 = 2;
7167 break;
7168
7169 case 200: hash_type = HASH_TYPE_MYSQL;
7170 salt_type = SALT_TYPE_NONE;
7171 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7172 opts_type = 0;
7173 kern_type = KERN_TYPE_MYSQL;
7174 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7175 parse_func = mysql323_parse_hash;
7176 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7177 opti_type = OPTI_TYPE_ZERO_BYTE;
7178 dgst_pos0 = 0;
7179 dgst_pos1 = 1;
7180 dgst_pos2 = 2;
7181 dgst_pos3 = 3;
7182 break;
7183
7184 case 300: hash_type = HASH_TYPE_SHA1;
7185 salt_type = SALT_TYPE_NONE;
7186 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7187 opts_type = OPTS_TYPE_PT_GENERATE_BE
7188 | OPTS_TYPE_PT_ADD80
7189 | OPTS_TYPE_PT_ADDBITS15;
7190 kern_type = KERN_TYPE_MYSQL41;
7191 dgst_size = DGST_SIZE_4_5;
7192 parse_func = sha1_parse_hash;
7193 sort_by_digest = sort_by_digest_4_5;
7194 opti_type = OPTI_TYPE_ZERO_BYTE
7195 | OPTI_TYPE_PRECOMPUTE_INIT
7196 | OPTI_TYPE_PRECOMPUTE_MERKLE
7197 | OPTI_TYPE_EARLY_SKIP
7198 | OPTI_TYPE_NOT_ITERATED
7199 | OPTI_TYPE_NOT_SALTED;
7200 dgst_pos0 = 3;
7201 dgst_pos1 = 4;
7202 dgst_pos2 = 2;
7203 dgst_pos3 = 1;
7204 break;
7205
7206 case 400: hash_type = HASH_TYPE_MD5;
7207 salt_type = SALT_TYPE_EMBEDDED;
7208 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7209 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7210 kern_type = KERN_TYPE_PHPASS;
7211 dgst_size = DGST_SIZE_4_4;
7212 parse_func = phpass_parse_hash;
7213 sort_by_digest = sort_by_digest_4_4;
7214 opti_type = OPTI_TYPE_ZERO_BYTE;
7215 dgst_pos0 = 0;
7216 dgst_pos1 = 1;
7217 dgst_pos2 = 2;
7218 dgst_pos3 = 3;
7219 break;
7220
7221 case 500: hash_type = HASH_TYPE_MD5;
7222 salt_type = SALT_TYPE_EMBEDDED;
7223 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7224 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7225 kern_type = KERN_TYPE_MD5CRYPT;
7226 dgst_size = DGST_SIZE_4_4;
7227 parse_func = md5crypt_parse_hash;
7228 sort_by_digest = sort_by_digest_4_4;
7229 opti_type = OPTI_TYPE_ZERO_BYTE;
7230 dgst_pos0 = 0;
7231 dgst_pos1 = 1;
7232 dgst_pos2 = 2;
7233 dgst_pos3 = 3;
7234 break;
7235
7236 case 501: hash_type = HASH_TYPE_MD5;
7237 salt_type = SALT_TYPE_EMBEDDED;
7238 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7239 opts_type = OPTS_TYPE_PT_GENERATE_LE
7240 | OPTS_TYPE_HASH_COPY;
7241 kern_type = KERN_TYPE_MD5CRYPT;
7242 dgst_size = DGST_SIZE_4_4;
7243 parse_func = juniper_parse_hash;
7244 sort_by_digest = sort_by_digest_4_4;
7245 opti_type = OPTI_TYPE_ZERO_BYTE;
7246 dgst_pos0 = 0;
7247 dgst_pos1 = 1;
7248 dgst_pos2 = 2;
7249 dgst_pos3 = 3;
7250 break;
7251
7252 case 900: hash_type = HASH_TYPE_MD4;
7253 salt_type = SALT_TYPE_NONE;
7254 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7255 opts_type = OPTS_TYPE_PT_GENERATE_LE
7256 | OPTS_TYPE_PT_ADD80
7257 | OPTS_TYPE_PT_ADDBITS14;
7258 kern_type = KERN_TYPE_MD4;
7259 dgst_size = DGST_SIZE_4_4;
7260 parse_func = md4_parse_hash;
7261 sort_by_digest = sort_by_digest_4_4;
7262 opti_type = OPTI_TYPE_ZERO_BYTE
7263 | OPTI_TYPE_PRECOMPUTE_INIT
7264 | OPTI_TYPE_PRECOMPUTE_MERKLE
7265 | OPTI_TYPE_MEET_IN_MIDDLE
7266 | OPTI_TYPE_EARLY_SKIP
7267 | OPTI_TYPE_NOT_ITERATED
7268 | OPTI_TYPE_NOT_SALTED
7269 | OPTI_TYPE_RAW_HASH;
7270 dgst_pos0 = 0;
7271 dgst_pos1 = 3;
7272 dgst_pos2 = 2;
7273 dgst_pos3 = 1;
7274 break;
7275
7276 case 1000: hash_type = HASH_TYPE_MD4;
7277 salt_type = SALT_TYPE_NONE;
7278 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7279 opts_type = OPTS_TYPE_PT_GENERATE_LE
7280 | OPTS_TYPE_PT_ADD80
7281 | OPTS_TYPE_PT_ADDBITS14
7282 | OPTS_TYPE_PT_UNICODE;
7283 kern_type = KERN_TYPE_MD4_PWU;
7284 dgst_size = DGST_SIZE_4_4;
7285 parse_func = md4_parse_hash;
7286 sort_by_digest = sort_by_digest_4_4;
7287 opti_type = OPTI_TYPE_ZERO_BYTE
7288 | OPTI_TYPE_PRECOMPUTE_INIT
7289 | OPTI_TYPE_PRECOMPUTE_MERKLE
7290 | OPTI_TYPE_MEET_IN_MIDDLE
7291 | OPTI_TYPE_EARLY_SKIP
7292 | OPTI_TYPE_NOT_ITERATED
7293 | OPTI_TYPE_NOT_SALTED
7294 | OPTI_TYPE_RAW_HASH;
7295 dgst_pos0 = 0;
7296 dgst_pos1 = 3;
7297 dgst_pos2 = 2;
7298 dgst_pos3 = 1;
7299 break;
7300
7301 case 1100: hash_type = HASH_TYPE_MD4;
7302 salt_type = SALT_TYPE_INTERN;
7303 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7304 opts_type = OPTS_TYPE_PT_GENERATE_LE
7305 | OPTS_TYPE_PT_ADD80
7306 | OPTS_TYPE_PT_ADDBITS14
7307 | OPTS_TYPE_PT_UNICODE
7308 | OPTS_TYPE_ST_ADD80
7309 | OPTS_TYPE_ST_UNICODE
7310 | OPTS_TYPE_ST_LOWER;
7311 kern_type = KERN_TYPE_MD44_PWUSLT;
7312 dgst_size = DGST_SIZE_4_4;
7313 parse_func = dcc_parse_hash;
7314 sort_by_digest = sort_by_digest_4_4;
7315 opti_type = OPTI_TYPE_ZERO_BYTE
7316 | OPTI_TYPE_PRECOMPUTE_INIT
7317 | OPTI_TYPE_PRECOMPUTE_MERKLE
7318 | OPTI_TYPE_EARLY_SKIP
7319 | OPTI_TYPE_NOT_ITERATED;
7320 dgst_pos0 = 0;
7321 dgst_pos1 = 3;
7322 dgst_pos2 = 2;
7323 dgst_pos3 = 1;
7324 break;
7325
7326 case 1400: hash_type = HASH_TYPE_SHA256;
7327 salt_type = SALT_TYPE_NONE;
7328 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7329 opts_type = OPTS_TYPE_PT_GENERATE_BE
7330 | OPTS_TYPE_PT_ADD80
7331 | OPTS_TYPE_PT_ADDBITS15;
7332 kern_type = KERN_TYPE_SHA256;
7333 dgst_size = DGST_SIZE_4_8;
7334 parse_func = sha256_parse_hash;
7335 sort_by_digest = sort_by_digest_4_8;
7336 opti_type = OPTI_TYPE_ZERO_BYTE
7337 | OPTI_TYPE_PRECOMPUTE_INIT
7338 | OPTI_TYPE_PRECOMPUTE_MERKLE
7339 | OPTI_TYPE_EARLY_SKIP
7340 | OPTI_TYPE_NOT_ITERATED
7341 | OPTI_TYPE_NOT_SALTED
7342 | OPTI_TYPE_RAW_HASH;
7343 dgst_pos0 = 3;
7344 dgst_pos1 = 7;
7345 dgst_pos2 = 2;
7346 dgst_pos3 = 6;
7347 break;
7348
7349 case 1410: hash_type = HASH_TYPE_SHA256;
7350 salt_type = SALT_TYPE_INTERN;
7351 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7352 opts_type = OPTS_TYPE_PT_GENERATE_BE
7353 | OPTS_TYPE_ST_ADD80
7354 | OPTS_TYPE_ST_ADDBITS15;
7355 kern_type = KERN_TYPE_SHA256_PWSLT;
7356 dgst_size = DGST_SIZE_4_8;
7357 parse_func = sha256s_parse_hash;
7358 sort_by_digest = sort_by_digest_4_8;
7359 opti_type = OPTI_TYPE_ZERO_BYTE
7360 | OPTI_TYPE_PRECOMPUTE_INIT
7361 | OPTI_TYPE_PRECOMPUTE_MERKLE
7362 | OPTI_TYPE_EARLY_SKIP
7363 | OPTI_TYPE_NOT_ITERATED
7364 | OPTI_TYPE_APPENDED_SALT
7365 | OPTI_TYPE_RAW_HASH;
7366 dgst_pos0 = 3;
7367 dgst_pos1 = 7;
7368 dgst_pos2 = 2;
7369 dgst_pos3 = 6;
7370 break;
7371
7372 case 1420: hash_type = HASH_TYPE_SHA256;
7373 salt_type = SALT_TYPE_INTERN;
7374 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7375 opts_type = OPTS_TYPE_PT_GENERATE_BE
7376 | OPTS_TYPE_PT_ADD80
7377 | OPTS_TYPE_PT_ADDBITS15;
7378 kern_type = KERN_TYPE_SHA256_SLTPW;
7379 dgst_size = DGST_SIZE_4_8;
7380 parse_func = sha256s_parse_hash;
7381 sort_by_digest = sort_by_digest_4_8;
7382 opti_type = OPTI_TYPE_ZERO_BYTE
7383 | OPTI_TYPE_PRECOMPUTE_INIT
7384 | OPTI_TYPE_PRECOMPUTE_MERKLE
7385 | OPTI_TYPE_EARLY_SKIP
7386 | OPTI_TYPE_NOT_ITERATED
7387 | OPTI_TYPE_PREPENDED_SALT
7388 | OPTI_TYPE_RAW_HASH;
7389 dgst_pos0 = 3;
7390 dgst_pos1 = 7;
7391 dgst_pos2 = 2;
7392 dgst_pos3 = 6;
7393 break;
7394
7395 case 1421: hash_type = HASH_TYPE_SHA256;
7396 salt_type = SALT_TYPE_EMBEDDED;
7397 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7398 opts_type = OPTS_TYPE_PT_GENERATE_BE
7399 | OPTS_TYPE_PT_ADD80
7400 | OPTS_TYPE_PT_ADDBITS15;
7401 kern_type = KERN_TYPE_SHA256_SLTPW;
7402 dgst_size = DGST_SIZE_4_8;
7403 parse_func = hmailserver_parse_hash;
7404 sort_by_digest = sort_by_digest_4_8;
7405 opti_type = OPTI_TYPE_ZERO_BYTE
7406 | OPTI_TYPE_PRECOMPUTE_INIT
7407 | OPTI_TYPE_PRECOMPUTE_MERKLE
7408 | OPTI_TYPE_EARLY_SKIP
7409 | OPTI_TYPE_NOT_ITERATED
7410 | OPTI_TYPE_PREPENDED_SALT
7411 | OPTI_TYPE_RAW_HASH;
7412 dgst_pos0 = 3;
7413 dgst_pos1 = 7;
7414 dgst_pos2 = 2;
7415 dgst_pos3 = 6;
7416 break;
7417
7418 case 1430: hash_type = HASH_TYPE_SHA256;
7419 salt_type = SALT_TYPE_INTERN;
7420 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7421 opts_type = OPTS_TYPE_PT_GENERATE_BE
7422 | OPTS_TYPE_PT_UNICODE
7423 | OPTS_TYPE_ST_ADD80
7424 | OPTS_TYPE_ST_ADDBITS15;
7425 kern_type = KERN_TYPE_SHA256_PWUSLT;
7426 dgst_size = DGST_SIZE_4_8;
7427 parse_func = sha256s_parse_hash;
7428 sort_by_digest = sort_by_digest_4_8;
7429 opti_type = OPTI_TYPE_ZERO_BYTE
7430 | OPTI_TYPE_PRECOMPUTE_INIT
7431 | OPTI_TYPE_PRECOMPUTE_MERKLE
7432 | OPTI_TYPE_EARLY_SKIP
7433 | OPTI_TYPE_NOT_ITERATED
7434 | OPTI_TYPE_APPENDED_SALT
7435 | OPTI_TYPE_RAW_HASH;
7436 dgst_pos0 = 3;
7437 dgst_pos1 = 7;
7438 dgst_pos2 = 2;
7439 dgst_pos3 = 6;
7440 break;
7441
7442 case 1440: hash_type = HASH_TYPE_SHA256;
7443 salt_type = SALT_TYPE_INTERN;
7444 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7445 opts_type = OPTS_TYPE_PT_GENERATE_BE
7446 | OPTS_TYPE_PT_ADD80
7447 | OPTS_TYPE_PT_ADDBITS15
7448 | OPTS_TYPE_PT_UNICODE;
7449 kern_type = KERN_TYPE_SHA256_SLTPWU;
7450 dgst_size = DGST_SIZE_4_8;
7451 parse_func = sha256s_parse_hash;
7452 sort_by_digest = sort_by_digest_4_8;
7453 opti_type = OPTI_TYPE_ZERO_BYTE
7454 | OPTI_TYPE_PRECOMPUTE_INIT
7455 | OPTI_TYPE_PRECOMPUTE_MERKLE
7456 | OPTI_TYPE_EARLY_SKIP
7457 | OPTI_TYPE_NOT_ITERATED
7458 | OPTI_TYPE_PREPENDED_SALT
7459 | OPTI_TYPE_RAW_HASH;
7460 dgst_pos0 = 3;
7461 dgst_pos1 = 7;
7462 dgst_pos2 = 2;
7463 dgst_pos3 = 6;
7464 break;
7465
7466 case 1441: hash_type = HASH_TYPE_SHA256;
7467 salt_type = SALT_TYPE_EMBEDDED;
7468 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7469 opts_type = OPTS_TYPE_PT_GENERATE_BE
7470 | OPTS_TYPE_PT_ADD80
7471 | OPTS_TYPE_PT_ADDBITS15
7472 | OPTS_TYPE_PT_UNICODE
7473 | OPTS_TYPE_ST_BASE64;
7474 kern_type = KERN_TYPE_SHA256_SLTPWU;
7475 dgst_size = DGST_SIZE_4_8;
7476 parse_func = episerver4_parse_hash;
7477 sort_by_digest = sort_by_digest_4_8;
7478 opti_type = OPTI_TYPE_ZERO_BYTE
7479 | OPTI_TYPE_PRECOMPUTE_INIT
7480 | OPTI_TYPE_PRECOMPUTE_MERKLE
7481 | OPTI_TYPE_EARLY_SKIP
7482 | OPTI_TYPE_NOT_ITERATED
7483 | OPTI_TYPE_PREPENDED_SALT
7484 | OPTI_TYPE_RAW_HASH;
7485 dgst_pos0 = 3;
7486 dgst_pos1 = 7;
7487 dgst_pos2 = 2;
7488 dgst_pos3 = 6;
7489 break;
7490
7491 case 1450: hash_type = HASH_TYPE_SHA256;
7492 salt_type = SALT_TYPE_INTERN;
7493 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7494 opts_type = OPTS_TYPE_PT_GENERATE_BE
7495 | OPTS_TYPE_ST_ADD80;
7496 kern_type = KERN_TYPE_HMACSHA256_PW;
7497 dgst_size = DGST_SIZE_4_8;
7498 parse_func = hmacsha256_parse_hash;
7499 sort_by_digest = sort_by_digest_4_8;
7500 opti_type = OPTI_TYPE_ZERO_BYTE
7501 | OPTI_TYPE_NOT_ITERATED;
7502 dgst_pos0 = 3;
7503 dgst_pos1 = 7;
7504 dgst_pos2 = 2;
7505 dgst_pos3 = 6;
7506 break;
7507
7508 case 1460: hash_type = HASH_TYPE_SHA256;
7509 salt_type = SALT_TYPE_INTERN;
7510 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7511 opts_type = OPTS_TYPE_PT_GENERATE_BE
7512 | OPTS_TYPE_PT_ADD80
7513 | OPTS_TYPE_PT_ADDBITS15;
7514 kern_type = KERN_TYPE_HMACSHA256_SLT;
7515 dgst_size = DGST_SIZE_4_8;
7516 parse_func = hmacsha256_parse_hash;
7517 sort_by_digest = sort_by_digest_4_8;
7518 opti_type = OPTI_TYPE_ZERO_BYTE
7519 | OPTI_TYPE_NOT_ITERATED;
7520 dgst_pos0 = 3;
7521 dgst_pos1 = 7;
7522 dgst_pos2 = 2;
7523 dgst_pos3 = 6;
7524 break;
7525
7526 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7527 salt_type = SALT_TYPE_EMBEDDED;
7528 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7529 opts_type = OPTS_TYPE_PT_GENERATE_LE
7530 | OPTS_TYPE_PT_BITSLICE;
7531 kern_type = KERN_TYPE_DESCRYPT;
7532 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7533 parse_func = descrypt_parse_hash;
7534 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7535 opti_type = OPTI_TYPE_ZERO_BYTE
7536 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7537 dgst_pos0 = 0;
7538 dgst_pos1 = 1;
7539 dgst_pos2 = 2;
7540 dgst_pos3 = 3;
7541 break;
7542
7543 case 1600: hash_type = HASH_TYPE_MD5;
7544 salt_type = SALT_TYPE_EMBEDDED;
7545 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7546 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7547 kern_type = KERN_TYPE_APR1CRYPT;
7548 dgst_size = DGST_SIZE_4_4;
7549 parse_func = md5apr1_parse_hash;
7550 sort_by_digest = sort_by_digest_4_4;
7551 opti_type = OPTI_TYPE_ZERO_BYTE;
7552 dgst_pos0 = 0;
7553 dgst_pos1 = 1;
7554 dgst_pos2 = 2;
7555 dgst_pos3 = 3;
7556 break;
7557
7558 case 1700: hash_type = HASH_TYPE_SHA512;
7559 salt_type = SALT_TYPE_NONE;
7560 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7561 opts_type = OPTS_TYPE_PT_GENERATE_BE
7562 | OPTS_TYPE_PT_ADD80
7563 | OPTS_TYPE_PT_ADDBITS15;
7564 kern_type = KERN_TYPE_SHA512;
7565 dgst_size = DGST_SIZE_8_8;
7566 parse_func = sha512_parse_hash;
7567 sort_by_digest = sort_by_digest_8_8;
7568 opti_type = OPTI_TYPE_ZERO_BYTE
7569 | OPTI_TYPE_PRECOMPUTE_INIT
7570 | OPTI_TYPE_PRECOMPUTE_MERKLE
7571 | OPTI_TYPE_EARLY_SKIP
7572 | OPTI_TYPE_NOT_ITERATED
7573 | OPTI_TYPE_NOT_SALTED
7574 | OPTI_TYPE_RAW_HASH;
7575 dgst_pos0 = 14;
7576 dgst_pos1 = 15;
7577 dgst_pos2 = 6;
7578 dgst_pos3 = 7;
7579 break;
7580
7581 case 1710: hash_type = HASH_TYPE_SHA512;
7582 salt_type = SALT_TYPE_INTERN;
7583 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7584 opts_type = OPTS_TYPE_PT_GENERATE_BE
7585 | OPTS_TYPE_ST_ADD80
7586 | OPTS_TYPE_ST_ADDBITS15;
7587 kern_type = KERN_TYPE_SHA512_PWSLT;
7588 dgst_size = DGST_SIZE_8_8;
7589 parse_func = sha512s_parse_hash;
7590 sort_by_digest = sort_by_digest_8_8;
7591 opti_type = OPTI_TYPE_ZERO_BYTE
7592 | OPTI_TYPE_PRECOMPUTE_INIT
7593 | OPTI_TYPE_PRECOMPUTE_MERKLE
7594 | OPTI_TYPE_EARLY_SKIP
7595 | OPTI_TYPE_NOT_ITERATED
7596 | OPTI_TYPE_APPENDED_SALT
7597 | OPTI_TYPE_RAW_HASH;
7598 dgst_pos0 = 14;
7599 dgst_pos1 = 15;
7600 dgst_pos2 = 6;
7601 dgst_pos3 = 7;
7602 break;
7603
7604 case 1711: hash_type = HASH_TYPE_SHA512;
7605 salt_type = SALT_TYPE_EMBEDDED;
7606 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7607 opts_type = OPTS_TYPE_PT_GENERATE_BE
7608 | OPTS_TYPE_ST_ADD80
7609 | OPTS_TYPE_ST_ADDBITS15;
7610 kern_type = KERN_TYPE_SHA512_PWSLT;
7611 dgst_size = DGST_SIZE_8_8;
7612 parse_func = sha512b64s_parse_hash;
7613 sort_by_digest = sort_by_digest_8_8;
7614 opti_type = OPTI_TYPE_ZERO_BYTE
7615 | OPTI_TYPE_PRECOMPUTE_INIT
7616 | OPTI_TYPE_PRECOMPUTE_MERKLE
7617 | OPTI_TYPE_EARLY_SKIP
7618 | OPTI_TYPE_NOT_ITERATED
7619 | OPTI_TYPE_APPENDED_SALT
7620 | OPTI_TYPE_RAW_HASH;
7621 dgst_pos0 = 14;
7622 dgst_pos1 = 15;
7623 dgst_pos2 = 6;
7624 dgst_pos3 = 7;
7625 break;
7626
7627 case 1720: hash_type = HASH_TYPE_SHA512;
7628 salt_type = SALT_TYPE_INTERN;
7629 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7630 opts_type = OPTS_TYPE_PT_GENERATE_BE
7631 | OPTS_TYPE_PT_ADD80
7632 | OPTS_TYPE_PT_ADDBITS15;
7633 kern_type = KERN_TYPE_SHA512_SLTPW;
7634 dgst_size = DGST_SIZE_8_8;
7635 parse_func = sha512s_parse_hash;
7636 sort_by_digest = sort_by_digest_8_8;
7637 opti_type = OPTI_TYPE_ZERO_BYTE
7638 | OPTI_TYPE_PRECOMPUTE_INIT
7639 | OPTI_TYPE_PRECOMPUTE_MERKLE
7640 | OPTI_TYPE_EARLY_SKIP
7641 | OPTI_TYPE_NOT_ITERATED
7642 | OPTI_TYPE_PREPENDED_SALT
7643 | OPTI_TYPE_RAW_HASH;
7644 dgst_pos0 = 14;
7645 dgst_pos1 = 15;
7646 dgst_pos2 = 6;
7647 dgst_pos3 = 7;
7648 break;
7649
7650 case 1722: hash_type = HASH_TYPE_SHA512;
7651 salt_type = SALT_TYPE_EMBEDDED;
7652 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7653 opts_type = OPTS_TYPE_PT_GENERATE_BE
7654 | OPTS_TYPE_PT_ADD80
7655 | OPTS_TYPE_PT_ADDBITS15
7656 | OPTS_TYPE_ST_HEX;
7657 kern_type = KERN_TYPE_SHA512_SLTPW;
7658 dgst_size = DGST_SIZE_8_8;
7659 parse_func = osx512_parse_hash;
7660 sort_by_digest = sort_by_digest_8_8;
7661 opti_type = OPTI_TYPE_ZERO_BYTE
7662 | OPTI_TYPE_PRECOMPUTE_INIT
7663 | OPTI_TYPE_PRECOMPUTE_MERKLE
7664 | OPTI_TYPE_EARLY_SKIP
7665 | OPTI_TYPE_NOT_ITERATED
7666 | OPTI_TYPE_PREPENDED_SALT
7667 | OPTI_TYPE_RAW_HASH;
7668 dgst_pos0 = 14;
7669 dgst_pos1 = 15;
7670 dgst_pos2 = 6;
7671 dgst_pos3 = 7;
7672 break;
7673
7674 case 1730: hash_type = HASH_TYPE_SHA512;
7675 salt_type = SALT_TYPE_INTERN;
7676 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7677 opts_type = OPTS_TYPE_PT_GENERATE_BE
7678 | OPTS_TYPE_PT_UNICODE
7679 | OPTS_TYPE_ST_ADD80
7680 | OPTS_TYPE_ST_ADDBITS15;
7681 kern_type = KERN_TYPE_SHA512_PWSLTU;
7682 dgst_size = DGST_SIZE_8_8;
7683 parse_func = sha512s_parse_hash;
7684 sort_by_digest = sort_by_digest_8_8;
7685 opti_type = OPTI_TYPE_ZERO_BYTE
7686 | OPTI_TYPE_PRECOMPUTE_INIT
7687 | OPTI_TYPE_PRECOMPUTE_MERKLE
7688 | OPTI_TYPE_EARLY_SKIP
7689 | OPTI_TYPE_NOT_ITERATED
7690 | OPTI_TYPE_APPENDED_SALT
7691 | OPTI_TYPE_RAW_HASH;
7692 dgst_pos0 = 14;
7693 dgst_pos1 = 15;
7694 dgst_pos2 = 6;
7695 dgst_pos3 = 7;
7696 break;
7697
7698 case 1731: hash_type = HASH_TYPE_SHA512;
7699 salt_type = SALT_TYPE_EMBEDDED;
7700 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7701 opts_type = OPTS_TYPE_PT_GENERATE_BE
7702 | OPTS_TYPE_PT_UNICODE
7703 | OPTS_TYPE_ST_ADD80
7704 | OPTS_TYPE_ST_ADDBITS15
7705 | OPTS_TYPE_ST_HEX;
7706 kern_type = KERN_TYPE_SHA512_PWSLTU;
7707 dgst_size = DGST_SIZE_8_8;
7708 parse_func = mssql2012_parse_hash;
7709 sort_by_digest = sort_by_digest_8_8;
7710 opti_type = OPTI_TYPE_ZERO_BYTE
7711 | OPTI_TYPE_PRECOMPUTE_INIT
7712 | OPTI_TYPE_PRECOMPUTE_MERKLE
7713 | OPTI_TYPE_EARLY_SKIP
7714 | OPTI_TYPE_NOT_ITERATED
7715 | OPTI_TYPE_APPENDED_SALT
7716 | OPTI_TYPE_RAW_HASH;
7717 dgst_pos0 = 14;
7718 dgst_pos1 = 15;
7719 dgst_pos2 = 6;
7720 dgst_pos3 = 7;
7721 break;
7722
7723 case 1740: hash_type = HASH_TYPE_SHA512;
7724 salt_type = SALT_TYPE_INTERN;
7725 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7726 opts_type = OPTS_TYPE_PT_GENERATE_BE
7727 | OPTS_TYPE_PT_ADD80
7728 | OPTS_TYPE_PT_ADDBITS15
7729 | OPTS_TYPE_PT_UNICODE;
7730 kern_type = KERN_TYPE_SHA512_SLTPWU;
7731 dgst_size = DGST_SIZE_8_8;
7732 parse_func = sha512s_parse_hash;
7733 sort_by_digest = sort_by_digest_8_8;
7734 opti_type = OPTI_TYPE_ZERO_BYTE
7735 | OPTI_TYPE_PRECOMPUTE_INIT
7736 | OPTI_TYPE_PRECOMPUTE_MERKLE
7737 | OPTI_TYPE_EARLY_SKIP
7738 | OPTI_TYPE_NOT_ITERATED
7739 | OPTI_TYPE_PREPENDED_SALT
7740 | OPTI_TYPE_RAW_HASH;
7741 dgst_pos0 = 14;
7742 dgst_pos1 = 15;
7743 dgst_pos2 = 6;
7744 dgst_pos3 = 7;
7745 break;
7746
7747 case 1750: hash_type = HASH_TYPE_SHA512;
7748 salt_type = SALT_TYPE_INTERN;
7749 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7750 opts_type = OPTS_TYPE_PT_GENERATE_BE
7751 | OPTS_TYPE_ST_ADD80;
7752 kern_type = KERN_TYPE_HMACSHA512_PW;
7753 dgst_size = DGST_SIZE_8_8;
7754 parse_func = hmacsha512_parse_hash;
7755 sort_by_digest = sort_by_digest_8_8;
7756 opti_type = OPTI_TYPE_ZERO_BYTE
7757 | OPTI_TYPE_NOT_ITERATED;
7758 dgst_pos0 = 14;
7759 dgst_pos1 = 15;
7760 dgst_pos2 = 6;
7761 dgst_pos3 = 7;
7762 break;
7763
7764 case 1760: hash_type = HASH_TYPE_SHA512;
7765 salt_type = SALT_TYPE_INTERN;
7766 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7767 opts_type = OPTS_TYPE_PT_GENERATE_BE
7768 | OPTS_TYPE_PT_ADD80
7769 | OPTS_TYPE_PT_ADDBITS15;
7770 kern_type = KERN_TYPE_HMACSHA512_SLT;
7771 dgst_size = DGST_SIZE_8_8;
7772 parse_func = hmacsha512_parse_hash;
7773 sort_by_digest = sort_by_digest_8_8;
7774 opti_type = OPTI_TYPE_ZERO_BYTE
7775 | OPTI_TYPE_NOT_ITERATED;
7776 dgst_pos0 = 14;
7777 dgst_pos1 = 15;
7778 dgst_pos2 = 6;
7779 dgst_pos3 = 7;
7780 break;
7781
7782 case 1800: hash_type = HASH_TYPE_SHA512;
7783 salt_type = SALT_TYPE_EMBEDDED;
7784 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7785 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7786 kern_type = KERN_TYPE_SHA512CRYPT;
7787 dgst_size = DGST_SIZE_8_8;
7788 parse_func = sha512crypt_parse_hash;
7789 sort_by_digest = sort_by_digest_8_8;
7790 opti_type = OPTI_TYPE_ZERO_BYTE;
7791 dgst_pos0 = 0;
7792 dgst_pos1 = 1;
7793 dgst_pos2 = 2;
7794 dgst_pos3 = 3;
7795 break;
7796
7797 case 2100: hash_type = HASH_TYPE_DCC2;
7798 salt_type = SALT_TYPE_EMBEDDED;
7799 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7800 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
7801 | OPTS_TYPE_ST_LOWER
7802 | OPTS_TYPE_ST_UNICODE;
7803 kern_type = KERN_TYPE_DCC2;
7804 dgst_size = DGST_SIZE_4_4;
7805 parse_func = dcc2_parse_hash;
7806 sort_by_digest = sort_by_digest_4_4;
7807 opti_type = OPTI_TYPE_ZERO_BYTE;
7808 dgst_pos0 = 0;
7809 dgst_pos1 = 1;
7810 dgst_pos2 = 2;
7811 dgst_pos3 = 3;
7812 break;
7813
7814 case 2400: hash_type = HASH_TYPE_MD5;
7815 salt_type = SALT_TYPE_NONE;
7816 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7817 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7818 kern_type = KERN_TYPE_MD5PIX;
7819 dgst_size = DGST_SIZE_4_4;
7820 parse_func = md5pix_parse_hash;
7821 sort_by_digest = sort_by_digest_4_4;
7822 opti_type = OPTI_TYPE_ZERO_BYTE
7823 | OPTI_TYPE_PRECOMPUTE_INIT
7824 | OPTI_TYPE_PRECOMPUTE_MERKLE
7825 | OPTI_TYPE_EARLY_SKIP
7826 | OPTI_TYPE_NOT_ITERATED
7827 | OPTI_TYPE_NOT_SALTED;
7828 dgst_pos0 = 0;
7829 dgst_pos1 = 3;
7830 dgst_pos2 = 2;
7831 dgst_pos3 = 1;
7832 break;
7833
7834 case 2410: hash_type = HASH_TYPE_MD5;
7835 salt_type = SALT_TYPE_INTERN;
7836 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7837 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7838 kern_type = KERN_TYPE_MD5ASA;
7839 dgst_size = DGST_SIZE_4_4;
7840 parse_func = md5asa_parse_hash;
7841 sort_by_digest = sort_by_digest_4_4;
7842 opti_type = OPTI_TYPE_ZERO_BYTE
7843 | OPTI_TYPE_PRECOMPUTE_INIT
7844 | OPTI_TYPE_PRECOMPUTE_MERKLE
7845 | OPTI_TYPE_EARLY_SKIP
7846 | OPTI_TYPE_NOT_ITERATED;
7847 dgst_pos0 = 0;
7848 dgst_pos1 = 3;
7849 dgst_pos2 = 2;
7850 dgst_pos3 = 1;
7851 break;
7852
7853 case 2500: hash_type = HASH_TYPE_WPA;
7854 salt_type = SALT_TYPE_EMBEDDED;
7855 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7856 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7857 kern_type = KERN_TYPE_WPA;
7858 dgst_size = DGST_SIZE_4_4;
7859 parse_func = wpa_parse_hash;
7860 sort_by_digest = sort_by_digest_4_4;
7861 opti_type = OPTI_TYPE_ZERO_BYTE;
7862 dgst_pos0 = 0;
7863 dgst_pos1 = 1;
7864 dgst_pos2 = 2;
7865 dgst_pos3 = 3;
7866 break;
7867
7868 case 2600: hash_type = HASH_TYPE_MD5;
7869 salt_type = SALT_TYPE_VIRTUAL;
7870 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7871 opts_type = OPTS_TYPE_PT_GENERATE_LE
7872 | OPTS_TYPE_PT_ADD80
7873 | OPTS_TYPE_PT_ADDBITS14
7874 | OPTS_TYPE_ST_ADD80;
7875 kern_type = KERN_TYPE_MD55_PWSLT1;
7876 dgst_size = DGST_SIZE_4_4;
7877 parse_func = md5md5_parse_hash;
7878 sort_by_digest = sort_by_digest_4_4;
7879 opti_type = OPTI_TYPE_ZERO_BYTE
7880 | OPTI_TYPE_PRECOMPUTE_INIT
7881 | OPTI_TYPE_PRECOMPUTE_MERKLE
7882 | OPTI_TYPE_EARLY_SKIP;
7883 dgst_pos0 = 0;
7884 dgst_pos1 = 3;
7885 dgst_pos2 = 2;
7886 dgst_pos3 = 1;
7887 break;
7888
7889 case 2611: hash_type = HASH_TYPE_MD5;
7890 salt_type = SALT_TYPE_INTERN;
7891 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7892 opts_type = OPTS_TYPE_PT_GENERATE_LE
7893 | OPTS_TYPE_PT_ADD80
7894 | OPTS_TYPE_PT_ADDBITS14
7895 | OPTS_TYPE_ST_ADD80;
7896 kern_type = KERN_TYPE_MD55_PWSLT1;
7897 dgst_size = DGST_SIZE_4_4;
7898 parse_func = vb3_parse_hash;
7899 sort_by_digest = sort_by_digest_4_4;
7900 opti_type = OPTI_TYPE_ZERO_BYTE
7901 | OPTI_TYPE_PRECOMPUTE_INIT
7902 | OPTI_TYPE_PRECOMPUTE_MERKLE
7903 | OPTI_TYPE_EARLY_SKIP;
7904 dgst_pos0 = 0;
7905 dgst_pos1 = 3;
7906 dgst_pos2 = 2;
7907 dgst_pos3 = 1;
7908 break;
7909
7910 case 2612: hash_type = HASH_TYPE_MD5;
7911 salt_type = SALT_TYPE_EMBEDDED;
7912 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7913 opts_type = OPTS_TYPE_PT_GENERATE_LE
7914 | OPTS_TYPE_PT_ADD80
7915 | OPTS_TYPE_PT_ADDBITS14
7916 | OPTS_TYPE_ST_ADD80
7917 | OPTS_TYPE_ST_HEX;
7918 kern_type = KERN_TYPE_MD55_PWSLT1;
7919 dgst_size = DGST_SIZE_4_4;
7920 parse_func = phps_parse_hash;
7921 sort_by_digest = sort_by_digest_4_4;
7922 opti_type = OPTI_TYPE_ZERO_BYTE
7923 | OPTI_TYPE_PRECOMPUTE_INIT
7924 | OPTI_TYPE_PRECOMPUTE_MERKLE
7925 | OPTI_TYPE_EARLY_SKIP;
7926 dgst_pos0 = 0;
7927 dgst_pos1 = 3;
7928 dgst_pos2 = 2;
7929 dgst_pos3 = 1;
7930 break;
7931
7932 case 2711: hash_type = HASH_TYPE_MD5;
7933 salt_type = SALT_TYPE_INTERN;
7934 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7935 opts_type = OPTS_TYPE_PT_GENERATE_LE
7936 | OPTS_TYPE_PT_ADD80
7937 | OPTS_TYPE_PT_ADDBITS14
7938 | OPTS_TYPE_ST_ADD80;
7939 kern_type = KERN_TYPE_MD55_PWSLT2;
7940 dgst_size = DGST_SIZE_4_4;
7941 parse_func = vb30_parse_hash;
7942 sort_by_digest = sort_by_digest_4_4;
7943 opti_type = OPTI_TYPE_ZERO_BYTE
7944 | OPTI_TYPE_PRECOMPUTE_INIT
7945 | OPTI_TYPE_EARLY_SKIP;
7946 dgst_pos0 = 0;
7947 dgst_pos1 = 3;
7948 dgst_pos2 = 2;
7949 dgst_pos3 = 1;
7950 break;
7951
7952 case 2811: hash_type = HASH_TYPE_MD5;
7953 salt_type = SALT_TYPE_INTERN;
7954 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7955 opts_type = OPTS_TYPE_PT_GENERATE_LE
7956 | OPTS_TYPE_PT_ADD80
7957 | OPTS_TYPE_PT_ADDBITS14;
7958 kern_type = KERN_TYPE_MD55_SLTPW;
7959 dgst_size = DGST_SIZE_4_4;
7960 parse_func = ipb2_parse_hash;
7961 sort_by_digest = sort_by_digest_4_4;
7962 opti_type = OPTI_TYPE_ZERO_BYTE
7963 | OPTI_TYPE_PRECOMPUTE_INIT
7964 | OPTI_TYPE_EARLY_SKIP;
7965 dgst_pos0 = 0;
7966 dgst_pos1 = 3;
7967 dgst_pos2 = 2;
7968 dgst_pos3 = 1;
7969 break;
7970
7971 case 3000: hash_type = HASH_TYPE_LM;
7972 salt_type = SALT_TYPE_NONE;
7973 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7974 opts_type = OPTS_TYPE_PT_GENERATE_LE
7975 | OPTS_TYPE_PT_UPPER
7976 | OPTS_TYPE_PT_BITSLICE;
7977 kern_type = KERN_TYPE_LM;
7978 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7979 parse_func = lm_parse_hash;
7980 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7981 opti_type = OPTI_TYPE_ZERO_BYTE
7982 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7983 dgst_pos0 = 0;
7984 dgst_pos1 = 1;
7985 dgst_pos2 = 2;
7986 dgst_pos3 = 3;
7987 break;
7988
7989 case 3100: hash_type = HASH_TYPE_ORACLEH;
7990 salt_type = SALT_TYPE_INTERN;
7991 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7992 opts_type = OPTS_TYPE_PT_GENERATE_LE
7993 | OPTS_TYPE_PT_UPPER
7994 | OPTS_TYPE_ST_UPPER;
7995 kern_type = KERN_TYPE_ORACLEH;
7996 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7997 parse_func = oracleh_parse_hash;
7998 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7999 opti_type = OPTI_TYPE_ZERO_BYTE;
8000 dgst_pos0 = 0;
8001 dgst_pos1 = 1;
8002 dgst_pos2 = 2;
8003 dgst_pos3 = 3;
8004 break;
8005
8006 case 3200: hash_type = HASH_TYPE_BCRYPT;
8007 salt_type = SALT_TYPE_EMBEDDED;
8008 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8009 opts_type = OPTS_TYPE_PT_GENERATE_LE
8010 | OPTS_TYPE_ST_GENERATE_LE;
8011 kern_type = KERN_TYPE_BCRYPT;
8012 dgst_size = DGST_SIZE_4_6;
8013 parse_func = bcrypt_parse_hash;
8014 sort_by_digest = sort_by_digest_4_6;
8015 opti_type = OPTI_TYPE_ZERO_BYTE;
8016 dgst_pos0 = 0;
8017 dgst_pos1 = 1;
8018 dgst_pos2 = 2;
8019 dgst_pos3 = 3;
8020 break;
8021
8022 case 3710: hash_type = HASH_TYPE_MD5;
8023 salt_type = SALT_TYPE_INTERN;
8024 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8025 opts_type = OPTS_TYPE_PT_GENERATE_LE
8026 | OPTS_TYPE_PT_ADD80
8027 | OPTS_TYPE_PT_ADDBITS14;
8028 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8029 dgst_size = DGST_SIZE_4_4;
8030 parse_func = md5s_parse_hash;
8031 sort_by_digest = sort_by_digest_4_4;
8032 opti_type = OPTI_TYPE_ZERO_BYTE
8033 | OPTI_TYPE_PRECOMPUTE_INIT
8034 | OPTI_TYPE_PRECOMPUTE_MERKLE
8035 | OPTI_TYPE_EARLY_SKIP;
8036 dgst_pos0 = 0;
8037 dgst_pos1 = 3;
8038 dgst_pos2 = 2;
8039 dgst_pos3 = 1;
8040 break;
8041
8042 case 3711: hash_type = HASH_TYPE_MD5;
8043 salt_type = SALT_TYPE_EMBEDDED;
8044 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8045 opts_type = OPTS_TYPE_PT_GENERATE_LE
8046 | OPTS_TYPE_PT_ADD80
8047 | OPTS_TYPE_PT_ADDBITS14;
8048 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8049 dgst_size = DGST_SIZE_4_4;
8050 parse_func = mediawiki_b_parse_hash;
8051 sort_by_digest = sort_by_digest_4_4;
8052 opti_type = OPTI_TYPE_ZERO_BYTE
8053 | OPTI_TYPE_PRECOMPUTE_INIT
8054 | OPTI_TYPE_PRECOMPUTE_MERKLE
8055 | OPTI_TYPE_EARLY_SKIP;
8056 dgst_pos0 = 0;
8057 dgst_pos1 = 3;
8058 dgst_pos2 = 2;
8059 dgst_pos3 = 1;
8060 break;
8061
8062 case 3800: hash_type = HASH_TYPE_MD5;
8063 salt_type = SALT_TYPE_INTERN;
8064 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8065 opts_type = OPTS_TYPE_PT_GENERATE_LE
8066 | OPTS_TYPE_ST_ADDBITS14;
8067 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8068 dgst_size = DGST_SIZE_4_4;
8069 parse_func = md5s_parse_hash;
8070 sort_by_digest = sort_by_digest_4_4;
8071 opti_type = OPTI_TYPE_ZERO_BYTE
8072 | OPTI_TYPE_PRECOMPUTE_INIT
8073 | OPTI_TYPE_PRECOMPUTE_MERKLE
8074 | OPTI_TYPE_EARLY_SKIP
8075 | OPTI_TYPE_NOT_ITERATED
8076 | OPTI_TYPE_RAW_HASH;
8077 dgst_pos0 = 0;
8078 dgst_pos1 = 3;
8079 dgst_pos2 = 2;
8080 dgst_pos3 = 1;
8081 break;
8082
8083 case 4300: hash_type = HASH_TYPE_MD5;
8084 salt_type = SALT_TYPE_VIRTUAL;
8085 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8086 opts_type = OPTS_TYPE_PT_GENERATE_LE
8087 | OPTS_TYPE_PT_ADD80
8088 | OPTS_TYPE_PT_ADDBITS14
8089 | OPTS_TYPE_ST_ADD80;
8090 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8091 dgst_size = DGST_SIZE_4_4;
8092 parse_func = md5md5_parse_hash;
8093 sort_by_digest = sort_by_digest_4_4;
8094 opti_type = OPTI_TYPE_ZERO_BYTE
8095 | OPTI_TYPE_PRECOMPUTE_INIT
8096 | OPTI_TYPE_PRECOMPUTE_MERKLE
8097 | OPTI_TYPE_EARLY_SKIP;
8098 dgst_pos0 = 0;
8099 dgst_pos1 = 3;
8100 dgst_pos2 = 2;
8101 dgst_pos3 = 1;
8102 break;
8103
8104
8105 case 4400: hash_type = HASH_TYPE_MD5;
8106 salt_type = SALT_TYPE_NONE;
8107 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8108 opts_type = OPTS_TYPE_PT_GENERATE_BE
8109 | OPTS_TYPE_PT_ADD80
8110 | OPTS_TYPE_PT_ADDBITS15;
8111 kern_type = KERN_TYPE_MD5_SHA1;
8112 dgst_size = DGST_SIZE_4_4;
8113 parse_func = md5_parse_hash;
8114 sort_by_digest = sort_by_digest_4_4;
8115 opti_type = OPTI_TYPE_ZERO_BYTE
8116 | OPTI_TYPE_PRECOMPUTE_INIT
8117 | OPTI_TYPE_PRECOMPUTE_MERKLE
8118 | OPTI_TYPE_EARLY_SKIP
8119 | OPTI_TYPE_NOT_ITERATED
8120 | OPTI_TYPE_NOT_SALTED
8121 | OPTI_TYPE_RAW_HASH;
8122 dgst_pos0 = 0;
8123 dgst_pos1 = 3;
8124 dgst_pos2 = 2;
8125 dgst_pos3 = 1;
8126 break;
8127
8128 case 4500: hash_type = HASH_TYPE_SHA1;
8129 salt_type = SALT_TYPE_NONE;
8130 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8131 opts_type = OPTS_TYPE_PT_GENERATE_BE
8132 | OPTS_TYPE_PT_ADD80
8133 | OPTS_TYPE_PT_ADDBITS15;
8134 kern_type = KERN_TYPE_SHA11;
8135 dgst_size = DGST_SIZE_4_5;
8136 parse_func = sha1_parse_hash;
8137 sort_by_digest = sort_by_digest_4_5;
8138 opti_type = OPTI_TYPE_ZERO_BYTE
8139 | OPTI_TYPE_PRECOMPUTE_INIT
8140 | OPTI_TYPE_PRECOMPUTE_MERKLE
8141 | OPTI_TYPE_EARLY_SKIP
8142 | OPTI_TYPE_NOT_SALTED;
8143 dgst_pos0 = 3;
8144 dgst_pos1 = 4;
8145 dgst_pos2 = 2;
8146 dgst_pos3 = 1;
8147 break;
8148
8149 case 4700: hash_type = HASH_TYPE_SHA1;
8150 salt_type = SALT_TYPE_NONE;
8151 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8152 opts_type = OPTS_TYPE_PT_GENERATE_LE
8153 | OPTS_TYPE_PT_ADD80
8154 | OPTS_TYPE_PT_ADDBITS14;
8155 kern_type = KERN_TYPE_SHA1_MD5;
8156 dgst_size = DGST_SIZE_4_5;
8157 parse_func = sha1_parse_hash;
8158 sort_by_digest = sort_by_digest_4_5;
8159 opti_type = OPTI_TYPE_ZERO_BYTE
8160 | OPTI_TYPE_PRECOMPUTE_INIT
8161 | OPTI_TYPE_PRECOMPUTE_MERKLE
8162 | OPTI_TYPE_EARLY_SKIP
8163 | OPTI_TYPE_NOT_ITERATED
8164 | OPTI_TYPE_NOT_SALTED
8165 | OPTI_TYPE_RAW_HASH;
8166 dgst_pos0 = 3;
8167 dgst_pos1 = 4;
8168 dgst_pos2 = 2;
8169 dgst_pos3 = 1;
8170 break;
8171
8172 case 4800: hash_type = HASH_TYPE_MD5;
8173 salt_type = SALT_TYPE_EMBEDDED;
8174 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8175 opts_type = OPTS_TYPE_PT_GENERATE_LE
8176 | OPTS_TYPE_PT_ADDBITS14;
8177 kern_type = KERN_TYPE_MD5_CHAP;
8178 dgst_size = DGST_SIZE_4_4;
8179 parse_func = chap_parse_hash;
8180 sort_by_digest = sort_by_digest_4_4;
8181 opti_type = OPTI_TYPE_ZERO_BYTE
8182 | OPTI_TYPE_PRECOMPUTE_INIT
8183 | OPTI_TYPE_PRECOMPUTE_MERKLE
8184 | OPTI_TYPE_MEET_IN_MIDDLE
8185 | OPTI_TYPE_EARLY_SKIP
8186 | OPTI_TYPE_NOT_ITERATED
8187 | OPTI_TYPE_RAW_HASH;
8188 dgst_pos0 = 0;
8189 dgst_pos1 = 3;
8190 dgst_pos2 = 2;
8191 dgst_pos3 = 1;
8192 break;
8193
8194 case 4900: hash_type = HASH_TYPE_SHA1;
8195 salt_type = SALT_TYPE_INTERN;
8196 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8197 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8198 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8199 dgst_size = DGST_SIZE_4_5;
8200 parse_func = sha1s_parse_hash;
8201 sort_by_digest = sort_by_digest_4_5;
8202 opti_type = OPTI_TYPE_ZERO_BYTE
8203 | OPTI_TYPE_PRECOMPUTE_INIT
8204 | OPTI_TYPE_PRECOMPUTE_MERKLE
8205 | OPTI_TYPE_EARLY_SKIP;
8206 dgst_pos0 = 3;
8207 dgst_pos1 = 4;
8208 dgst_pos2 = 2;
8209 dgst_pos3 = 1;
8210 break;
8211
8212 case 5000: hash_type = HASH_TYPE_KECCAK;
8213 salt_type = SALT_TYPE_EMBEDDED;
8214 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8215 opts_type = OPTS_TYPE_PT_GENERATE_LE
8216 | OPTS_TYPE_PT_ADD01;
8217 kern_type = KERN_TYPE_KECCAK;
8218 dgst_size = DGST_SIZE_8_25;
8219 parse_func = keccak_parse_hash;
8220 sort_by_digest = sort_by_digest_8_25;
8221 opti_type = OPTI_TYPE_ZERO_BYTE
8222 | OPTI_TYPE_RAW_HASH;
8223 dgst_pos0 = 2;
8224 dgst_pos1 = 3;
8225 dgst_pos2 = 4;
8226 dgst_pos3 = 5;
8227 break;
8228
8229 case 5100: hash_type = HASH_TYPE_MD5H;
8230 salt_type = SALT_TYPE_NONE;
8231 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8232 opts_type = OPTS_TYPE_PT_GENERATE_LE
8233 | OPTS_TYPE_PT_ADD80
8234 | OPTS_TYPE_PT_ADDBITS14;
8235 kern_type = KERN_TYPE_MD5H;
8236 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8237 parse_func = md5half_parse_hash;
8238 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8239 opti_type = OPTI_TYPE_ZERO_BYTE
8240 | OPTI_TYPE_RAW_HASH;
8241 dgst_pos0 = 0;
8242 dgst_pos1 = 1;
8243 dgst_pos2 = 2;
8244 dgst_pos3 = 3;
8245 break;
8246
8247 case 5200: hash_type = HASH_TYPE_SHA256;
8248 salt_type = SALT_TYPE_EMBEDDED;
8249 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8250 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8251 kern_type = KERN_TYPE_PSAFE3;
8252 dgst_size = DGST_SIZE_4_8;
8253 parse_func = psafe3_parse_hash;
8254 sort_by_digest = sort_by_digest_4_8;
8255 opti_type = OPTI_TYPE_ZERO_BYTE;
8256 dgst_pos0 = 0;
8257 dgst_pos1 = 1;
8258 dgst_pos2 = 2;
8259 dgst_pos3 = 3;
8260 break;
8261
8262 case 5300: hash_type = HASH_TYPE_MD5;
8263 salt_type = SALT_TYPE_EMBEDDED;
8264 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8265 opts_type = OPTS_TYPE_PT_GENERATE_LE
8266 | OPTS_TYPE_ST_ADD80;
8267 kern_type = KERN_TYPE_IKEPSK_MD5;
8268 dgst_size = DGST_SIZE_4_4;
8269 parse_func = ikepsk_md5_parse_hash;
8270 sort_by_digest = sort_by_digest_4_4;
8271 opti_type = OPTI_TYPE_ZERO_BYTE;
8272 dgst_pos0 = 0;
8273 dgst_pos1 = 3;
8274 dgst_pos2 = 2;
8275 dgst_pos3 = 1;
8276 break;
8277
8278 case 5400: hash_type = HASH_TYPE_SHA1;
8279 salt_type = SALT_TYPE_EMBEDDED;
8280 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8281 opts_type = OPTS_TYPE_PT_GENERATE_BE
8282 | OPTS_TYPE_ST_ADD80;
8283 kern_type = KERN_TYPE_IKEPSK_SHA1;
8284 dgst_size = DGST_SIZE_4_5;
8285 parse_func = ikepsk_sha1_parse_hash;
8286 sort_by_digest = sort_by_digest_4_5;
8287 opti_type = OPTI_TYPE_ZERO_BYTE;
8288 dgst_pos0 = 3;
8289 dgst_pos1 = 4;
8290 dgst_pos2 = 2;
8291 dgst_pos3 = 1;
8292 break;
8293
8294 case 5500: hash_type = HASH_TYPE_NETNTLM;
8295 salt_type = SALT_TYPE_EMBEDDED;
8296 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8297 opts_type = OPTS_TYPE_PT_GENERATE_LE
8298 | OPTS_TYPE_PT_ADD80
8299 | OPTS_TYPE_PT_ADDBITS14
8300 | OPTS_TYPE_PT_UNICODE
8301 | OPTS_TYPE_ST_HEX;
8302 kern_type = KERN_TYPE_NETNTLMv1;
8303 dgst_size = DGST_SIZE_4_4;
8304 parse_func = netntlmv1_parse_hash;
8305 sort_by_digest = sort_by_digest_4_4;
8306 opti_type = OPTI_TYPE_ZERO_BYTE
8307 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8308 dgst_pos0 = 0;
8309 dgst_pos1 = 1;
8310 dgst_pos2 = 2;
8311 dgst_pos3 = 3;
8312 break;
8313
8314 case 5600: hash_type = HASH_TYPE_MD5;
8315 salt_type = SALT_TYPE_EMBEDDED;
8316 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8317 opts_type = OPTS_TYPE_PT_GENERATE_LE
8318 | OPTS_TYPE_PT_ADD80
8319 | OPTS_TYPE_PT_ADDBITS14
8320 | OPTS_TYPE_PT_UNICODE;
8321 kern_type = KERN_TYPE_NETNTLMv2;
8322 dgst_size = DGST_SIZE_4_4;
8323 parse_func = netntlmv2_parse_hash;
8324 sort_by_digest = sort_by_digest_4_4;
8325 opti_type = OPTI_TYPE_ZERO_BYTE;
8326 dgst_pos0 = 0;
8327 dgst_pos1 = 3;
8328 dgst_pos2 = 2;
8329 dgst_pos3 = 1;
8330 break;
8331
8332 case 5700: hash_type = HASH_TYPE_SHA256;
8333 salt_type = SALT_TYPE_NONE;
8334 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8335 opts_type = OPTS_TYPE_PT_GENERATE_BE
8336 | OPTS_TYPE_PT_ADD80
8337 | OPTS_TYPE_PT_ADDBITS15;
8338 kern_type = KERN_TYPE_SHA256;
8339 dgst_size = DGST_SIZE_4_8;
8340 parse_func = cisco4_parse_hash;
8341 sort_by_digest = sort_by_digest_4_8;
8342 opti_type = OPTI_TYPE_ZERO_BYTE
8343 | OPTI_TYPE_PRECOMPUTE_INIT
8344 | OPTI_TYPE_PRECOMPUTE_MERKLE
8345 | OPTI_TYPE_EARLY_SKIP
8346 | OPTI_TYPE_NOT_ITERATED
8347 | OPTI_TYPE_NOT_SALTED
8348 | OPTI_TYPE_RAW_HASH;
8349 dgst_pos0 = 3;
8350 dgst_pos1 = 7;
8351 dgst_pos2 = 2;
8352 dgst_pos3 = 6;
8353 break;
8354
8355 case 5800: hash_type = HASH_TYPE_SHA1;
8356 salt_type = SALT_TYPE_INTERN;
8357 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8358 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8359 | OPTS_TYPE_ST_ADD80;
8360 kern_type = KERN_TYPE_ANDROIDPIN;
8361 dgst_size = DGST_SIZE_4_5;
8362 parse_func = androidpin_parse_hash;
8363 sort_by_digest = sort_by_digest_4_5;
8364 opti_type = OPTI_TYPE_ZERO_BYTE;
8365 dgst_pos0 = 0;
8366 dgst_pos1 = 1;
8367 dgst_pos2 = 2;
8368 dgst_pos3 = 3;
8369 break;
8370
8371 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8372 salt_type = SALT_TYPE_NONE;
8373 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8374 opts_type = OPTS_TYPE_PT_GENERATE_LE
8375 | OPTS_TYPE_PT_ADD80;
8376 kern_type = KERN_TYPE_RIPEMD160;
8377 dgst_size = DGST_SIZE_4_5;
8378 parse_func = ripemd160_parse_hash;
8379 sort_by_digest = sort_by_digest_4_5;
8380 opti_type = OPTI_TYPE_ZERO_BYTE;
8381 dgst_pos0 = 0;
8382 dgst_pos1 = 1;
8383 dgst_pos2 = 2;
8384 dgst_pos3 = 3;
8385 break;
8386
8387 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8388 salt_type = SALT_TYPE_NONE;
8389 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8390 opts_type = OPTS_TYPE_PT_GENERATE_BE
8391 | OPTS_TYPE_PT_ADD80;
8392 kern_type = KERN_TYPE_WHIRLPOOL;
8393 dgst_size = DGST_SIZE_4_16;
8394 parse_func = whirlpool_parse_hash;
8395 sort_by_digest = sort_by_digest_4_16;
8396 opti_type = OPTI_TYPE_ZERO_BYTE;
8397 dgst_pos0 = 0;
8398 dgst_pos1 = 1;
8399 dgst_pos2 = 2;
8400 dgst_pos3 = 3;
8401 break;
8402
8403 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8404 salt_type = SALT_TYPE_EMBEDDED;
8405 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8406 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8407 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8408 dgst_size = DGST_SIZE_4_5;
8409 parse_func = truecrypt_parse_hash_2k;
8410 sort_by_digest = sort_by_digest_4_5;
8411 opti_type = OPTI_TYPE_ZERO_BYTE;
8412 dgst_pos0 = 0;
8413 dgst_pos1 = 1;
8414 dgst_pos2 = 2;
8415 dgst_pos3 = 3;
8416 break;
8417
8418 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8419 salt_type = SALT_TYPE_EMBEDDED;
8420 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8421 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8422 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8423 dgst_size = DGST_SIZE_4_5;
8424 parse_func = truecrypt_parse_hash_2k;
8425 sort_by_digest = sort_by_digest_4_5;
8426 opti_type = OPTI_TYPE_ZERO_BYTE;
8427 dgst_pos0 = 0;
8428 dgst_pos1 = 1;
8429 dgst_pos2 = 2;
8430 dgst_pos3 = 3;
8431 break;
8432
8433 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8434 salt_type = SALT_TYPE_EMBEDDED;
8435 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8436 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8437 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8438 dgst_size = DGST_SIZE_4_5;
8439 parse_func = truecrypt_parse_hash_2k;
8440 sort_by_digest = sort_by_digest_4_5;
8441 opti_type = OPTI_TYPE_ZERO_BYTE;
8442 dgst_pos0 = 0;
8443 dgst_pos1 = 1;
8444 dgst_pos2 = 2;
8445 dgst_pos3 = 3;
8446 break;
8447
8448 case 6221: hash_type = HASH_TYPE_SHA512;
8449 salt_type = SALT_TYPE_EMBEDDED;
8450 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8451 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8452 kern_type = KERN_TYPE_TCSHA512_XTS512;
8453 dgst_size = DGST_SIZE_8_8;
8454 parse_func = truecrypt_parse_hash_1k;
8455 sort_by_digest = sort_by_digest_8_8;
8456 opti_type = OPTI_TYPE_ZERO_BYTE;
8457 dgst_pos0 = 0;
8458 dgst_pos1 = 1;
8459 dgst_pos2 = 2;
8460 dgst_pos3 = 3;
8461 break;
8462
8463 case 6222: hash_type = HASH_TYPE_SHA512;
8464 salt_type = SALT_TYPE_EMBEDDED;
8465 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8466 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8467 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8468 dgst_size = DGST_SIZE_8_8;
8469 parse_func = truecrypt_parse_hash_1k;
8470 sort_by_digest = sort_by_digest_8_8;
8471 opti_type = OPTI_TYPE_ZERO_BYTE;
8472 dgst_pos0 = 0;
8473 dgst_pos1 = 1;
8474 dgst_pos2 = 2;
8475 dgst_pos3 = 3;
8476 break;
8477
8478 case 6223: hash_type = HASH_TYPE_SHA512;
8479 salt_type = SALT_TYPE_EMBEDDED;
8480 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8481 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8482 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8483 dgst_size = DGST_SIZE_8_8;
8484 parse_func = truecrypt_parse_hash_1k;
8485 sort_by_digest = sort_by_digest_8_8;
8486 opti_type = OPTI_TYPE_ZERO_BYTE;
8487 dgst_pos0 = 0;
8488 dgst_pos1 = 1;
8489 dgst_pos2 = 2;
8490 dgst_pos3 = 3;
8491 break;
8492
8493 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8494 salt_type = SALT_TYPE_EMBEDDED;
8495 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8496 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8497 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8498 dgst_size = DGST_SIZE_4_8;
8499 parse_func = truecrypt_parse_hash_1k;
8500 sort_by_digest = sort_by_digest_4_8;
8501 opti_type = OPTI_TYPE_ZERO_BYTE;
8502 dgst_pos0 = 0;
8503 dgst_pos1 = 1;
8504 dgst_pos2 = 2;
8505 dgst_pos3 = 3;
8506 break;
8507
8508 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8509 salt_type = SALT_TYPE_EMBEDDED;
8510 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8511 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8512 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8513 dgst_size = DGST_SIZE_4_8;
8514 parse_func = truecrypt_parse_hash_1k;
8515 sort_by_digest = sort_by_digest_4_8;
8516 opti_type = OPTI_TYPE_ZERO_BYTE;
8517 dgst_pos0 = 0;
8518 dgst_pos1 = 1;
8519 dgst_pos2 = 2;
8520 dgst_pos3 = 3;
8521 break;
8522
8523 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8524 salt_type = SALT_TYPE_EMBEDDED;
8525 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8526 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8527 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8528 dgst_size = DGST_SIZE_4_8;
8529 parse_func = truecrypt_parse_hash_1k;
8530 sort_by_digest = sort_by_digest_4_8;
8531 opti_type = OPTI_TYPE_ZERO_BYTE;
8532 dgst_pos0 = 0;
8533 dgst_pos1 = 1;
8534 dgst_pos2 = 2;
8535 dgst_pos3 = 3;
8536 break;
8537
8538 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8539 salt_type = SALT_TYPE_EMBEDDED;
8540 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8541 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8542 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8543 dgst_size = DGST_SIZE_4_5;
8544 parse_func = truecrypt_parse_hash_1k;
8545 sort_by_digest = sort_by_digest_4_5;
8546 opti_type = OPTI_TYPE_ZERO_BYTE;
8547 dgst_pos0 = 0;
8548 dgst_pos1 = 1;
8549 dgst_pos2 = 2;
8550 dgst_pos3 = 3;
8551 break;
8552
8553 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8554 salt_type = SALT_TYPE_EMBEDDED;
8555 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8556 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8557 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8558 dgst_size = DGST_SIZE_4_5;
8559 parse_func = truecrypt_parse_hash_1k;
8560 sort_by_digest = sort_by_digest_4_5;
8561 opti_type = OPTI_TYPE_ZERO_BYTE;
8562 dgst_pos0 = 0;
8563 dgst_pos1 = 1;
8564 dgst_pos2 = 2;
8565 dgst_pos3 = 3;
8566 break;
8567
8568 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8569 salt_type = SALT_TYPE_EMBEDDED;
8570 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8571 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8572 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8573 dgst_size = DGST_SIZE_4_5;
8574 parse_func = truecrypt_parse_hash_1k;
8575 sort_by_digest = sort_by_digest_4_5;
8576 opti_type = OPTI_TYPE_ZERO_BYTE;
8577 dgst_pos0 = 0;
8578 dgst_pos1 = 1;
8579 dgst_pos2 = 2;
8580 dgst_pos3 = 3;
8581 break;
8582
8583 case 6300: hash_type = HASH_TYPE_MD5;
8584 salt_type = SALT_TYPE_EMBEDDED;
8585 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8586 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8587 kern_type = KERN_TYPE_MD5AIX;
8588 dgst_size = DGST_SIZE_4_4;
8589 parse_func = md5aix_parse_hash;
8590 sort_by_digest = sort_by_digest_4_4;
8591 opti_type = OPTI_TYPE_ZERO_BYTE;
8592 dgst_pos0 = 0;
8593 dgst_pos1 = 1;
8594 dgst_pos2 = 2;
8595 dgst_pos3 = 3;
8596 break;
8597
8598 case 6400: hash_type = HASH_TYPE_SHA256;
8599 salt_type = SALT_TYPE_EMBEDDED;
8600 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8601 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8602 kern_type = KERN_TYPE_SHA256AIX;
8603 dgst_size = DGST_SIZE_4_8;
8604 parse_func = sha256aix_parse_hash;
8605 sort_by_digest = sort_by_digest_4_8;
8606 opti_type = OPTI_TYPE_ZERO_BYTE;
8607 dgst_pos0 = 0;
8608 dgst_pos1 = 1;
8609 dgst_pos2 = 2;
8610 dgst_pos3 = 3;
8611 break;
8612
8613 case 6500: hash_type = HASH_TYPE_SHA512;
8614 salt_type = SALT_TYPE_EMBEDDED;
8615 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8616 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8617 kern_type = KERN_TYPE_SHA512AIX;
8618 dgst_size = DGST_SIZE_8_8;
8619 parse_func = sha512aix_parse_hash;
8620 sort_by_digest = sort_by_digest_8_8;
8621 opti_type = OPTI_TYPE_ZERO_BYTE;
8622 dgst_pos0 = 0;
8623 dgst_pos1 = 1;
8624 dgst_pos2 = 2;
8625 dgst_pos3 = 3;
8626 break;
8627
8628 case 6600: hash_type = HASH_TYPE_AES;
8629 salt_type = SALT_TYPE_EMBEDDED;
8630 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8631 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8632 kern_type = KERN_TYPE_AGILEKEY;
8633 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8634 parse_func = agilekey_parse_hash;
8635 sort_by_digest = sort_by_digest_4_5;
8636 opti_type = OPTI_TYPE_ZERO_BYTE;
8637 dgst_pos0 = 0;
8638 dgst_pos1 = 1;
8639 dgst_pos2 = 2;
8640 dgst_pos3 = 3;
8641 break;
8642
8643 case 6700: hash_type = HASH_TYPE_SHA1;
8644 salt_type = SALT_TYPE_EMBEDDED;
8645 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8646 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8647 kern_type = KERN_TYPE_SHA1AIX;
8648 dgst_size = DGST_SIZE_4_5;
8649 parse_func = sha1aix_parse_hash;
8650 sort_by_digest = sort_by_digest_4_5;
8651 opti_type = OPTI_TYPE_ZERO_BYTE;
8652 dgst_pos0 = 0;
8653 dgst_pos1 = 1;
8654 dgst_pos2 = 2;
8655 dgst_pos3 = 3;
8656 break;
8657
8658 case 6800: hash_type = HASH_TYPE_AES;
8659 salt_type = SALT_TYPE_EMBEDDED;
8660 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8661 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8662 kern_type = KERN_TYPE_LASTPASS;
8663 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
8664 parse_func = lastpass_parse_hash;
8665 sort_by_digest = sort_by_digest_4_8;
8666 opti_type = OPTI_TYPE_ZERO_BYTE;
8667 dgst_pos0 = 0;
8668 dgst_pos1 = 1;
8669 dgst_pos2 = 2;
8670 dgst_pos3 = 3;
8671 break;
8672
8673 case 6900: hash_type = HASH_TYPE_GOST;
8674 salt_type = SALT_TYPE_NONE;
8675 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8676 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8677 kern_type = KERN_TYPE_GOST;
8678 dgst_size = DGST_SIZE_4_8;
8679 parse_func = gost_parse_hash;
8680 sort_by_digest = sort_by_digest_4_8;
8681 opti_type = OPTI_TYPE_ZERO_BYTE;
8682 dgst_pos0 = 0;
8683 dgst_pos1 = 1;
8684 dgst_pos2 = 2;
8685 dgst_pos3 = 3;
8686 break;
8687
8688 case 7100: hash_type = HASH_TYPE_SHA512;
8689 salt_type = SALT_TYPE_EMBEDDED;
8690 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8691 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8692 kern_type = KERN_TYPE_PBKDF2_SHA512;
8693 dgst_size = DGST_SIZE_8_16;
8694 parse_func = sha512osx_parse_hash;
8695 sort_by_digest = sort_by_digest_8_16;
8696 opti_type = OPTI_TYPE_ZERO_BYTE;
8697 dgst_pos0 = 0;
8698 dgst_pos1 = 1;
8699 dgst_pos2 = 2;
8700 dgst_pos3 = 3;
8701 break;
8702
8703 case 7200: hash_type = HASH_TYPE_SHA512;
8704 salt_type = SALT_TYPE_EMBEDDED;
8705 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8706 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8707 kern_type = KERN_TYPE_PBKDF2_SHA512;
8708 dgst_size = DGST_SIZE_8_16;
8709 parse_func = sha512grub_parse_hash;
8710 sort_by_digest = sort_by_digest_8_16;
8711 opti_type = OPTI_TYPE_ZERO_BYTE;
8712 dgst_pos0 = 0;
8713 dgst_pos1 = 1;
8714 dgst_pos2 = 2;
8715 dgst_pos3 = 3;
8716 break;
8717
8718 case 7300: hash_type = HASH_TYPE_SHA1;
8719 salt_type = SALT_TYPE_EMBEDDED;
8720 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8721 opts_type = OPTS_TYPE_PT_GENERATE_BE
8722 | OPTS_TYPE_ST_ADD80
8723 | OPTS_TYPE_ST_ADDBITS15;
8724 kern_type = KERN_TYPE_RAKP;
8725 dgst_size = DGST_SIZE_4_5;
8726 parse_func = rakp_parse_hash;
8727 sort_by_digest = sort_by_digest_4_5;
8728 opti_type = OPTI_TYPE_ZERO_BYTE
8729 | OPTI_TYPE_NOT_ITERATED;
8730 dgst_pos0 = 3;
8731 dgst_pos1 = 4;
8732 dgst_pos2 = 2;
8733 dgst_pos3 = 1;
8734 break;
8735
8736 case 7400: hash_type = HASH_TYPE_SHA256;
8737 salt_type = SALT_TYPE_EMBEDDED;
8738 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8739 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8740 kern_type = KERN_TYPE_SHA256CRYPT;
8741 dgst_size = DGST_SIZE_4_8;
8742 parse_func = sha256crypt_parse_hash;
8743 sort_by_digest = sort_by_digest_4_8;
8744 opti_type = OPTI_TYPE_ZERO_BYTE;
8745 dgst_pos0 = 0;
8746 dgst_pos1 = 1;
8747 dgst_pos2 = 2;
8748 dgst_pos3 = 3;
8749 break;
8750
8751 case 7500: hash_type = HASH_TYPE_KRB5PA;
8752 salt_type = SALT_TYPE_EMBEDDED;
8753 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8754 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8755 kern_type = KERN_TYPE_KRB5PA;
8756 dgst_size = DGST_SIZE_4_4;
8757 parse_func = krb5pa_parse_hash;
8758 sort_by_digest = sort_by_digest_4_4;
8759 opti_type = OPTI_TYPE_ZERO_BYTE
8760 | OPTI_TYPE_NOT_ITERATED;
8761 dgst_pos0 = 3;
8762 dgst_pos1 = 7;
8763 dgst_pos2 = 2;
8764 dgst_pos3 = 6;
8765 break;
8766
8767 case 7600: hash_type = HASH_TYPE_SHA1;
8768 salt_type = SALT_TYPE_INTERN;
8769 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8770 opts_type = OPTS_TYPE_PT_GENERATE_BE
8771 | OPTS_TYPE_PT_ADD80
8772 | OPTS_TYPE_PT_ADDBITS15;
8773 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
8774 dgst_size = DGST_SIZE_4_5;
8775 parse_func = redmine_parse_hash;
8776 sort_by_digest = sort_by_digest_4_5;
8777 opti_type = OPTI_TYPE_ZERO_BYTE
8778 | OPTI_TYPE_PRECOMPUTE_INIT
8779 | OPTI_TYPE_EARLY_SKIP
8780 | OPTI_TYPE_NOT_ITERATED
8781 | OPTI_TYPE_PREPENDED_SALT;
8782 dgst_pos0 = 3;
8783 dgst_pos1 = 4;
8784 dgst_pos2 = 2;
8785 dgst_pos3 = 1;
8786 break;
8787
8788 case 7700: hash_type = HASH_TYPE_SAPB;
8789 salt_type = SALT_TYPE_EMBEDDED;
8790 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8791 opts_type = OPTS_TYPE_PT_GENERATE_LE
8792 | OPTS_TYPE_PT_UPPER
8793 | OPTS_TYPE_ST_UPPER;
8794 kern_type = KERN_TYPE_SAPB;
8795 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8796 parse_func = sapb_parse_hash;
8797 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8798 opti_type = OPTI_TYPE_ZERO_BYTE
8799 | OPTI_TYPE_PRECOMPUTE_INIT
8800 | OPTI_TYPE_NOT_ITERATED;
8801 dgst_pos0 = 0;
8802 dgst_pos1 = 1;
8803 dgst_pos2 = 2;
8804 dgst_pos3 = 3;
8805 break;
8806
8807 case 7800: hash_type = HASH_TYPE_SAPG;
8808 salt_type = SALT_TYPE_EMBEDDED;
8809 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8810 opts_type = OPTS_TYPE_PT_GENERATE_BE
8811 | OPTS_TYPE_ST_ADD80
8812 | OPTS_TYPE_ST_UPPER;
8813 kern_type = KERN_TYPE_SAPG;
8814 dgst_size = DGST_SIZE_4_5;
8815 parse_func = sapg_parse_hash;
8816 sort_by_digest = sort_by_digest_4_5;
8817 opti_type = OPTI_TYPE_ZERO_BYTE
8818 | OPTI_TYPE_PRECOMPUTE_INIT
8819 | OPTI_TYPE_NOT_ITERATED;
8820 dgst_pos0 = 3;
8821 dgst_pos1 = 4;
8822 dgst_pos2 = 2;
8823 dgst_pos3 = 1;
8824 break;
8825
8826 case 7900: hash_type = HASH_TYPE_SHA512;
8827 salt_type = SALT_TYPE_EMBEDDED;
8828 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8829 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8830 kern_type = KERN_TYPE_DRUPAL7;
8831 dgst_size = DGST_SIZE_8_8;
8832 parse_func = drupal7_parse_hash;
8833 sort_by_digest = sort_by_digest_8_8;
8834 opti_type = OPTI_TYPE_ZERO_BYTE;
8835 dgst_pos0 = 0;
8836 dgst_pos1 = 1;
8837 dgst_pos2 = 2;
8838 dgst_pos3 = 3;
8839 break;
8840
8841 case 8000: hash_type = HASH_TYPE_SHA256;
8842 salt_type = SALT_TYPE_EMBEDDED;
8843 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8844 opts_type = OPTS_TYPE_PT_GENERATE_BE
8845 | OPTS_TYPE_PT_UNICODE
8846 | OPTS_TYPE_ST_ADD80
8847 | OPTS_TYPE_ST_HEX;
8848 kern_type = KERN_TYPE_SYBASEASE;
8849 dgst_size = DGST_SIZE_4_8;
8850 parse_func = sybasease_parse_hash;
8851 sort_by_digest = sort_by_digest_4_8;
8852 opti_type = OPTI_TYPE_ZERO_BYTE
8853 | OPTI_TYPE_PRECOMPUTE_INIT
8854 | OPTI_TYPE_EARLY_SKIP
8855 | OPTI_TYPE_NOT_ITERATED
8856 | OPTI_TYPE_RAW_HASH;
8857 dgst_pos0 = 3;
8858 dgst_pos1 = 7;
8859 dgst_pos2 = 2;
8860 dgst_pos3 = 6;
8861 break;
8862
8863 case 8100: hash_type = HASH_TYPE_SHA1;
8864 salt_type = SALT_TYPE_EMBEDDED;
8865 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8866 opts_type = OPTS_TYPE_PT_GENERATE_BE;
8867 kern_type = KERN_TYPE_NETSCALER;
8868 dgst_size = DGST_SIZE_4_5;
8869 parse_func = netscaler_parse_hash;
8870 sort_by_digest = sort_by_digest_4_5;
8871 opti_type = OPTI_TYPE_ZERO_BYTE
8872 | OPTI_TYPE_PRECOMPUTE_INIT
8873 | OPTI_TYPE_PRECOMPUTE_MERKLE
8874 | OPTI_TYPE_EARLY_SKIP
8875 | OPTI_TYPE_NOT_ITERATED
8876 | OPTI_TYPE_PREPENDED_SALT
8877 | OPTI_TYPE_RAW_HASH;
8878 dgst_pos0 = 3;
8879 dgst_pos1 = 4;
8880 dgst_pos2 = 2;
8881 dgst_pos3 = 1;
8882 break;
8883
8884 case 8200: hash_type = HASH_TYPE_SHA256;
8885 salt_type = SALT_TYPE_EMBEDDED;
8886 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8887 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8888 kern_type = KERN_TYPE_CLOUDKEY;
8889 dgst_size = DGST_SIZE_4_8;
8890 parse_func = cloudkey_parse_hash;
8891 sort_by_digest = sort_by_digest_4_8;
8892 opti_type = OPTI_TYPE_ZERO_BYTE;
8893 dgst_pos0 = 0;
8894 dgst_pos1 = 1;
8895 dgst_pos2 = 2;
8896 dgst_pos3 = 3;
8897 break;
8898
8899 case 8300: hash_type = HASH_TYPE_SHA1;
8900 salt_type = SALT_TYPE_EMBEDDED;
8901 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8902 opts_type = OPTS_TYPE_PT_GENERATE_LE
8903 | OPTS_TYPE_ST_HEX
8904 | OPTS_TYPE_ST_ADD80;
8905 kern_type = KERN_TYPE_NSEC3;
8906 dgst_size = DGST_SIZE_4_5;
8907 parse_func = nsec3_parse_hash;
8908 sort_by_digest = sort_by_digest_4_5;
8909 opti_type = OPTI_TYPE_ZERO_BYTE;
8910 dgst_pos0 = 3;
8911 dgst_pos1 = 4;
8912 dgst_pos2 = 2;
8913 dgst_pos3 = 1;
8914 break;
8915
8916 case 8400: hash_type = HASH_TYPE_SHA1;
8917 salt_type = SALT_TYPE_INTERN;
8918 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8919 opts_type = OPTS_TYPE_PT_GENERATE_BE
8920 | OPTS_TYPE_PT_ADD80
8921 | OPTS_TYPE_PT_ADDBITS15;
8922 kern_type = KERN_TYPE_WBB3;
8923 dgst_size = DGST_SIZE_4_5;
8924 parse_func = wbb3_parse_hash;
8925 sort_by_digest = sort_by_digest_4_5;
8926 opti_type = OPTI_TYPE_ZERO_BYTE
8927 | OPTI_TYPE_PRECOMPUTE_INIT
8928 | OPTI_TYPE_NOT_ITERATED;
8929 dgst_pos0 = 3;
8930 dgst_pos1 = 4;
8931 dgst_pos2 = 2;
8932 dgst_pos3 = 1;
8933 break;
8934
8935 case 8500: hash_type = HASH_TYPE_DESRACF;
8936 salt_type = SALT_TYPE_EMBEDDED;
8937 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8938 opts_type = OPTS_TYPE_PT_GENERATE_LE
8939 | OPTS_TYPE_ST_UPPER;
8940 kern_type = KERN_TYPE_RACF;
8941 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8942 parse_func = racf_parse_hash;
8943 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8944 opti_type = OPTI_TYPE_ZERO_BYTE
8945 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8946 dgst_pos0 = 0;
8947 dgst_pos1 = 1;
8948 dgst_pos2 = 2;
8949 dgst_pos3 = 3;
8950 break;
8951
8952 case 8600: hash_type = HASH_TYPE_LOTUS5;
8953 salt_type = SALT_TYPE_NONE;
8954 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8955 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8956 kern_type = KERN_TYPE_LOTUS5;
8957 dgst_size = DGST_SIZE_4_4;
8958 parse_func = lotus5_parse_hash;
8959 sort_by_digest = sort_by_digest_4_4;
8960 opti_type = OPTI_TYPE_EARLY_SKIP
8961 | OPTI_TYPE_NOT_ITERATED
8962 | OPTI_TYPE_NOT_SALTED
8963 | OPTI_TYPE_RAW_HASH;
8964 dgst_pos0 = 0;
8965 dgst_pos1 = 1;
8966 dgst_pos2 = 2;
8967 dgst_pos3 = 3;
8968 break;
8969
8970 case 8700: hash_type = HASH_TYPE_LOTUS6;
8971 salt_type = SALT_TYPE_EMBEDDED;
8972 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8973 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8974 kern_type = KERN_TYPE_LOTUS6;
8975 dgst_size = DGST_SIZE_4_4;
8976 parse_func = lotus6_parse_hash;
8977 sort_by_digest = sort_by_digest_4_4;
8978 opti_type = OPTI_TYPE_EARLY_SKIP
8979 | OPTI_TYPE_NOT_ITERATED
8980 | OPTI_TYPE_RAW_HASH;
8981 dgst_pos0 = 0;
8982 dgst_pos1 = 1;
8983 dgst_pos2 = 2;
8984 dgst_pos3 = 3;
8985 break;
8986
8987 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
8988 salt_type = SALT_TYPE_EMBEDDED;
8989 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8990 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8991 kern_type = KERN_TYPE_ANDROIDFDE;
8992 dgst_size = DGST_SIZE_4_4;
8993 parse_func = androidfde_parse_hash;
8994 sort_by_digest = sort_by_digest_4_4;
8995 opti_type = OPTI_TYPE_ZERO_BYTE;
8996 dgst_pos0 = 0;
8997 dgst_pos1 = 1;
8998 dgst_pos2 = 2;
8999 dgst_pos3 = 3;
9000 break;
9001
9002 case 8900: hash_type = HASH_TYPE_SCRYPT;
9003 salt_type = SALT_TYPE_EMBEDDED;
9004 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9005 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9006 kern_type = KERN_TYPE_SCRYPT;
9007 dgst_size = DGST_SIZE_4_8;
9008 parse_func = scrypt_parse_hash;
9009 sort_by_digest = sort_by_digest_4_8;
9010 opti_type = OPTI_TYPE_ZERO_BYTE;
9011 dgst_pos0 = 0;
9012 dgst_pos1 = 1;
9013 dgst_pos2 = 2;
9014 dgst_pos3 = 3;
9015 break;
9016
9017 case 9000: hash_type = HASH_TYPE_SHA1;
9018 salt_type = SALT_TYPE_EMBEDDED;
9019 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9020 opts_type = OPTS_TYPE_PT_GENERATE_LE
9021 | OPTS_TYPE_ST_GENERATE_LE;
9022 kern_type = KERN_TYPE_PSAFE2;
9023 dgst_size = DGST_SIZE_4_5;
9024 parse_func = psafe2_parse_hash;
9025 sort_by_digest = sort_by_digest_4_5;
9026 opti_type = OPTI_TYPE_ZERO_BYTE;
9027 dgst_pos0 = 0;
9028 dgst_pos1 = 1;
9029 dgst_pos2 = 2;
9030 dgst_pos3 = 3;
9031 break;
9032
9033 case 9100: hash_type = HASH_TYPE_LOTUS8;
9034 salt_type = SALT_TYPE_EMBEDDED;
9035 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9036 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9037 kern_type = KERN_TYPE_LOTUS8;
9038 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9039 parse_func = lotus8_parse_hash;
9040 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9041 opti_type = OPTI_TYPE_ZERO_BYTE;
9042 dgst_pos0 = 0;
9043 dgst_pos1 = 1;
9044 dgst_pos2 = 2;
9045 dgst_pos3 = 3;
9046 break;
9047
9048 case 9200: hash_type = HASH_TYPE_SHA256;
9049 salt_type = SALT_TYPE_EMBEDDED;
9050 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9051 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9052 kern_type = KERN_TYPE_PBKDF2_SHA256;
9053 dgst_size = DGST_SIZE_4_32;
9054 parse_func = cisco8_parse_hash;
9055 sort_by_digest = sort_by_digest_4_32;
9056 opti_type = OPTI_TYPE_ZERO_BYTE;
9057 dgst_pos0 = 0;
9058 dgst_pos1 = 1;
9059 dgst_pos2 = 2;
9060 dgst_pos3 = 3;
9061 break;
9062
9063 case 9300: hash_type = HASH_TYPE_SCRYPT;
9064 salt_type = SALT_TYPE_EMBEDDED;
9065 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9066 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9067 kern_type = KERN_TYPE_SCRYPT;
9068 dgst_size = DGST_SIZE_4_8;
9069 parse_func = cisco9_parse_hash;
9070 sort_by_digest = sort_by_digest_4_8;
9071 opti_type = OPTI_TYPE_ZERO_BYTE;
9072 dgst_pos0 = 0;
9073 dgst_pos1 = 1;
9074 dgst_pos2 = 2;
9075 dgst_pos3 = 3;
9076 break;
9077
9078 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9079 salt_type = SALT_TYPE_EMBEDDED;
9080 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9081 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9082 kern_type = KERN_TYPE_OFFICE2007;
9083 dgst_size = DGST_SIZE_4_4;
9084 parse_func = office2007_parse_hash;
9085 sort_by_digest = sort_by_digest_4_4;
9086 opti_type = OPTI_TYPE_ZERO_BYTE;
9087 dgst_pos0 = 0;
9088 dgst_pos1 = 1;
9089 dgst_pos2 = 2;
9090 dgst_pos3 = 3;
9091 break;
9092
9093 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9094 salt_type = SALT_TYPE_EMBEDDED;
9095 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9096 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9097 kern_type = KERN_TYPE_OFFICE2010;
9098 dgst_size = DGST_SIZE_4_4;
9099 parse_func = office2010_parse_hash;
9100 sort_by_digest = sort_by_digest_4_4;
9101 opti_type = OPTI_TYPE_ZERO_BYTE;
9102 dgst_pos0 = 0;
9103 dgst_pos1 = 1;
9104 dgst_pos2 = 2;
9105 dgst_pos3 = 3;
9106 break;
9107
9108 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9109 salt_type = SALT_TYPE_EMBEDDED;
9110 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9111 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9112 kern_type = KERN_TYPE_OFFICE2013;
9113 dgst_size = DGST_SIZE_4_4;
9114 parse_func = office2013_parse_hash;
9115 sort_by_digest = sort_by_digest_4_4;
9116 opti_type = OPTI_TYPE_ZERO_BYTE;
9117 dgst_pos0 = 0;
9118 dgst_pos1 = 1;
9119 dgst_pos2 = 2;
9120 dgst_pos3 = 3;
9121 break;
9122
9123 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9124 salt_type = SALT_TYPE_EMBEDDED;
9125 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9126 opts_type = OPTS_TYPE_PT_GENERATE_LE
9127 | OPTS_TYPE_PT_ADD80
9128 | OPTS_TYPE_PT_UNICODE;
9129 kern_type = KERN_TYPE_OLDOFFICE01;
9130 dgst_size = DGST_SIZE_4_4;
9131 parse_func = oldoffice01_parse_hash;
9132 sort_by_digest = sort_by_digest_4_4;
9133 opti_type = OPTI_TYPE_ZERO_BYTE
9134 | OPTI_TYPE_PRECOMPUTE_INIT
9135 | OPTI_TYPE_NOT_ITERATED;
9136 dgst_pos0 = 0;
9137 dgst_pos1 = 1;
9138 dgst_pos2 = 2;
9139 dgst_pos3 = 3;
9140 break;
9141
9142 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9143 salt_type = SALT_TYPE_EMBEDDED;
9144 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9145 opts_type = OPTS_TYPE_PT_GENERATE_LE
9146 | OPTS_TYPE_PT_ADD80;
9147 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9148 dgst_size = DGST_SIZE_4_4;
9149 parse_func = oldoffice01cm1_parse_hash;
9150 sort_by_digest = sort_by_digest_4_4;
9151 opti_type = OPTI_TYPE_ZERO_BYTE
9152 | OPTI_TYPE_PRECOMPUTE_INIT
9153 | OPTI_TYPE_NOT_ITERATED;
9154 dgst_pos0 = 0;
9155 dgst_pos1 = 1;
9156 dgst_pos2 = 2;
9157 dgst_pos3 = 3;
9158 break;
9159
9160 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9161 salt_type = SALT_TYPE_EMBEDDED;
9162 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9163 opts_type = OPTS_TYPE_PT_GENERATE_LE
9164 | OPTS_TYPE_PT_ADD80
9165 | OPTS_TYPE_PT_UNICODE
9166 | OPTS_TYPE_PT_NEVERCRACK;
9167 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9168 dgst_size = DGST_SIZE_4_4;
9169 parse_func = oldoffice01cm2_parse_hash;
9170 sort_by_digest = sort_by_digest_4_4;
9171 opti_type = OPTI_TYPE_ZERO_BYTE
9172 | OPTI_TYPE_PRECOMPUTE_INIT
9173 | OPTI_TYPE_NOT_ITERATED;
9174 dgst_pos0 = 0;
9175 dgst_pos1 = 1;
9176 dgst_pos2 = 2;
9177 dgst_pos3 = 3;
9178 break;
9179
9180 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9181 salt_type = SALT_TYPE_EMBEDDED;
9182 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9183 opts_type = OPTS_TYPE_PT_GENERATE_BE
9184 | OPTS_TYPE_PT_ADD80
9185 | OPTS_TYPE_PT_UNICODE;
9186 kern_type = KERN_TYPE_OLDOFFICE34;
9187 dgst_size = DGST_SIZE_4_4;
9188 parse_func = oldoffice34_parse_hash;
9189 sort_by_digest = sort_by_digest_4_4;
9190 opti_type = OPTI_TYPE_ZERO_BYTE
9191 | OPTI_TYPE_PRECOMPUTE_INIT
9192 | OPTI_TYPE_NOT_ITERATED;
9193 dgst_pos0 = 0;
9194 dgst_pos1 = 1;
9195 dgst_pos2 = 2;
9196 dgst_pos3 = 3;
9197 break;
9198
9199 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9200 salt_type = SALT_TYPE_EMBEDDED;
9201 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9202 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9203 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9204 dgst_size = DGST_SIZE_4_4;
9205 parse_func = oldoffice34cm1_parse_hash;
9206 sort_by_digest = sort_by_digest_4_4;
9207 opti_type = OPTI_TYPE_ZERO_BYTE
9208 | OPTI_TYPE_PRECOMPUTE_INIT
9209 | OPTI_TYPE_NOT_ITERATED;
9210 dgst_pos0 = 0;
9211 dgst_pos1 = 1;
9212 dgst_pos2 = 2;
9213 dgst_pos3 = 3;
9214 break;
9215
9216 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9217 salt_type = SALT_TYPE_EMBEDDED;
9218 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9219 opts_type = OPTS_TYPE_PT_GENERATE_BE
9220 | OPTS_TYPE_PT_ADD80
9221 | OPTS_TYPE_PT_UNICODE
9222 | OPTS_TYPE_PT_NEVERCRACK;
9223 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9224 dgst_size = DGST_SIZE_4_4;
9225 parse_func = oldoffice34cm2_parse_hash;
9226 sort_by_digest = sort_by_digest_4_4;
9227 opti_type = OPTI_TYPE_ZERO_BYTE
9228 | OPTI_TYPE_PRECOMPUTE_INIT
9229 | OPTI_TYPE_NOT_ITERATED;
9230 dgst_pos0 = 0;
9231 dgst_pos1 = 1;
9232 dgst_pos2 = 2;
9233 dgst_pos3 = 3;
9234 break;
9235
9236 case 9900: hash_type = HASH_TYPE_MD5;
9237 salt_type = SALT_TYPE_NONE;
9238 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9239 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9240 kern_type = KERN_TYPE_RADMIN2;
9241 dgst_size = DGST_SIZE_4_4;
9242 parse_func = radmin2_parse_hash;
9243 sort_by_digest = sort_by_digest_4_4;
9244 opti_type = OPTI_TYPE_ZERO_BYTE
9245 | OPTI_TYPE_PRECOMPUTE_INIT
9246 | OPTI_TYPE_EARLY_SKIP
9247 | OPTI_TYPE_NOT_ITERATED
9248 | OPTI_TYPE_NOT_SALTED;
9249 dgst_pos0 = 0;
9250 dgst_pos1 = 3;
9251 dgst_pos2 = 2;
9252 dgst_pos3 = 1;
9253 break;
9254
9255 case 10000: hash_type = HASH_TYPE_SHA256;
9256 salt_type = SALT_TYPE_EMBEDDED;
9257 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9258 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9259 kern_type = KERN_TYPE_PBKDF2_SHA256;
9260 dgst_size = DGST_SIZE_4_32;
9261 parse_func = djangopbkdf2_parse_hash;
9262 sort_by_digest = sort_by_digest_4_32;
9263 opti_type = OPTI_TYPE_ZERO_BYTE;
9264 dgst_pos0 = 0;
9265 dgst_pos1 = 1;
9266 dgst_pos2 = 2;
9267 dgst_pos3 = 3;
9268 break;
9269
9270 case 10100: hash_type = HASH_TYPE_SIPHASH;
9271 salt_type = SALT_TYPE_EMBEDDED;
9272 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9273 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9274 kern_type = KERN_TYPE_SIPHASH;
9275 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9276 parse_func = siphash_parse_hash;
9277 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9278 opti_type = OPTI_TYPE_ZERO_BYTE
9279 | OPTI_TYPE_NOT_ITERATED
9280 | OPTI_TYPE_RAW_HASH;
9281 dgst_pos0 = 0;
9282 dgst_pos1 = 1;
9283 dgst_pos2 = 2;
9284 dgst_pos3 = 3;
9285 break;
9286
9287 case 10200: hash_type = HASH_TYPE_MD5;
9288 salt_type = SALT_TYPE_EMBEDDED;
9289 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9290 opts_type = OPTS_TYPE_PT_GENERATE_LE
9291 | OPTS_TYPE_ST_ADD80
9292 | OPTS_TYPE_ST_ADDBITS14;
9293 kern_type = KERN_TYPE_HMACMD5_PW;
9294 dgst_size = DGST_SIZE_4_4;
9295 parse_func = crammd5_parse_hash;
9296 sort_by_digest = sort_by_digest_4_4;
9297 opti_type = OPTI_TYPE_ZERO_BYTE
9298 | OPTI_TYPE_NOT_ITERATED;
9299 dgst_pos0 = 0;
9300 dgst_pos1 = 3;
9301 dgst_pos2 = 2;
9302 dgst_pos3 = 1;
9303 break;
9304
9305 case 10300: hash_type = HASH_TYPE_SHA1;
9306 salt_type = SALT_TYPE_EMBEDDED;
9307 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9308 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9309 kern_type = KERN_TYPE_SAPH_SHA1;
9310 dgst_size = DGST_SIZE_4_5;
9311 parse_func = saph_sha1_parse_hash;
9312 sort_by_digest = sort_by_digest_4_5;
9313 opti_type = OPTI_TYPE_ZERO_BYTE;
9314 dgst_pos0 = 0;
9315 dgst_pos1 = 1;
9316 dgst_pos2 = 2;
9317 dgst_pos3 = 3;
9318 break;
9319
9320 case 10400: hash_type = HASH_TYPE_PDFU16;
9321 salt_type = SALT_TYPE_EMBEDDED;
9322 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9323 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9324 kern_type = KERN_TYPE_PDF11;
9325 dgst_size = DGST_SIZE_4_4;
9326 parse_func = pdf11_parse_hash;
9327 sort_by_digest = sort_by_digest_4_4;
9328 opti_type = OPTI_TYPE_ZERO_BYTE
9329 | OPTI_TYPE_NOT_ITERATED;
9330 dgst_pos0 = 0;
9331 dgst_pos1 = 1;
9332 dgst_pos2 = 2;
9333 dgst_pos3 = 3;
9334 break;
9335
9336 case 10410: hash_type = HASH_TYPE_PDFU16;
9337 salt_type = SALT_TYPE_EMBEDDED;
9338 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9339 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9340 kern_type = KERN_TYPE_PDF11CM1;
9341 dgst_size = DGST_SIZE_4_4;
9342 parse_func = pdf11cm1_parse_hash;
9343 sort_by_digest = sort_by_digest_4_4;
9344 opti_type = OPTI_TYPE_ZERO_BYTE
9345 | OPTI_TYPE_NOT_ITERATED;
9346 dgst_pos0 = 0;
9347 dgst_pos1 = 1;
9348 dgst_pos2 = 2;
9349 dgst_pos3 = 3;
9350 break;
9351
9352 case 10420: hash_type = HASH_TYPE_PDFU16;
9353 salt_type = SALT_TYPE_EMBEDDED;
9354 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9355 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9356 kern_type = KERN_TYPE_PDF11CM2;
9357 dgst_size = DGST_SIZE_4_4;
9358 parse_func = pdf11cm2_parse_hash;
9359 sort_by_digest = sort_by_digest_4_4;
9360 opti_type = OPTI_TYPE_ZERO_BYTE
9361 | OPTI_TYPE_NOT_ITERATED;
9362 dgst_pos0 = 0;
9363 dgst_pos1 = 1;
9364 dgst_pos2 = 2;
9365 dgst_pos3 = 3;
9366 break;
9367
9368 case 10500: hash_type = HASH_TYPE_PDFU16;
9369 salt_type = SALT_TYPE_EMBEDDED;
9370 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9371 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9372 kern_type = KERN_TYPE_PDF14;
9373 dgst_size = DGST_SIZE_4_4;
9374 parse_func = pdf14_parse_hash;
9375 sort_by_digest = sort_by_digest_4_4;
9376 opti_type = OPTI_TYPE_ZERO_BYTE
9377 | OPTI_TYPE_NOT_ITERATED;
9378 dgst_pos0 = 0;
9379 dgst_pos1 = 1;
9380 dgst_pos2 = 2;
9381 dgst_pos3 = 3;
9382 break;
9383
9384 case 10600: hash_type = HASH_TYPE_SHA256;
9385 salt_type = SALT_TYPE_EMBEDDED;
9386 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9387 opts_type = OPTS_TYPE_PT_GENERATE_BE
9388 | OPTS_TYPE_ST_ADD80
9389 | OPTS_TYPE_ST_ADDBITS15
9390 | OPTS_TYPE_HASH_COPY;
9391 kern_type = KERN_TYPE_SHA256_PWSLT;
9392 dgst_size = DGST_SIZE_4_8;
9393 parse_func = pdf17l3_parse_hash;
9394 sort_by_digest = sort_by_digest_4_8;
9395 opti_type = OPTI_TYPE_ZERO_BYTE
9396 | OPTI_TYPE_PRECOMPUTE_INIT
9397 | OPTI_TYPE_PRECOMPUTE_MERKLE
9398 | OPTI_TYPE_EARLY_SKIP
9399 | OPTI_TYPE_NOT_ITERATED
9400 | OPTI_TYPE_APPENDED_SALT
9401 | OPTI_TYPE_RAW_HASH;
9402 dgst_pos0 = 3;
9403 dgst_pos1 = 7;
9404 dgst_pos2 = 2;
9405 dgst_pos3 = 6;
9406 break;
9407
9408 case 10700: hash_type = HASH_TYPE_PDFU32;
9409 salt_type = SALT_TYPE_EMBEDDED;
9410 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9411 opts_type = OPTS_TYPE_PT_GENERATE_LE
9412 | OPTS_TYPE_HASH_COPY;
9413 kern_type = KERN_TYPE_PDF17L8;
9414 dgst_size = DGST_SIZE_4_8;
9415 parse_func = pdf17l8_parse_hash;
9416 sort_by_digest = sort_by_digest_4_8;
9417 opti_type = OPTI_TYPE_ZERO_BYTE
9418 | OPTI_TYPE_NOT_ITERATED;
9419 dgst_pos0 = 0;
9420 dgst_pos1 = 1;
9421 dgst_pos2 = 2;
9422 dgst_pos3 = 3;
9423 break;
9424
9425 case 10800: hash_type = HASH_TYPE_SHA384;
9426 salt_type = SALT_TYPE_NONE;
9427 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9428 opts_type = OPTS_TYPE_PT_GENERATE_BE
9429 | OPTS_TYPE_PT_ADD80
9430 | OPTS_TYPE_PT_ADDBITS15;
9431 kern_type = KERN_TYPE_SHA384;
9432 dgst_size = DGST_SIZE_8_8;
9433 parse_func = sha384_parse_hash;
9434 sort_by_digest = sort_by_digest_8_8;
9435 opti_type = OPTI_TYPE_ZERO_BYTE
9436 | OPTI_TYPE_PRECOMPUTE_INIT
9437 | OPTI_TYPE_PRECOMPUTE_MERKLE
9438 | OPTI_TYPE_EARLY_SKIP
9439 | OPTI_TYPE_NOT_ITERATED
9440 | OPTI_TYPE_NOT_SALTED
9441 | OPTI_TYPE_RAW_HASH;
9442 dgst_pos0 = 6;
9443 dgst_pos1 = 7;
9444 dgst_pos2 = 4;
9445 dgst_pos3 = 5;
9446 break;
9447
9448 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9449 salt_type = SALT_TYPE_EMBEDDED;
9450 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9451 opts_type = OPTS_TYPE_PT_GENERATE_LE
9452 | OPTS_TYPE_ST_BASE64
9453 | OPTS_TYPE_HASH_COPY;
9454 kern_type = KERN_TYPE_PBKDF2_SHA256;
9455 dgst_size = DGST_SIZE_4_32;
9456 parse_func = pbkdf2_sha256_parse_hash;
9457 sort_by_digest = sort_by_digest_4_32;
9458 opti_type = OPTI_TYPE_ZERO_BYTE;
9459 dgst_pos0 = 0;
9460 dgst_pos1 = 1;
9461 dgst_pos2 = 2;
9462 dgst_pos3 = 3;
9463 break;
9464
9465 case 11000: hash_type = HASH_TYPE_MD5;
9466 salt_type = SALT_TYPE_INTERN;
9467 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9468 opts_type = OPTS_TYPE_PT_GENERATE_LE
9469 | OPTS_TYPE_PT_ADD80;
9470 kern_type = KERN_TYPE_PRESTASHOP;
9471 dgst_size = DGST_SIZE_4_4;
9472 parse_func = prestashop_parse_hash;
9473 sort_by_digest = sort_by_digest_4_4;
9474 opti_type = OPTI_TYPE_ZERO_BYTE
9475 | OPTI_TYPE_PRECOMPUTE_INIT
9476 | OPTI_TYPE_NOT_ITERATED
9477 | OPTI_TYPE_PREPENDED_SALT;
9478 dgst_pos0 = 0;
9479 dgst_pos1 = 3;
9480 dgst_pos2 = 2;
9481 dgst_pos3 = 1;
9482 break;
9483
9484 case 11100: hash_type = HASH_TYPE_MD5;
9485 salt_type = SALT_TYPE_EMBEDDED;
9486 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9487 opts_type = OPTS_TYPE_PT_GENERATE_LE
9488 | OPTS_TYPE_ST_ADD80;
9489 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9490 dgst_size = DGST_SIZE_4_4;
9491 parse_func = postgresql_auth_parse_hash;
9492 sort_by_digest = sort_by_digest_4_4;
9493 opti_type = OPTI_TYPE_ZERO_BYTE
9494 | OPTI_TYPE_PRECOMPUTE_INIT
9495 | OPTI_TYPE_PRECOMPUTE_MERKLE
9496 | OPTI_TYPE_EARLY_SKIP;
9497 dgst_pos0 = 0;
9498 dgst_pos1 = 3;
9499 dgst_pos2 = 2;
9500 dgst_pos3 = 1;
9501 break;
9502
9503 case 11200: hash_type = HASH_TYPE_SHA1;
9504 salt_type = SALT_TYPE_EMBEDDED;
9505 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9506 opts_type = OPTS_TYPE_PT_GENERATE_BE
9507 | OPTS_TYPE_PT_ADD80
9508 | OPTS_TYPE_ST_HEX;
9509 kern_type = KERN_TYPE_MYSQL_AUTH;
9510 dgst_size = DGST_SIZE_4_5;
9511 parse_func = mysql_auth_parse_hash;
9512 sort_by_digest = sort_by_digest_4_5;
9513 opti_type = OPTI_TYPE_ZERO_BYTE
9514 | OPTI_TYPE_EARLY_SKIP;
9515 dgst_pos0 = 3;
9516 dgst_pos1 = 4;
9517 dgst_pos2 = 2;
9518 dgst_pos3 = 1;
9519 break;
9520
9521 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9522 salt_type = SALT_TYPE_EMBEDDED;
9523 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9524 opts_type = OPTS_TYPE_PT_GENERATE_LE
9525 | OPTS_TYPE_ST_HEX
9526 | OPTS_TYPE_ST_ADD80;
9527 kern_type = KERN_TYPE_BITCOIN_WALLET;
9528 dgst_size = DGST_SIZE_4_4;
9529 parse_func = bitcoin_wallet_parse_hash;
9530 sort_by_digest = sort_by_digest_4_4;
9531 opti_type = OPTI_TYPE_ZERO_BYTE;
9532 dgst_pos0 = 0;
9533 dgst_pos1 = 1;
9534 dgst_pos2 = 2;
9535 dgst_pos3 = 3;
9536 break;
9537
9538 case 11400: hash_type = HASH_TYPE_MD5;
9539 salt_type = SALT_TYPE_EMBEDDED;
9540 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9541 opts_type = OPTS_TYPE_PT_GENERATE_LE
9542 | OPTS_TYPE_PT_ADD80
9543 | OPTS_TYPE_HASH_COPY;
9544 kern_type = KERN_TYPE_SIP_AUTH;
9545 dgst_size = DGST_SIZE_4_4;
9546 parse_func = sip_auth_parse_hash;
9547 sort_by_digest = sort_by_digest_4_4;
9548 opti_type = OPTI_TYPE_ZERO_BYTE;
9549 dgst_pos0 = 0;
9550 dgst_pos1 = 3;
9551 dgst_pos2 = 2;
9552 dgst_pos3 = 1;
9553 break;
9554
9555 case 11500: hash_type = HASH_TYPE_CRC32;
9556 salt_type = SALT_TYPE_INTERN;
9557 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9558 opts_type = OPTS_TYPE_PT_GENERATE_LE
9559 | OPTS_TYPE_ST_GENERATE_LE
9560 | OPTS_TYPE_ST_HEX;
9561 kern_type = KERN_TYPE_CRC32;
9562 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9563 parse_func = crc32_parse_hash;
9564 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9565 opti_type = OPTI_TYPE_ZERO_BYTE;
9566 dgst_pos0 = 0;
9567 dgst_pos1 = 1;
9568 dgst_pos2 = 2;
9569 dgst_pos3 = 3;
9570 break;
9571
9572 case 11600: hash_type = HASH_TYPE_AES;
9573 salt_type = SALT_TYPE_EMBEDDED;
9574 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9575 opts_type = OPTS_TYPE_PT_GENERATE_LE
9576 | OPTS_TYPE_PT_NEVERCRACK;
9577 kern_type = KERN_TYPE_SEVEN_ZIP;
9578 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9579 parse_func = seven_zip_parse_hash;
9580 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9581 opti_type = OPTI_TYPE_ZERO_BYTE;
9582 dgst_pos0 = 0;
9583 dgst_pos1 = 1;
9584 dgst_pos2 = 2;
9585 dgst_pos3 = 3;
9586 break;
9587
9588 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9589 salt_type = SALT_TYPE_NONE;
9590 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9591 opts_type = OPTS_TYPE_PT_GENERATE_LE
9592 | OPTS_TYPE_PT_ADD01;
9593 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9594 dgst_size = DGST_SIZE_4_8;
9595 parse_func = gost2012sbog_256_parse_hash;
9596 sort_by_digest = sort_by_digest_4_8;
9597 opti_type = OPTI_TYPE_ZERO_BYTE;
9598 dgst_pos0 = 0;
9599 dgst_pos1 = 1;
9600 dgst_pos2 = 2;
9601 dgst_pos3 = 3;
9602 break;
9603
9604 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9605 salt_type = SALT_TYPE_NONE;
9606 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9607 opts_type = OPTS_TYPE_PT_GENERATE_LE
9608 | OPTS_TYPE_PT_ADD01;
9609 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9610 dgst_size = DGST_SIZE_4_16;
9611 parse_func = gost2012sbog_512_parse_hash;
9612 sort_by_digest = sort_by_digest_4_16;
9613 opti_type = OPTI_TYPE_ZERO_BYTE;
9614 dgst_pos0 = 0;
9615 dgst_pos1 = 1;
9616 dgst_pos2 = 2;
9617 dgst_pos3 = 3;
9618 break;
9619
9620 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9621 salt_type = SALT_TYPE_EMBEDDED;
9622 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9623 opts_type = OPTS_TYPE_PT_GENERATE_LE
9624 | OPTS_TYPE_ST_BASE64
9625 | OPTS_TYPE_HASH_COPY;
9626 kern_type = KERN_TYPE_PBKDF2_MD5;
9627 dgst_size = DGST_SIZE_4_32;
9628 parse_func = pbkdf2_md5_parse_hash;
9629 sort_by_digest = sort_by_digest_4_32;
9630 opti_type = OPTI_TYPE_ZERO_BYTE;
9631 dgst_pos0 = 0;
9632 dgst_pos1 = 1;
9633 dgst_pos2 = 2;
9634 dgst_pos3 = 3;
9635 break;
9636
9637 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
9638 salt_type = SALT_TYPE_EMBEDDED;
9639 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9640 opts_type = OPTS_TYPE_PT_GENERATE_LE
9641 | OPTS_TYPE_ST_BASE64
9642 | OPTS_TYPE_HASH_COPY;
9643 kern_type = KERN_TYPE_PBKDF2_SHA1;
9644 dgst_size = DGST_SIZE_4_32;
9645 parse_func = pbkdf2_sha1_parse_hash;
9646 sort_by_digest = sort_by_digest_4_32;
9647 opti_type = OPTI_TYPE_ZERO_BYTE;
9648 dgst_pos0 = 0;
9649 dgst_pos1 = 1;
9650 dgst_pos2 = 2;
9651 dgst_pos3 = 3;
9652 break;
9653
9654 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
9655 salt_type = SALT_TYPE_EMBEDDED;
9656 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9657 opts_type = OPTS_TYPE_PT_GENERATE_LE
9658 | OPTS_TYPE_ST_BASE64
9659 | OPTS_TYPE_HASH_COPY;
9660 kern_type = KERN_TYPE_PBKDF2_SHA512;
9661 dgst_size = DGST_SIZE_8_16;
9662 parse_func = pbkdf2_sha512_parse_hash;
9663 sort_by_digest = sort_by_digest_8_16;
9664 opti_type = OPTI_TYPE_ZERO_BYTE;
9665 dgst_pos0 = 0;
9666 dgst_pos1 = 1;
9667 dgst_pos2 = 2;
9668 dgst_pos3 = 3;
9669 break;
9670
9671 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
9672 salt_type = SALT_TYPE_EMBEDDED;
9673 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9674 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9675 kern_type = KERN_TYPE_ECRYPTFS;
9676 dgst_size = DGST_SIZE_8_8;
9677 parse_func = ecryptfs_parse_hash;
9678 sort_by_digest = sort_by_digest_8_8;
9679 opti_type = OPTI_TYPE_ZERO_BYTE;
9680 dgst_pos0 = 0;
9681 dgst_pos1 = 1;
9682 dgst_pos2 = 2;
9683 dgst_pos3 = 3;
9684 break;
9685
9686 case 12300: hash_type = HASH_TYPE_ORACLET;
9687 salt_type = SALT_TYPE_EMBEDDED;
9688 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9689 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9690 kern_type = KERN_TYPE_ORACLET;
9691 dgst_size = DGST_SIZE_8_16;
9692 parse_func = oraclet_parse_hash;
9693 sort_by_digest = sort_by_digest_8_16;
9694 opti_type = OPTI_TYPE_ZERO_BYTE;
9695 dgst_pos0 = 0;
9696 dgst_pos1 = 1;
9697 dgst_pos2 = 2;
9698 dgst_pos3 = 3;
9699 break;
9700
9701 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
9702 salt_type = SALT_TYPE_EMBEDDED;
9703 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9704 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9705 kern_type = KERN_TYPE_BSDICRYPT;
9706 dgst_size = DGST_SIZE_4_4;
9707 parse_func = bsdicrypt_parse_hash;
9708 sort_by_digest = sort_by_digest_4_4;
9709 opti_type = OPTI_TYPE_ZERO_BYTE
9710 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9711 dgst_pos0 = 0;
9712 dgst_pos1 = 1;
9713 dgst_pos2 = 2;
9714 dgst_pos3 = 3;
9715 break;
9716
9717 case 12500: hash_type = HASH_TYPE_RAR3HP;
9718 salt_type = SALT_TYPE_EMBEDDED;
9719 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9720 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9721 kern_type = KERN_TYPE_RAR3;
9722 dgst_size = DGST_SIZE_4_4;
9723 parse_func = rar3hp_parse_hash;
9724 sort_by_digest = sort_by_digest_4_4;
9725 opti_type = OPTI_TYPE_ZERO_BYTE;
9726 dgst_pos0 = 0;
9727 dgst_pos1 = 1;
9728 dgst_pos2 = 2;
9729 dgst_pos3 = 3;
9730 break;
9731
9732 case 12600: hash_type = HASH_TYPE_SHA256;
9733 salt_type = SALT_TYPE_INTERN;
9734 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9735 opts_type = OPTS_TYPE_PT_GENERATE_BE
9736 | OPTS_TYPE_PT_ADD80;
9737 kern_type = KERN_TYPE_CF10;
9738 dgst_size = DGST_SIZE_4_8;
9739 parse_func = cf10_parse_hash;
9740 sort_by_digest = sort_by_digest_4_8;
9741 opti_type = OPTI_TYPE_ZERO_BYTE
9742 | OPTI_TYPE_PRECOMPUTE_INIT
9743 | OPTI_TYPE_EARLY_SKIP
9744 | OPTI_TYPE_NOT_ITERATED;
9745 dgst_pos0 = 3;
9746 dgst_pos1 = 7;
9747 dgst_pos2 = 2;
9748 dgst_pos3 = 6;
9749 break;
9750
9751 case 12700: hash_type = HASH_TYPE_AES;
9752 salt_type = SALT_TYPE_EMBEDDED;
9753 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9754 opts_type = OPTS_TYPE_PT_GENERATE_LE
9755 | OPTS_TYPE_HASH_COPY;
9756 kern_type = KERN_TYPE_MYWALLET;
9757 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9758 parse_func = mywallet_parse_hash;
9759 sort_by_digest = sort_by_digest_4_5;
9760 opti_type = OPTI_TYPE_ZERO_BYTE;
9761 dgst_pos0 = 0;
9762 dgst_pos1 = 1;
9763 dgst_pos2 = 2;
9764 dgst_pos3 = 3;
9765 break;
9766
9767 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
9768 salt_type = SALT_TYPE_EMBEDDED;
9769 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9770 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9771 kern_type = KERN_TYPE_MS_DRSR;
9772 dgst_size = DGST_SIZE_4_8;
9773 parse_func = ms_drsr_parse_hash;
9774 sort_by_digest = sort_by_digest_4_8;
9775 opti_type = OPTI_TYPE_ZERO_BYTE;
9776 dgst_pos0 = 0;
9777 dgst_pos1 = 1;
9778 dgst_pos2 = 2;
9779 dgst_pos3 = 3;
9780 break;
9781
9782 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9783 salt_type = SALT_TYPE_EMBEDDED;
9784 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9785 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9786 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
9787 dgst_size = DGST_SIZE_4_8;
9788 parse_func = androidfde_samsung_parse_hash;
9789 sort_by_digest = sort_by_digest_4_8;
9790 opti_type = OPTI_TYPE_ZERO_BYTE;
9791 dgst_pos0 = 0;
9792 dgst_pos1 = 1;
9793 dgst_pos2 = 2;
9794 dgst_pos3 = 3;
9795 break;
9796
9797 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
9798 salt_type = SALT_TYPE_EMBEDDED;
9799 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9800 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9801 kern_type = KERN_TYPE_RAR5;
9802 dgst_size = DGST_SIZE_4_4;
9803 parse_func = rar5_parse_hash;
9804 sort_by_digest = sort_by_digest_4_4;
9805 opti_type = OPTI_TYPE_ZERO_BYTE;
9806 dgst_pos0 = 0;
9807 dgst_pos1 = 1;
9808 dgst_pos2 = 2;
9809 dgst_pos3 = 3;
9810 break;
9811
9812 default: usage_mini_print (PROGNAME); return (-1);
9813 }
9814
9815 /**
9816 * transpose
9817 */
9818
9819 data.parse_func = parse_func;
9820
9821 /**
9822 * misc stuff
9823 */
9824
9825 if (hex_salt)
9826 {
9827 if (salt_type == SALT_TYPE_INTERN)
9828 {
9829 opts_type |= OPTS_TYPE_ST_HEX;
9830 }
9831 else
9832 {
9833 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
9834
9835 return (-1);
9836 }
9837 }
9838
9839 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
9840 | (salt_type == SALT_TYPE_EXTERN)
9841 | (salt_type == SALT_TYPE_EMBEDDED)
9842 | (salt_type == SALT_TYPE_VIRTUAL));
9843
9844 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
9845
9846 data.hash_type = hash_type;
9847 data.attack_mode = attack_mode;
9848 data.attack_kern = attack_kern;
9849 data.attack_exec = attack_exec;
9850 data.kern_type = kern_type;
9851 data.opts_type = opts_type;
9852 data.dgst_size = dgst_size;
9853 data.salt_type = salt_type;
9854 data.isSalted = isSalted;
9855 data.sort_by_digest = sort_by_digest;
9856 data.dgst_pos0 = dgst_pos0;
9857 data.dgst_pos1 = dgst_pos1;
9858 data.dgst_pos2 = dgst_pos2;
9859 data.dgst_pos3 = dgst_pos3;
9860
9861 esalt_size = 0;
9862
9863 switch (hash_mode)
9864 {
9865 case 2500: esalt_size = sizeof (wpa_t); break;
9866 case 5300: esalt_size = sizeof (ikepsk_t); break;
9867 case 5400: esalt_size = sizeof (ikepsk_t); break;
9868 case 5500: esalt_size = sizeof (netntlm_t); break;
9869 case 5600: esalt_size = sizeof (netntlm_t); break;
9870 case 6211:
9871 case 6212:
9872 case 6213:
9873 case 6221:
9874 case 6222:
9875 case 6223:
9876 case 6231:
9877 case 6232:
9878 case 6233:
9879 case 6241:
9880 case 6242:
9881 case 6243: esalt_size = sizeof (tc_t); break;
9882 case 6600: esalt_size = sizeof (agilekey_t); break;
9883 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
9884 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
9885 case 7300: esalt_size = sizeof (rakp_t); break;
9886 case 7500: esalt_size = sizeof (krb5pa_t); break;
9887 case 8200: esalt_size = sizeof (cloudkey_t); break;
9888 case 8800: esalt_size = sizeof (androidfde_t); break;
9889 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
9890 case 9400: esalt_size = sizeof (office2007_t); break;
9891 case 9500: esalt_size = sizeof (office2010_t); break;
9892 case 9600: esalt_size = sizeof (office2013_t); break;
9893 case 9700: esalt_size = sizeof (oldoffice01_t); break;
9894 case 9710: esalt_size = sizeof (oldoffice01_t); break;
9895 case 9720: esalt_size = sizeof (oldoffice01_t); break;
9896 case 9800: esalt_size = sizeof (oldoffice34_t); break;
9897 case 9810: esalt_size = sizeof (oldoffice34_t); break;
9898 case 9820: esalt_size = sizeof (oldoffice34_t); break;
9899 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
9900 case 10200: esalt_size = sizeof (cram_md5_t); break;
9901 case 10400: esalt_size = sizeof (pdf_t); break;
9902 case 10410: esalt_size = sizeof (pdf_t); break;
9903 case 10420: esalt_size = sizeof (pdf_t); break;
9904 case 10500: esalt_size = sizeof (pdf_t); break;
9905 case 10600: esalt_size = sizeof (pdf_t); break;
9906 case 10700: esalt_size = sizeof (pdf_t); break;
9907 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
9908 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
9909 case 11400: esalt_size = sizeof (sip_t); break;
9910 case 11600: esalt_size = sizeof (seven_zip_t); break;
9911 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
9912 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
9913 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
9914 }
9915
9916 data.esalt_size = esalt_size;
9917
9918 /**
9919 * choose dictionary parser
9920 */
9921
9922 if (hash_type == HASH_TYPE_LM)
9923 {
9924 get_next_word_func = get_next_word_lm;
9925 }
9926 else if (opts_type & OPTS_TYPE_PT_UPPER)
9927 {
9928 get_next_word_func = get_next_word_uc;
9929 }
9930 else
9931 {
9932 get_next_word_func = get_next_word_std;
9933 }
9934
9935 /**
9936 * dictstat
9937 */
9938
9939 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
9940
9941 #ifdef _POSIX
9942 size_t dictstat_nmemb = 0;
9943 #endif
9944
9945 #ifdef _WIN
9946 uint dictstat_nmemb = 0;
9947 #endif
9948
9949 char dictstat[256];
9950
9951 FILE *dictstat_fp = NULL;
9952
9953 if (keyspace == 0)
9954 {
9955 memset (dictstat, 0, sizeof (dictstat));
9956
9957 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
9958
9959 dictstat_fp = fopen (dictstat, "rb");
9960
9961 if (dictstat_fp)
9962 {
9963 #ifdef _POSIX
9964 struct stat tmpstat;
9965
9966 fstat (fileno (dictstat_fp), &tmpstat);
9967 #endif
9968
9969 #ifdef _WIN
9970 struct stat64 tmpstat;
9971
9972 _fstat64 (fileno (dictstat_fp), &tmpstat);
9973 #endif
9974
9975 if (tmpstat.st_mtime < COMPTIME)
9976 {
9977 /* with v0.15 the format changed so we have to ensure user is using a good version
9978 since there is no version-header in the dictstat file */
9979
9980 fclose (dictstat_fp);
9981
9982 unlink (dictstat);
9983 }
9984 else
9985 {
9986 while (!feof (dictstat_fp))
9987 {
9988 dictstat_t d;
9989
9990 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
9991
9992 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
9993
9994 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
9995 {
9996 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
9997
9998 return -1;
9999 }
10000 }
10001
10002 fclose (dictstat_fp);
10003 }
10004 }
10005 }
10006
10007 /**
10008 * potfile
10009 */
10010
10011 char potfile[256];
10012
10013 memset (potfile, 0, sizeof (potfile));
10014
10015 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
10016
10017 data.pot_fp = NULL;
10018
10019 FILE *out_fp = NULL;
10020 FILE *pot_fp = NULL;
10021
10022 if (show == 1 || left == 1)
10023 {
10024 pot_fp = fopen (potfile, "rb");
10025
10026 if (pot_fp == NULL)
10027 {
10028 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10029
10030 return (-1);
10031 }
10032
10033 if (outfile != NULL)
10034 {
10035 if ((out_fp = fopen (outfile, "ab")) == NULL)
10036 {
10037 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10038
10039 fclose (pot_fp);
10040
10041 return (-1);
10042 }
10043 }
10044 else
10045 {
10046 out_fp = stdout;
10047 }
10048 }
10049 else
10050 {
10051 if (potfile_disable == 0)
10052 {
10053 pot_fp = fopen (potfile, "ab");
10054
10055 if (pot_fp == NULL)
10056 {
10057 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10058
10059 return (-1);
10060 }
10061
10062 data.pot_fp = pot_fp;
10063 }
10064 }
10065
10066 pot_t *pot = NULL;
10067
10068 uint pot_cnt = 0;
10069 uint pot_avail = 0;
10070
10071 if (show == 1 || left == 1)
10072 {
10073 SUPPRESS_OUTPUT = 1;
10074
10075 pot_avail = count_lines (pot_fp);
10076
10077 rewind (pot_fp);
10078
10079 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10080
10081 uint pot_hashes_avail = 0;
10082
10083 uint line_num = 0;
10084
10085 while (!feof (pot_fp))
10086 {
10087 line_num++;
10088
10089 char line_buf[BUFSIZ];
10090
10091 int line_len = fgetl (pot_fp, line_buf);
10092
10093 if (line_len == 0) continue;
10094
10095 char *plain_buf = line_buf + line_len;
10096
10097 pot_t *pot_ptr = &pot[pot_cnt];
10098
10099 hash_t *hashes_buf = &pot_ptr->hash;
10100
10101 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10102 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10103
10104 if (pot_cnt == pot_hashes_avail)
10105 {
10106 uint pos = 0;
10107
10108 for (pos = 0; pos < INCR_POT; pos++)
10109 {
10110 if ((pot_cnt + pos) >= pot_avail) break;
10111
10112 pot_t *tmp_pot = &pot[pot_cnt + pos];
10113
10114 hash_t *tmp_hash = &tmp_pot->hash;
10115
10116 tmp_hash->digest = mymalloc (dgst_size);
10117
10118 if (isSalted)
10119 {
10120 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10121 }
10122
10123 if (esalt_size)
10124 {
10125 tmp_hash->esalt = mymalloc (esalt_size);
10126 }
10127
10128 pot_hashes_avail++;
10129 }
10130 }
10131
10132 int plain_len = 0;
10133
10134 int parser_status;
10135
10136 int iter = MAX_CUT_TRIES;
10137
10138 do
10139 {
10140 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10141 {
10142 if (line_buf[i] == ':')
10143 {
10144 line_len--;
10145
10146 break;
10147 }
10148 }
10149
10150 if (data.hash_mode != 2500)
10151 {
10152 parser_status = parse_func (line_buf, line_len, hashes_buf);
10153 }
10154 else
10155 {
10156 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10157
10158 if (line_len > max_salt_size)
10159 {
10160 parser_status = PARSER_GLOBAL_LENGTH;
10161 }
10162 else
10163 {
10164 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10165
10166 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10167
10168 hashes_buf->salt->salt_len = line_len;
10169
10170 parser_status = PARSER_OK;
10171 }
10172 }
10173
10174 // if NOT parsed without error, we add the ":" to the plain
10175
10176 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10177 {
10178 plain_len++;
10179 plain_buf--;
10180 }
10181
10182 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10183
10184 if (parser_status < PARSER_GLOBAL_ZERO)
10185 {
10186 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10187
10188 continue;
10189 }
10190
10191 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10192
10193 pot_ptr->plain_len = plain_len;
10194
10195 pot_cnt++;
10196 }
10197
10198 fclose (pot_fp);
10199
10200 SUPPRESS_OUTPUT = 0;
10201
10202 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10203 }
10204
10205 /**
10206 * kernel accel and loops auto adjustment
10207 */
10208
10209 if (kernel_accel_chgd == 0) kernel_accel = set_kernel_accel (hash_mode);
10210 if (kernel_loops_chgd == 0) kernel_loops = set_kernel_loops (hash_mode);
10211
10212 if (workload_profile == 1)
10213 {
10214 kernel_loops /= 8;
10215 kernel_accel /= 4;
10216
10217 if (kernel_loops == 0) kernel_loops = 8;
10218 if (kernel_accel == 0) kernel_accel = 2;
10219 }
10220 else if (workload_profile == 3)
10221 {
10222 kernel_loops *= 8;
10223 kernel_accel *= 4;
10224
10225 if (kernel_loops > 1024) kernel_loops = 1024;
10226 if (kernel_accel > 256) kernel_accel = 256; // causes memory problems otherwise
10227 }
10228
10229 // those hashes *must* run at a specific kernel_loops count because of some optimization inside the kernel
10230
10231 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
10232 {
10233 kernel_loops = 1024;
10234 }
10235
10236 if (hash_mode == 12500)
10237 {
10238 kernel_loops = ROUNDS_RAR3 / 16;
10239 }
10240
10241 data.kernel_accel = kernel_accel;
10242 data.kernel_loops = kernel_loops;
10243
10244 /**
10245 * word len
10246 */
10247
10248 uint pw_min = PW_MIN;
10249 uint pw_max = PW_MAX;
10250
10251 switch (hash_mode)
10252 {
10253 case 400: if (pw_max > 40) pw_max = 40;
10254 break;
10255 case 500: if (pw_max > 16) pw_max = 16;
10256 break;
10257 case 1500: if (pw_max > 8) pw_max = 8;
10258 break;
10259 case 1600: if (pw_max > 16) pw_max = 16;
10260 break;
10261 case 1800: if (pw_max > 16) pw_max = 16;
10262 break;
10263 case 2100: if (pw_max > 16) pw_max = 16;
10264 break;
10265 case 2500: if (pw_min < 8) pw_min = 8;
10266 break;
10267 case 3000: if (pw_max > 7) pw_max = 7;
10268 break;
10269 case 5200: if (pw_max > 24) pw_max = 24;
10270 break;
10271 case 5800: if (pw_max > 16) pw_max = 16;
10272 break;
10273 case 6300: if (pw_max > 16) pw_max = 16;
10274 break;
10275 case 7400: if (pw_max > 16) pw_max = 16;
10276 break;
10277 case 7900: if (pw_max > 48) pw_max = 48;
10278 break;
10279 case 8500: if (pw_max > 8) pw_max = 8;
10280 break;
10281 case 8600: if (pw_max > 16) pw_max = 16;
10282 break;
10283 case 9710: pw_min = 5;
10284 pw_max = 5;
10285 break;
10286 case 9810: pw_min = 5;
10287 pw_max = 5;
10288 break;
10289 case 10410: pw_min = 5;
10290 pw_max = 5;
10291 break;
10292 case 10300: if (pw_max < 3) pw_min = 3;
10293 if (pw_max > 40) pw_max = 40;
10294 break;
10295 case 10500: if (pw_max < 3) pw_min = 3;
10296 if (pw_max > 40) pw_max = 40;
10297 break;
10298 case 10700: if (pw_max > 16) pw_max = 16;
10299 break;
10300 case 11300: if (pw_max > 40) pw_max = 40;
10301 break;
10302 case 12500: if (pw_max > 20) pw_max = 20;
10303 break;
10304 case 12800: if (pw_max > 24) pw_max = 24;
10305 break;
10306 }
10307
10308 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10309 {
10310 switch (attack_kern)
10311 {
10312 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10313 break;
10314 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10315 break;
10316 }
10317 }
10318
10319 /**
10320 * charsets : keep them together for more easy maintainnce
10321 */
10322
10323 cs_t mp_sys[6];
10324 cs_t mp_usr[4];
10325
10326 memset (mp_sys, 0, sizeof (mp_sys));
10327 memset (mp_usr, 0, sizeof (mp_usr));
10328
10329 mp_setup_sys (mp_sys);
10330
10331 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10332 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10333 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10334 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10335
10336 /**
10337 * load hashes, part I: find input mode, count hashes
10338 */
10339
10340 uint hashlist_mode = 0;
10341 uint hashlist_format = HLFMT_HASHCAT;
10342
10343 uint hashes_avail = 0;
10344
10345 if (benchmark == 0)
10346 {
10347 struct stat f;
10348
10349 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10350
10351 if ((hash_mode == 2500) ||
10352 (hash_mode == 5200) ||
10353 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10354 (hash_mode == 9000))
10355 {
10356 hashlist_mode = HL_MODE_ARG;
10357
10358 char *hashfile = myargv[optind];
10359
10360 data.hashfile = hashfile;
10361
10362 logfile_top_var_string ("target", hashfile);
10363 }
10364
10365 if (hashlist_mode == HL_MODE_ARG)
10366 {
10367 if (hash_mode == 2500)
10368 {
10369 struct stat st;
10370
10371 if (stat (data.hashfile, &st) == -1)
10372 {
10373 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10374
10375 return (-1);
10376 }
10377
10378 hashes_avail = st.st_size / sizeof (hccap_t);
10379 }
10380 else
10381 {
10382 hashes_avail = 1;
10383 }
10384 }
10385 else if (hashlist_mode == HL_MODE_FILE)
10386 {
10387 char *hashfile = myargv[optind];
10388
10389 data.hashfile = hashfile;
10390
10391 logfile_top_var_string ("target", hashfile);
10392
10393 FILE *fp = NULL;
10394
10395 if ((fp = fopen (hashfile, "rb")) == NULL)
10396 {
10397 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10398
10399 return (-1);
10400 }
10401
10402 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10403
10404 hashes_avail = count_lines (fp);
10405
10406 rewind (fp);
10407
10408 if (hashes_avail == 0)
10409 {
10410 log_error ("ERROR: hashfile is empty or corrupt");
10411
10412 fclose (fp);
10413
10414 return (-1);
10415 }
10416
10417 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10418
10419 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10420 {
10421 log_error ("ERROR: remove not supported in native hashfile-format mode");
10422
10423 fclose (fp);
10424
10425 return (-1);
10426 }
10427
10428 fclose (fp);
10429 }
10430 }
10431 else
10432 {
10433 hashlist_mode = HL_MODE_ARG;
10434
10435 hashes_avail = 1;
10436 }
10437
10438 if (hash_mode == 3000) hashes_avail *= 2;
10439
10440 data.hashlist_mode = hashlist_mode;
10441 data.hashlist_format = hashlist_format;
10442
10443 logfile_top_uint (hashlist_mode);
10444 logfile_top_uint (hashlist_format);
10445
10446 /**
10447 * load hashes, part II: allocate required memory, set pointers
10448 */
10449
10450 hash_t *hashes_buf = NULL;
10451 void *digests_buf = NULL;
10452 salt_t *salts_buf = NULL;
10453 void *esalts_buf = NULL;
10454
10455 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10456
10457 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10458
10459 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10460 {
10461 uint32_t hash_pos;
10462
10463 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10464 {
10465 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10466
10467 hashes_buf[hash_pos].hash_info = hash_info;
10468
10469 if (username && (remove || show || left))
10470 {
10471 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10472 }
10473
10474 if (benchmark)
10475 {
10476 hash_info->orighash = (char *) mymalloc (256);
10477 }
10478 }
10479 }
10480
10481 if (isSalted)
10482 {
10483 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10484
10485 if (esalt_size)
10486 {
10487 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10488 }
10489 }
10490 else
10491 {
10492 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10493 }
10494
10495 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10496 {
10497 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10498
10499 if (isSalted)
10500 {
10501 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10502
10503 if (esalt_size)
10504 {
10505 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10506 }
10507 }
10508 else
10509 {
10510 hashes_buf[hash_pos].salt = &salts_buf[0];
10511 }
10512 }
10513
10514 /**
10515 * load hashes, part III: parse hashes or generate them if benchmark
10516 */
10517
10518 uint hashes_cnt = 0;
10519
10520 if (benchmark == 0)
10521 {
10522 if (keyspace == 1)
10523 {
10524 // useless to read hash file for keyspace, cheat a little bit w/ optind
10525 }
10526 else if (hashes_avail == 0)
10527 {
10528 }
10529 else if (hashlist_mode == HL_MODE_ARG)
10530 {
10531 char *input_buf = myargv[optind];
10532
10533 uint input_len = strlen (input_buf);
10534
10535 logfile_top_var_string ("target", input_buf);
10536
10537 char *hash_buf = NULL;
10538 int hash_len = 0;
10539
10540 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10541
10542 if (hash_len)
10543 {
10544 if (opts_type & OPTS_TYPE_HASH_COPY)
10545 {
10546 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10547
10548 hash_info_tmp->orighash = mystrdup (hash_buf);
10549 }
10550
10551 if (isSalted)
10552 {
10553 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10554 }
10555
10556 int parser_status = PARSER_OK;
10557
10558 if (hash_mode == 2500)
10559 {
10560 if (hash_len == 0)
10561 {
10562 log_error ("ERROR: hccap file not specified");
10563
10564 return (-1);
10565 }
10566
10567 hashlist_mode = HL_MODE_FILE;
10568
10569 data.hashlist_mode = hashlist_mode;
10570
10571 FILE *fp = fopen (hash_buf, "rb");
10572
10573 if (fp == NULL)
10574 {
10575 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10576
10577 return (-1);
10578 }
10579
10580 if (hashes_avail < 1)
10581 {
10582 log_error ("ERROR: hccap file is empty or corrupt");
10583
10584 fclose (fp);
10585
10586 return (-1);
10587 }
10588
10589 uint hccap_size = sizeof (hccap_t);
10590
10591 char in[hccap_size];
10592
10593 while (!feof (fp))
10594 {
10595 int n = fread (&in, hccap_size, 1, fp);
10596
10597 if (n != 1)
10598 {
10599 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
10600
10601 break;
10602 }
10603
10604 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
10605
10606 if (parser_status != PARSER_OK)
10607 {
10608 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
10609
10610 continue;
10611 }
10612
10613 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
10614
10615 if ((show == 1) || (left == 1))
10616 {
10617 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
10618
10619 char *salt_ptr = (char *) tmp_salt->salt_buf;
10620
10621 int cur_pos = tmp_salt->salt_len;
10622 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10623
10624 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
10625
10626 unsigned char *pke_ptr = (unsigned char *) wpa->pke;
10627
10628 // do the appending task
10629
10630 snprintf (salt_ptr + cur_pos,
10631 rem_len,
10632 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
10633 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
10634 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
10635
10636
10637 // memset () the remaining part of the salt
10638
10639 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
10640 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10641
10642 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
10643
10644 tmp_salt->salt_len += 1 + 12 + 1 + 12;
10645 }
10646
10647 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);
10648 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);
10649
10650 hashes_cnt++;
10651 }
10652
10653 fclose (fp);
10654 }
10655 else if (hash_mode == 3000)
10656 {
10657 if (hash_len == 32)
10658 {
10659 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10660
10661 hash_t *lm_hash_left = NULL;
10662
10663 if (parser_status == PARSER_OK)
10664 {
10665 lm_hash_left = &hashes_buf[hashes_cnt];
10666
10667 hashes_cnt++;
10668 }
10669 else
10670 {
10671 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10672 }
10673
10674
10675 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10676
10677 hash_t *lm_hash_right = NULL;
10678
10679 if (parser_status == PARSER_OK)
10680 {
10681 lm_hash_right = &hashes_buf[hashes_cnt];
10682
10683 hashes_cnt++;
10684 }
10685 else
10686 {
10687 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10688 }
10689
10690 // show / left
10691
10692 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
10693 {
10694 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);
10695 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);
10696 }
10697 }
10698 else
10699 {
10700 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10701
10702 if (parser_status == PARSER_OK)
10703 {
10704 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10705 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10706 }
10707
10708 if (parser_status == PARSER_OK)
10709 {
10710 hashes_cnt++;
10711 }
10712 else
10713 {
10714 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10715 }
10716 }
10717 }
10718 else
10719 {
10720 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10721
10722 if (parser_status == PARSER_OK)
10723 {
10724 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10725 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10726 }
10727
10728 if (parser_status == PARSER_OK)
10729 {
10730 hashes_cnt++;
10731 }
10732 else
10733 {
10734 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10735 }
10736 }
10737 }
10738 }
10739 else if (hashlist_mode == HL_MODE_FILE)
10740 {
10741 char *hashfile = data.hashfile;
10742
10743 FILE *fp;
10744
10745 if ((fp = fopen (hashfile, "rb")) == NULL)
10746 {
10747 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10748
10749 return (-1);
10750 }
10751
10752 uint line_num = 0;
10753
10754 while (!feof (fp))
10755 {
10756 line_num++;
10757
10758 char line_buf[BUFSIZ];
10759
10760 int line_len = fgetl (fp, line_buf);
10761
10762 if (line_len == 0) continue;
10763
10764 char *hash_buf = NULL;
10765 int hash_len = 0;
10766
10767 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
10768
10769 if (username)
10770 {
10771 char *user_buf = NULL;
10772 int user_len = 0;
10773
10774 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
10775
10776 if (remove || show)
10777 {
10778 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
10779
10780 *user = (user_t *) malloc (sizeof (user_t));
10781
10782 user_t *user_ptr = *user;
10783
10784 if (user_buf != NULL)
10785 {
10786 user_ptr->user_name = mystrdup (user_buf);
10787 }
10788 else
10789 {
10790 user_ptr->user_name = mystrdup ("");
10791 }
10792
10793 user_ptr->user_len = user_len;
10794 }
10795 }
10796
10797 if (opts_type & OPTS_TYPE_HASH_COPY)
10798 {
10799 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10800
10801 hash_info_tmp->orighash = mystrdup (hash_buf);
10802 }
10803
10804 if (isSalted)
10805 {
10806 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
10807 }
10808
10809 if (hash_mode == 3000)
10810 {
10811 if (hash_len == 32)
10812 {
10813 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10814
10815 if (parser_status < PARSER_GLOBAL_ZERO)
10816 {
10817 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10818
10819 continue;
10820 }
10821
10822 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
10823
10824 hashes_cnt++;
10825
10826 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10827
10828 if (parser_status < PARSER_GLOBAL_ZERO)
10829 {
10830 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10831
10832 continue;
10833 }
10834
10835 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
10836
10837 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);
10838
10839 hashes_cnt++;
10840
10841 // show / left
10842
10843 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);
10844 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);
10845 }
10846 else
10847 {
10848 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10849
10850 if (parser_status < PARSER_GLOBAL_ZERO)
10851 {
10852 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10853
10854 continue;
10855 }
10856
10857 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);
10858
10859 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10860 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10861
10862 hashes_cnt++;
10863 }
10864 }
10865 else
10866 {
10867 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10868
10869 if (parser_status < PARSER_GLOBAL_ZERO)
10870 {
10871 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10872
10873 continue;
10874 }
10875
10876 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);
10877
10878 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10879 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10880
10881 hashes_cnt++;
10882 }
10883 }
10884
10885 fclose (fp);
10886
10887 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
10888
10889 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
10890 }
10891 }
10892 else
10893 {
10894 if (isSalted)
10895 {
10896 hashes_buf[0].salt->salt_len = 8;
10897
10898 // special salt handling
10899
10900 switch (hash_mode)
10901 {
10902 case 1500: hashes_buf[0].salt->salt_len = 2;
10903 break;
10904 case 1731: hashes_buf[0].salt->salt_len = 4;
10905 break;
10906 case 2410: hashes_buf[0].salt->salt_len = 4;
10907 break;
10908 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
10909 break;
10910 case 3100: hashes_buf[0].salt->salt_len = 1;
10911 break;
10912 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
10913 break;
10914 case 5800: hashes_buf[0].salt->salt_len = 16;
10915 break;
10916 case 6800: hashes_buf[0].salt->salt_len = 32;
10917 break;
10918 case 8400: hashes_buf[0].salt->salt_len = 40;
10919 break;
10920 case 8800: hashes_buf[0].salt->salt_len = 16;
10921 break;
10922 case 8900: hashes_buf[0].salt->salt_len = 16;
10923 hashes_buf[0].salt->scrypt_N = 1024;
10924 hashes_buf[0].salt->scrypt_r = 1;
10925 hashes_buf[0].salt->scrypt_p = 1;
10926 break;
10927 case 9100: hashes_buf[0].salt->salt_len = 16;
10928 break;
10929 case 9300: hashes_buf[0].salt->salt_len = 14;
10930 hashes_buf[0].salt->scrypt_N = 16384;
10931 hashes_buf[0].salt->scrypt_r = 1;
10932 hashes_buf[0].salt->scrypt_p = 1;
10933 break;
10934 case 9400: hashes_buf[0].salt->salt_len = 16;
10935 break;
10936 case 9500: hashes_buf[0].salt->salt_len = 16;
10937 break;
10938 case 9600: hashes_buf[0].salt->salt_len = 16;
10939 break;
10940 case 9700: hashes_buf[0].salt->salt_len = 16;
10941 break;
10942 case 9710: hashes_buf[0].salt->salt_len = 16;
10943 break;
10944 case 9720: hashes_buf[0].salt->salt_len = 16;
10945 break;
10946 case 9800: hashes_buf[0].salt->salt_len = 16;
10947 break;
10948 case 9810: hashes_buf[0].salt->salt_len = 16;
10949 break;
10950 case 9820: hashes_buf[0].salt->salt_len = 16;
10951 break;
10952 case 10300: hashes_buf[0].salt->salt_len = 12;
10953 break;
10954 case 11500: hashes_buf[0].salt->salt_len = 4;
10955 break;
10956 case 11600: hashes_buf[0].salt->salt_len = 4;
10957 break;
10958 case 12400: hashes_buf[0].salt->salt_len = 4;
10959 break;
10960 case 12500: hashes_buf[0].salt->salt_len = 8;
10961 break;
10962 case 12600: hashes_buf[0].salt->salt_len = 64;
10963 break;
10964 }
10965
10966 // special esalt handling
10967
10968 switch (hash_mode)
10969 {
10970 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
10971 break;
10972 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
10973 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
10974 break;
10975 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
10976 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
10977 break;
10978 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
10979 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
10980 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
10981 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
10982 break;
10983 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
10984 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
10985 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
10986 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
10987 break;
10988 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
10989 break;
10990 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10991 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
10992 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
10993 break;
10994 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10995 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
10996 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
10997 break;
10998 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10999 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11000 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11001 break;
11002 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11003 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11004 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11005 break;
11006 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11007 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11008 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11009 break;
11010 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11011 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11012 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11013 break;
11014 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11015 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11016 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11017 break;
11018 }
11019 }
11020
11021 // set hashfile
11022
11023 switch (hash_mode)
11024 {
11025 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11026 break;
11027 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11028 break;
11029 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11030 break;
11031 case 6211:
11032 case 6212:
11033 case 6213:
11034 case 6221:
11035 case 6222:
11036 case 6223:
11037 case 6231:
11038 case 6232:
11039 case 6233:
11040 case 6241:
11041 case 6242:
11042 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11043 break;
11044 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11045 break;
11046 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11047 break;
11048 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11049 break;
11050 }
11051
11052 // set default iterations
11053
11054 switch (hash_mode)
11055 {
11056 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11057 break;
11058 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11059 break;
11060 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11061 break;
11062 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11063 break;
11064 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11065 break;
11066 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11067 break;
11068 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11069 break;
11070 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11071 break;
11072 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11073 break;
11074 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11075 break;
11076 case 6211:
11077 case 6212:
11078 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11079 break;
11080 case 6221:
11081 case 6222:
11082 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11083 break;
11084 case 6231:
11085 case 6232:
11086 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11087 break;
11088 case 6241:
11089 case 6242:
11090 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11091 break;
11092 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11093 break;
11094 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11095 break;
11096 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11097 break;
11098 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11099 break;
11100 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11101 break;
11102 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11103 break;
11104 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11105 break;
11106 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11107 break;
11108 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11109 break;
11110 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11111 break;
11112 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11113 break;
11114 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11115 break;
11116 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11117 break;
11118 case 8900: hashes_buf[0].salt->salt_iter = 1;
11119 break;
11120 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11121 break;
11122 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11123 break;
11124 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11125 break;
11126 case 9300: hashes_buf[0].salt->salt_iter = 1;
11127 break;
11128 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11129 break;
11130 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11131 break;
11132 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11133 break;
11134 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11135 break;
11136 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11137 break;
11138 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11139 break;
11140 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11141 break;
11142 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11143 break;
11144 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11145 break;
11146 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11147 break;
11148 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11149 break;
11150 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11151 break;
11152 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11153 break;
11154 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11155 break;
11156 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11157 break;
11158 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11159 break;
11160 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11161 break;
11162 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11163 break;
11164 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11165 break;
11166 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11167 break;
11168 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11169 break;
11170 }
11171
11172 // set special tuning for benchmark-mode 1
11173
11174 if (benchmark_mode == 1)
11175 {
11176 kernel_loops *= 8;
11177 kernel_accel *= 4;
11178
11179 switch (hash_mode)
11180 {
11181 case 400: kernel_loops = ROUNDS_PHPASS;
11182 kernel_accel = 32;
11183 break;
11184 case 500: kernel_loops = ROUNDS_MD5CRYPT;
11185 kernel_accel = 32;
11186 break;
11187 case 501: kernel_loops = ROUNDS_MD5CRYPT;
11188 kernel_accel = 32;
11189 break;
11190 case 1600: kernel_loops = ROUNDS_MD5CRYPT;
11191 kernel_accel = 32;
11192 break;
11193 case 1800: kernel_loops = ROUNDS_SHA512CRYPT;
11194 kernel_accel = 16;
11195 break;
11196 case 2100: kernel_loops = ROUNDS_DCC2;
11197 kernel_accel = 16;
11198 break;
11199 case 2500: kernel_loops = ROUNDS_WPA2;
11200 kernel_accel = 32;
11201 break;
11202 case 3200: kernel_loops = ROUNDS_BCRYPT;
11203 kernel_accel = 8;
11204 break;
11205 case 5200: kernel_loops = ROUNDS_PSAFE3;
11206 kernel_accel = 16;
11207 break;
11208 case 5800: kernel_loops = ROUNDS_ANDROIDPIN;
11209 kernel_accel = 16;
11210 break;
11211 case 6211: kernel_loops = ROUNDS_TRUECRYPT_2K;
11212 kernel_accel = 64;
11213 break;
11214 case 6212: kernel_loops = ROUNDS_TRUECRYPT_2K;
11215 kernel_accel = 32;
11216 break;
11217 case 6213: kernel_loops = ROUNDS_TRUECRYPT_2K;
11218 kernel_accel = 32;
11219 break;
11220 case 6221: kernel_loops = ROUNDS_TRUECRYPT_1K;
11221 kernel_accel = 8;
11222 break;
11223 case 6222: kernel_loops = ROUNDS_TRUECRYPT_1K;
11224 kernel_accel = 8;
11225 break;
11226 case 6223: kernel_loops = ROUNDS_TRUECRYPT_1K;
11227 kernel_accel = 8;
11228 break;
11229 case 6231: kernel_loops = ROUNDS_TRUECRYPT_1K;
11230 kernel_accel = 8;
11231 break;
11232 case 6232: kernel_loops = ROUNDS_TRUECRYPT_1K;
11233 kernel_accel = 8;
11234 break;
11235 case 6233: kernel_loops = ROUNDS_TRUECRYPT_1K;
11236 kernel_accel = 8;
11237 break;
11238 case 6241: kernel_loops = ROUNDS_TRUECRYPT_1K;
11239 kernel_accel = 128;
11240 break;
11241 case 6242: kernel_loops = ROUNDS_TRUECRYPT_1K;
11242 kernel_accel = 64;
11243 break;
11244 case 6243: kernel_loops = ROUNDS_TRUECRYPT_1K;
11245 kernel_accel = 64;
11246 break;
11247 case 6300: kernel_loops = ROUNDS_MD5CRYPT;
11248 kernel_accel = 32;
11249 break;
11250 case 6700: kernel_loops = ROUNDS_SHA1AIX;
11251 kernel_accel = 128;
11252 break;
11253 case 6400: kernel_loops = ROUNDS_SHA256AIX;
11254 kernel_accel = 128;
11255 break;
11256 case 6500: kernel_loops = ROUNDS_SHA512AIX;
11257 kernel_accel = 32;
11258 break;
11259 case 6600: kernel_loops = ROUNDS_AGILEKEY;
11260 kernel_accel = 64;
11261 break;
11262 case 6800: kernel_loops = ROUNDS_LASTPASS;
11263 kernel_accel = 64;
11264 break;
11265 case 7100: kernel_loops = ROUNDS_SHA512OSX;
11266 kernel_accel = 8;
11267 break;
11268 case 7200: kernel_loops = ROUNDS_GRUB;
11269 kernel_accel = 16;
11270 break;
11271 case 7400: kernel_loops = ROUNDS_SHA256CRYPT;
11272 kernel_accel = 8;
11273 break;
11274 case 7900: kernel_loops = ROUNDS_DRUPAL7;
11275 kernel_accel = 8;
11276 break;
11277 case 8200: kernel_loops = ROUNDS_CLOUDKEY;
11278 kernel_accel = 8;
11279 break;
11280 case 8800: kernel_loops = ROUNDS_ANDROIDFDE;
11281 kernel_accel = 32;
11282 break;
11283 case 8900: kernel_loops = 1;
11284 kernel_accel = 64;
11285 break;
11286 case 9000: kernel_loops = ROUNDS_PSAFE2;
11287 kernel_accel = 16;
11288 break;
11289 case 9100: kernel_loops = ROUNDS_LOTUS8;
11290 kernel_accel = 64;
11291 break;
11292 case 9200: kernel_loops = ROUNDS_CISCO8;
11293 kernel_accel = 8;
11294 break;
11295 case 9300: kernel_loops = 1;
11296 kernel_accel = 4;
11297 break;
11298 case 9400: kernel_loops = ROUNDS_OFFICE2007;
11299 kernel_accel = 32;
11300 break;
11301 case 9500: kernel_loops = ROUNDS_OFFICE2010;
11302 kernel_accel = 32;
11303 break;
11304 case 9600: kernel_loops = ROUNDS_OFFICE2013;
11305 kernel_accel = 8;
11306 break;
11307 case 10000: kernel_loops = ROUNDS_DJANGOPBKDF2;
11308 kernel_accel = 8;
11309 break;
11310 case 10300: kernel_loops = ROUNDS_SAPH_SHA1;
11311 kernel_accel = 16;
11312 break;
11313 case 10500: kernel_loops = ROUNDS_PDF14;
11314 kernel_accel = 256;
11315 break;
11316 case 10700: kernel_loops = ROUNDS_PDF17L8;
11317 kernel_accel = 8;
11318 break;
11319 case 10900: kernel_loops = ROUNDS_PBKDF2_SHA256;
11320 kernel_accel = 8;
11321 break;
11322 case 11300: kernel_loops = ROUNDS_BITCOIN_WALLET;
11323 kernel_accel = 8;
11324 break;
11325 case 11600: kernel_loops = ROUNDS_SEVEN_ZIP;
11326 kernel_accel = 8;
11327 break;
11328 case 11900: kernel_loops = ROUNDS_PBKDF2_MD5;
11329 kernel_accel = 8;
11330 break;
11331 case 12000: kernel_loops = ROUNDS_PBKDF2_SHA1;
11332 kernel_accel = 8;
11333 break;
11334 case 12100: kernel_loops = ROUNDS_PBKDF2_SHA512;
11335 kernel_accel = 8;
11336 break;
11337 case 12200: kernel_loops = ROUNDS_ECRYPTFS;
11338 kernel_accel = 8;
11339 break;
11340 case 12300: kernel_loops = ROUNDS_ORACLET;
11341 kernel_accel = 8;
11342 break;
11343 case 12500: kernel_loops = ROUNDS_RAR3;
11344 kernel_accel = 32;
11345 break;
11346 case 12700: kernel_loops = ROUNDS_MYWALLET;
11347 kernel_accel = 512;
11348 break;
11349 case 12800: kernel_loops = ROUNDS_MS_DRSR;
11350 kernel_accel = 512;
11351 break;
11352 case 12900: kernel_loops = ROUNDS_ANDROIDFDE_SAMSUNG;
11353 kernel_accel = 8;
11354 break;
11355 case 13000: kernel_loops = ROUNDS_RAR5;
11356 kernel_accel = 8;
11357 break;
11358 }
11359
11360 // some algorithm collide too fast, make that impossible
11361
11362 switch (hash_mode)
11363 {
11364 case 11500: ((uint *) digests_buf)[1] = 1;
11365 break;
11366 }
11367
11368 if (kernel_loops > 1024) kernel_loops = 1024;
11369 if (kernel_accel > 256) kernel_accel = 256; // causes memory problems otherwise
11370 }
11371
11372 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
11373 {
11374 kernel_loops = 1024;
11375 }
11376
11377 if (hash_mode == 12500)
11378 {
11379 kernel_loops = ROUNDS_RAR3 / 16;
11380 }
11381
11382 data.kernel_accel = kernel_accel;
11383 data.kernel_loops = kernel_loops;
11384
11385 hashes_cnt = 1;
11386 }
11387
11388 if (show == 1 || left == 1)
11389 {
11390 for (uint i = 0; i < pot_cnt; i++)
11391 {
11392 pot_t *pot_ptr = &pot[i];
11393
11394 hash_t *hashes_buf = &pot_ptr->hash;
11395
11396 local_free (hashes_buf->digest);
11397
11398 if (isSalted)
11399 {
11400 local_free (hashes_buf->salt);
11401 }
11402 }
11403
11404 local_free (pot);
11405
11406 if (data.quiet == 0) log_info_nn ("");
11407
11408 return (0);
11409 }
11410
11411 if (keyspace == 0)
11412 {
11413 if (hashes_cnt == 0)
11414 {
11415 log_error ("ERROR: No hashes loaded");
11416
11417 return (-1);
11418 }
11419 }
11420
11421 /**
11422 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11423 */
11424
11425 if (data.outfile != NULL)
11426 {
11427 if (data.hashfile != NULL)
11428 {
11429 #ifdef _POSIX
11430 struct stat tmpstat_outfile;
11431 struct stat tmpstat_hashfile;
11432 #endif
11433
11434 #ifdef _WIN
11435 struct stat64 tmpstat_outfile;
11436 struct stat64 tmpstat_hashfile;
11437 #endif
11438
11439 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11440
11441 if (tmp_outfile_fp)
11442 {
11443 #ifdef _POSIX
11444 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11445 #endif
11446
11447 #ifdef _WIN
11448 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11449 #endif
11450
11451 fclose (tmp_outfile_fp);
11452 }
11453
11454 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11455
11456 if (tmp_hashfile_fp)
11457 {
11458 #ifdef _POSIX
11459 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11460 #endif
11461
11462 #ifdef _WIN
11463 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11464 #endif
11465
11466 fclose (tmp_hashfile_fp);
11467 }
11468
11469 if (tmp_outfile_fp && tmp_outfile_fp)
11470 {
11471 tmpstat_outfile.st_mode = 0;
11472 tmpstat_outfile.st_nlink = 0;
11473 tmpstat_outfile.st_uid = 0;
11474 tmpstat_outfile.st_gid = 0;
11475 tmpstat_outfile.st_rdev = 0;
11476 tmpstat_outfile.st_atime = 0;
11477
11478 tmpstat_hashfile.st_mode = 0;
11479 tmpstat_hashfile.st_nlink = 0;
11480 tmpstat_hashfile.st_uid = 0;
11481 tmpstat_hashfile.st_gid = 0;
11482 tmpstat_hashfile.st_rdev = 0;
11483 tmpstat_hashfile.st_atime = 0;
11484
11485 #ifdef _POSIX
11486 tmpstat_outfile.st_blksize = 0;
11487 tmpstat_outfile.st_blocks = 0;
11488
11489 tmpstat_hashfile.st_blksize = 0;
11490 tmpstat_hashfile.st_blocks = 0;
11491 #endif
11492
11493 #ifdef _POSIX
11494 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11495 {
11496 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11497
11498 return (-1);
11499 }
11500 #endif
11501
11502 #ifdef _WIN
11503 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11504 {
11505 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11506
11507 return (-1);
11508 }
11509 #endif
11510 }
11511 }
11512 }
11513
11514 /**
11515 * Remove duplicates
11516 */
11517
11518 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11519
11520 if (isSalted)
11521 {
11522 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11523 }
11524 else
11525 {
11526 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11527 }
11528
11529 uint hashes_cnt_orig = hashes_cnt;
11530
11531 hashes_cnt = 1;
11532
11533 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11534 {
11535 if (isSalted)
11536 {
11537 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11538 {
11539 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11540 }
11541 }
11542 else
11543 {
11544 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11545 }
11546
11547 if (hashes_pos > hashes_cnt)
11548 {
11549 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11550 }
11551
11552 hashes_cnt++;
11553 }
11554
11555 /**
11556 * Potfile removes
11557 */
11558
11559 uint potfile_remove_cracks = 0;
11560
11561 if (potfile_disable == 0)
11562 {
11563 hash_t hash_buf;
11564
11565 hash_buf.digest = mymalloc (dgst_size);
11566 hash_buf.salt = NULL;
11567 hash_buf.esalt = NULL;
11568 hash_buf.hash_info = NULL;
11569 hash_buf.cracked = 0;
11570
11571 if (isSalted)
11572 {
11573 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11574 }
11575
11576 if (esalt_size)
11577 {
11578 hash_buf.esalt = mymalloc (esalt_size);
11579 }
11580
11581 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11582
11583 // no solution for these special hash types (for instane because they use hashfile in output etc)
11584 if ((hash_mode != 5200) &&
11585 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11586 (hash_mode != 9000))
11587 {
11588 FILE *fp = fopen (potfile, "rb");
11589
11590 if (fp != NULL)
11591 {
11592 while (!feof (fp))
11593 {
11594 char line_buf[BUFSIZ];
11595
11596 memset (line_buf, 0, BUFSIZ);
11597
11598 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11599
11600 if (ptr == NULL) break;
11601
11602 int line_len = strlen (line_buf);
11603
11604 if (line_len == 0) continue;
11605
11606 int iter = MAX_CUT_TRIES;
11607
11608 for (int i = line_len - 1; i && iter; i--, line_len--)
11609 {
11610 if (line_buf[i] != ':') continue;
11611
11612 if (isSalted)
11613 {
11614 memset (hash_buf.salt, 0, sizeof (salt_t));
11615 }
11616
11617 hash_t *found = NULL;
11618
11619 if (hash_mode == 6800)
11620 {
11621 if (i < 48) // 48 = 12 * uint in salt_buf[]
11622 {
11623 // manipulate salt_buf
11624 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11625
11626 hash_buf.salt->salt_len = i;
11627
11628 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11629 }
11630 }
11631 else if (hash_mode == 2500)
11632 {
11633 if (i < 48) // 48 = 12 * uint in salt_buf[]
11634 {
11635 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11636 // manipulate salt_buf
11637
11638 // to be safe work with a copy (because of line_len loop, i etc)
11639
11640 char line_buf_cpy[BUFSIZ];
11641 memset (line_buf_cpy, 0, BUFSIZ);
11642
11643 memset (line_buf_cpy, 0, sizeof (line_buf_cpy));
11644
11645 memcpy (line_buf_cpy, line_buf, i);
11646
11647 char *mac2_pos = strrchr (line_buf_cpy, ':');
11648
11649 if (mac2_pos == NULL) continue;
11650
11651 mac2_pos[0] = 0;
11652 mac2_pos++;
11653
11654 if (strlen (mac2_pos) != 12) continue;
11655
11656 char *mac1_pos = strrchr (line_buf_cpy, ':');
11657
11658 if (mac1_pos == NULL) continue;
11659
11660 mac1_pos[0] = 0;
11661 mac1_pos++;
11662
11663 if (strlen (mac1_pos) != 12) continue;
11664
11665 uint essid_length = mac1_pos - line_buf_cpy - 1;
11666
11667 // here we need the ESSID
11668 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11669
11670 hash_buf.salt->salt_len = essid_length;
11671
11672 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11673
11674 if (found)
11675 {
11676 wpa_t *wpa = (wpa_t *) found->esalt;
11677
11678 uint pke[25];
11679
11680 char *pke_ptr = (char *) pke;
11681
11682 for (uint i = 0; i < 25; i++)
11683 {
11684 pke[i] = byte_swap_32 (wpa->pke[i]);
11685 }
11686
11687 unsigned char mac1[6];
11688 unsigned char mac2[6];
11689
11690 memcpy (mac1, pke_ptr + 23, 6);
11691 memcpy (mac2, pke_ptr + 29, 6);
11692
11693 // compare hex string(s) vs binary MAC address(es)
11694
11695 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11696 {
11697 if (mac1[i] != (unsigned char) hex_to_char (&mac1_pos[j]))
11698 {
11699 found = NULL;
11700 break;
11701 }
11702 }
11703
11704 // early skip ;)
11705 if (!found) continue;
11706
11707 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11708 {
11709 if (mac2[i] != (unsigned char) hex_to_char (&mac2_pos[j]))
11710 {
11711 found = NULL;
11712 break;
11713 }
11714 }
11715 }
11716 }
11717 }
11718 else
11719 {
11720 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11721
11722 if (parser_status == PARSER_OK)
11723 {
11724 if (isSalted)
11725 {
11726 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11727 }
11728 else
11729 {
11730 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11731 }
11732 }
11733 }
11734
11735 if (found == NULL) continue;
11736
11737 if (!found->cracked) potfile_remove_cracks++;
11738
11739 found->cracked = 1;
11740
11741 if (found) break;
11742
11743 iter--;
11744 }
11745 }
11746
11747 fclose (fp);
11748 }
11749 }
11750
11751 if (esalt_size)
11752 {
11753 local_free (hash_buf.esalt);
11754 }
11755
11756 if (isSalted)
11757 {
11758 local_free (hash_buf.salt);
11759 }
11760
11761 local_free (hash_buf.digest);
11762 }
11763
11764 /**
11765 * Now generate all the buffers required for later
11766 */
11767
11768 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11769
11770 salt_t *salts_buf_new = NULL;
11771 void *esalts_buf_new = NULL;
11772
11773 if (isSalted)
11774 {
11775 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11776
11777 if (esalt_size)
11778 {
11779 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
11780 }
11781 }
11782 else
11783 {
11784 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
11785 }
11786
11787 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
11788
11789 uint digests_cnt = hashes_cnt;
11790 uint digests_done = 0;
11791
11792 uint size_digests = digests_cnt * dgst_size;
11793 uint size_shown = digests_cnt * sizeof (uint);
11794
11795 uint *digests_shown = (uint *) mymalloc (size_shown);
11796 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
11797
11798 uint salts_cnt = 0;
11799 uint salts_done = 0;
11800
11801 hashinfo_t **hash_info = NULL;
11802
11803 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11804 {
11805 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
11806
11807 if (username && (remove || show))
11808 {
11809 uint user_pos;
11810
11811 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
11812 {
11813 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
11814
11815 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
11816 }
11817 }
11818 }
11819
11820 uint *salts_shown = (uint *) mymalloc (size_shown);
11821
11822 salt_t *salt_buf;
11823
11824 {
11825 // copied from inner loop
11826
11827 salt_buf = &salts_buf_new[salts_cnt];
11828
11829 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
11830
11831 if (esalt_size)
11832 {
11833 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
11834 }
11835
11836 salt_buf->digests_cnt = 0;
11837 salt_buf->digests_done = 0;
11838 salt_buf->digests_offset = 0;
11839
11840 salts_cnt++;
11841 }
11842
11843 if (hashes_buf[0].cracked == 1)
11844 {
11845 digests_shown[0] = 1;
11846
11847 digests_done++;
11848
11849 salt_buf->digests_done++;
11850 }
11851
11852 salt_buf->digests_cnt++;
11853
11854 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
11855
11856 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11857 {
11858 hash_info[0] = hashes_buf[0].hash_info;
11859 }
11860
11861 // copy from inner loop
11862
11863 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
11864 {
11865 if (isSalted)
11866 {
11867 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
11868 {
11869 salt_buf = &salts_buf_new[salts_cnt];
11870
11871 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
11872
11873 if (esalt_size)
11874 {
11875 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
11876 }
11877
11878 salt_buf->digests_cnt = 0;
11879 salt_buf->digests_done = 0;
11880 salt_buf->digests_offset = hashes_pos;
11881
11882 salts_cnt++;
11883 }
11884 }
11885
11886 if (hashes_buf[hashes_pos].cracked == 1)
11887 {
11888 digests_shown[hashes_pos] = 1;
11889
11890 digests_done++;
11891
11892 salt_buf->digests_done++;
11893 }
11894
11895 salt_buf->digests_cnt++;
11896
11897 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
11898
11899 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11900 {
11901 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
11902 }
11903 }
11904
11905 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
11906 {
11907 salt_t *salt_buf = &salts_buf_new[salt_pos];
11908
11909 if (salt_buf->digests_done == salt_buf->digests_cnt)
11910 {
11911 salts_shown[salt_pos] = 1;
11912
11913 salts_done++;
11914 }
11915
11916 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
11917 }
11918
11919 local_free (digests_buf);
11920 local_free (salts_buf);
11921 local_free (esalts_buf);
11922
11923 digests_buf = digests_buf_new;
11924 salts_buf = salts_buf_new;
11925 esalts_buf = esalts_buf_new;
11926
11927 local_free (hashes_buf);
11928
11929 /**
11930 * special modification not set from parser
11931 */
11932
11933 switch (hash_mode)
11934 {
11935 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
11936 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
11937 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
11938 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
11939 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
11940 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
11941 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
11942 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
11943 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
11944 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
11945 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
11946 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
11947 }
11948
11949 if (truecrypt_keyfiles)
11950 {
11951 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
11952
11953 char *keyfiles = strdup (truecrypt_keyfiles);
11954
11955 char *keyfile = strtok (keyfiles, ",");
11956
11957 do
11958 {
11959 truecrypt_crc32 (keyfile, (unsigned char *) keyfile_buf);
11960
11961 } while ((keyfile = strtok (NULL, ",")) != NULL);
11962
11963 free (keyfiles);
11964 }
11965
11966 data.digests_cnt = digests_cnt;
11967 data.digests_done = digests_done;
11968 data.digests_buf = digests_buf;
11969 data.digests_shown = digests_shown;
11970 data.digests_shown_tmp = digests_shown_tmp;
11971
11972 data.salts_cnt = salts_cnt;
11973 data.salts_done = salts_done;
11974 data.salts_buf = salts_buf;
11975 data.salts_shown = salts_shown;
11976
11977 data.esalts_buf = esalts_buf;
11978 data.hash_info = hash_info;
11979
11980 /**
11981 * Automatic Optimizers
11982 */
11983
11984 if (salts_cnt == 1)
11985 opti_type |= OPTI_TYPE_SINGLE_SALT;
11986
11987 if (digests_cnt == 1)
11988 opti_type |= OPTI_TYPE_SINGLE_HASH;
11989
11990 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11991 opti_type |= OPTI_TYPE_NOT_ITERATED;
11992
11993 if (attack_mode == ATTACK_MODE_BF)
11994 opti_type |= OPTI_TYPE_BRUTE_FORCE;
11995
11996 data.opti_type = opti_type;
11997
11998 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
11999 {
12000 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12001 {
12002 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12003 {
12004 if (opts_type & OPTS_TYPE_ST_ADD80)
12005 {
12006 opts_type &= ~OPTS_TYPE_ST_ADD80;
12007 opts_type |= OPTS_TYPE_PT_ADD80;
12008 }
12009
12010 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12011 {
12012 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12013 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12014 }
12015
12016 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12017 {
12018 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12019 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12020 }
12021 }
12022 }
12023 }
12024
12025 /**
12026 * Some algorithm, like descrypt, can benefit from JIT compilation
12027 */
12028
12029 uint force_jit_compilation = 0;
12030
12031 if (hash_mode == 8900)
12032 {
12033 force_jit_compilation = 8900;
12034 }
12035 else if (hash_mode == 9300)
12036 {
12037 force_jit_compilation = 8900;
12038 }
12039 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12040 {
12041 force_jit_compilation = 1500;
12042 }
12043
12044 /**
12045 * generate bitmap tables
12046 */
12047
12048 const uint bitmap_shift1 = 5;
12049 const uint bitmap_shift2 = 13;
12050
12051 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12052
12053 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12054 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12055 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12056 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12057 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12058 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12059 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12060 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12061
12062 uint bitmap_bits;
12063 uint bitmap_nums;
12064 uint bitmap_mask;
12065 uint bitmap_size;
12066
12067 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12068 {
12069 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12070
12071 bitmap_nums = 1 << bitmap_bits;
12072
12073 bitmap_mask = bitmap_nums - 1;
12074
12075 bitmap_size = bitmap_nums * sizeof (uint);
12076
12077 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12078
12079 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;
12080 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;
12081
12082 break;
12083 }
12084
12085 bitmap_nums = 1 << bitmap_bits;
12086
12087 bitmap_mask = bitmap_nums - 1;
12088
12089 bitmap_size = bitmap_nums * sizeof (uint);
12090
12091 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);
12092 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);
12093
12094 /**
12095 * prepare quick rule
12096 */
12097
12098 data.rule_buf_l = rule_buf_l;
12099 data.rule_buf_r = rule_buf_r;
12100
12101 int rule_len_l = (int) strlen (rule_buf_l);
12102 int rule_len_r = (int) strlen (rule_buf_r);
12103
12104 data.rule_len_l = rule_len_l;
12105 data.rule_len_r = rule_len_r;
12106
12107 /**
12108 * load rules
12109 */
12110
12111 uint *all_kernel_rules_cnt = NULL;
12112
12113 kernel_rule_t **all_kernel_rules_buf = NULL;
12114
12115 if (rp_files_cnt)
12116 {
12117 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12118
12119 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12120 }
12121
12122 char rule_buf[BUFSIZ];
12123
12124 int rule_len = 0;
12125
12126 for (uint i = 0; i < rp_files_cnt; i++)
12127 {
12128 uint kernel_rules_avail = 0;
12129
12130 uint kernel_rules_cnt = 0;
12131
12132 kernel_rule_t *kernel_rules_buf = NULL;
12133
12134 char *rp_file = rp_files[i];
12135
12136 char in[BLOCK_SIZE];
12137 char out[BLOCK_SIZE];
12138
12139 FILE *fp = NULL;
12140
12141 uint rule_line = 0;
12142
12143 if ((fp = fopen (rp_file, "rb")) == NULL)
12144 {
12145 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12146
12147 return (-1);
12148 }
12149
12150 while (!feof (fp))
12151 {
12152 memset (rule_buf, 0, BUFSIZ);
12153
12154 rule_len = fgetl (fp, rule_buf);
12155
12156 rule_line++;
12157
12158 if (rule_len == 0) continue;
12159
12160 if (rule_buf[0] == '#') continue;
12161
12162 if (kernel_rules_avail == kernel_rules_cnt)
12163 {
12164 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12165
12166 kernel_rules_avail += INCR_RULES;
12167 }
12168
12169 memset (in, 0, BLOCK_SIZE);
12170 memset (out, 0, BLOCK_SIZE);
12171
12172 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12173
12174 if (result == -1)
12175 {
12176 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12177
12178 continue;
12179 }
12180
12181 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12182 {
12183 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12184
12185 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12186
12187 continue;
12188 }
12189
12190 /* its so slow
12191 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12192 {
12193 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12194
12195 continue;
12196 }
12197 */
12198
12199 kernel_rules_cnt++;
12200 }
12201
12202 fclose (fp);
12203
12204 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12205
12206 all_kernel_rules_buf[i] = kernel_rules_buf;
12207 }
12208
12209 /**
12210 * merge rules or automatic rule generator
12211 */
12212
12213 uint kernel_rules_cnt = 0;
12214
12215 kernel_rule_t *kernel_rules_buf = NULL;
12216
12217 if (attack_mode == ATTACK_MODE_STRAIGHT)
12218 {
12219 if (rp_files_cnt)
12220 {
12221 kernel_rules_cnt = 1;
12222
12223 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12224
12225 repeats[0] = kernel_rules_cnt;
12226
12227 for (uint i = 0; i < rp_files_cnt; i++)
12228 {
12229 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12230
12231 repeats[i + 1] = kernel_rules_cnt;
12232 }
12233
12234 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12235
12236 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12237
12238 for (uint i = 0; i < kernel_rules_cnt; i++)
12239 {
12240 uint out_pos = 0;
12241
12242 kernel_rule_t *out = &kernel_rules_buf[i];
12243
12244 for (uint j = 0; j < rp_files_cnt; j++)
12245 {
12246 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12247 uint in_pos;
12248
12249 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12250
12251 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12252 {
12253 if (out_pos == RULES_MAX - 1)
12254 {
12255 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12256
12257 break;
12258 }
12259
12260 out->cmds[out_pos] = in->cmds[in_pos];
12261 }
12262 }
12263 }
12264
12265 local_free (repeats);
12266 }
12267 else if (rp_gen)
12268 {
12269 uint kernel_rules_avail = 0;
12270
12271 while (kernel_rules_cnt < rp_gen)
12272 {
12273 if (kernel_rules_avail == kernel_rules_cnt)
12274 {
12275 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12276
12277 kernel_rules_avail += INCR_RULES;
12278 }
12279
12280 memset (rule_buf, 0, BLOCK_SIZE);
12281
12282 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12283
12284 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12285
12286 kernel_rules_cnt++;
12287 }
12288 }
12289 }
12290
12291 /**
12292 * generate NOP rules
12293 */
12294
12295 if (kernel_rules_cnt == 0)
12296 {
12297 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12298
12299 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12300
12301 kernel_rules_cnt++;
12302 }
12303
12304 data.kernel_rules_cnt = kernel_rules_cnt;
12305 data.kernel_rules_buf = kernel_rules_buf;
12306
12307 /**
12308 * platform
12309 */
12310
12311 cl_platform_id CL_platforms[CL_PLATFORMS_MAX];
12312
12313 uint CL_platforms_cnt = 0;
12314
12315 hc_clGetPlatformIDs (CL_PLATFORMS_MAX, CL_platforms, &CL_platforms_cnt);
12316
12317 if (CL_platforms_cnt == 0)
12318 {
12319 log_error ("ERROR: No OpenCL compatible platform found");
12320
12321 return (-1);
12322 }
12323
12324 int CL_platform_sel = 1;
12325
12326 if (opencl_platform != NULL)
12327 {
12328 CL_platform_sel = atoi (opencl_platform);
12329 }
12330
12331 if (CL_platforms_cnt > 1)
12332 {
12333 if (opencl_platform == NULL)
12334 {
12335 log_error ("ERROR: Too many OpenCL compatible platforms found");
12336
12337 log_info ("Please select a single platform using the --opencl-platform option");
12338 log_info ("");
12339 log_info ("Available OpenCL platforms:");
12340 log_info ("");
12341
12342 for (uint i = 0; i < CL_platforms_cnt; i++)
12343 {
12344 char CL_platform_vendor[INFOSZ];
12345
12346 memset (CL_platform_vendor, 0, sizeof (CL_platform_vendor));
12347
12348 hc_clGetPlatformInfo (CL_platforms[i], CL_PLATFORM_VENDOR, sizeof (CL_platform_vendor), CL_platform_vendor, NULL);
12349
12350 log_info ("* %d = %s", i + 1, CL_platform_vendor);
12351 }
12352
12353 log_info ("");
12354
12355 return (-1);
12356 }
12357 else
12358 {
12359 if (CL_platform_sel < 1)
12360 {
12361 log_error ("ERROR: --opencl-platform < 1");
12362
12363 return (-1);
12364 }
12365
12366 if (CL_platform_sel > (int) CL_platforms_cnt)
12367 {
12368 log_error ("ERROR: invalid OpenCL platforms selected");
12369
12370 return (-1);
12371 }
12372 }
12373 }
12374 else
12375 {
12376 if (CL_platform_sel != 1)
12377 {
12378 log_error ("ERROR: OpenCL platform number %d is not available", CL_platform_sel);
12379
12380 return (-1);
12381 }
12382 }
12383
12384 // zero-indexed: not starting to count at 1, as user does
12385
12386 CL_platform_sel -= 1;
12387
12388
12389 cl_platform_id CL_platform = CL_platforms[CL_platform_sel];
12390
12391 char CL_platform_vendor[INFOSZ];
12392
12393 memset (CL_platform_vendor, 0, sizeof (CL_platform_vendor));
12394
12395 hc_clGetPlatformInfo (CL_platform, CL_PLATFORM_VENDOR, sizeof (CL_platform_vendor), CL_platform_vendor, NULL);
12396
12397 cl_device_type device_type_filter;
12398
12399 uint vendor_id;
12400
12401 if (strcmp (CL_platform_vendor, CL_VENDOR_AMD) == 0)
12402 {
12403 vendor_id = VENDOR_ID_AMD;
12404
12405 device_type_filter = CL_DEVICE_TYPE_GPU;
12406 }
12407 else if (strcmp (CL_platform_vendor, CL_VENDOR_NV) == 0)
12408 {
12409 vendor_id = VENDOR_ID_NV;
12410
12411 device_type_filter = CL_DEVICE_TYPE_GPU;
12412
12413 // make sure that we do not directly control the fan for NVidia
12414
12415 gpu_temp_retain = 0;
12416
12417 data.gpu_temp_retain = gpu_temp_retain;
12418 }
12419 else if (strcmp (CL_platform_vendor, CL_VENDOR_POCL) == 0)
12420 {
12421 if (force == 0)
12422 {
12423 log_error ("");
12424 log_error ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12425 log_error ("You are STRONGLY encouraged not to use it");
12426 log_error ("You can use --force to override this but do not post error reports if you do so");
12427
12428 return (-1);
12429 }
12430
12431 vendor_id = VENDOR_ID_GENERIC;
12432
12433 device_type_filter = CL_DEVICE_TYPE_DEFAULT;
12434 }
12435 else
12436 {
12437 vendor_id = VENDOR_ID_GENERIC;
12438
12439 device_type_filter = CL_DEVICE_TYPE_DEFAULT;
12440 }
12441
12442 if (vendor_id == VENDOR_ID_GENERIC)
12443 {
12444 log_error ("Warning: unknown OpenCL vendor '%s' detected", CL_platform_vendor);
12445
12446 gpu_temp_disable = 1;
12447 }
12448
12449 data.vendor_id = vendor_id;
12450
12451 /**
12452 * cached kernel path depends on vendor_id which we don't know, so create it here
12453 */
12454
12455 int vendor_id_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 10 + 1;
12456
12457 char *vendor_id_folder = (char *) mymalloc (vendor_id_folder_size);
12458
12459 snprintf (vendor_id_folder, vendor_id_folder_size - 1, "%s/kernels", profile_dir);
12460
12461 mkdir (vendor_id_folder, 0700);
12462
12463 snprintf (vendor_id_folder, vendor_id_folder_size - 1, "%s/kernels/%d", profile_dir, vendor_id);
12464
12465 mkdir (vendor_id_folder, 0700);
12466
12467 myfree (vendor_id_folder);
12468
12469 /**
12470 * devices
12471 */
12472
12473 cl_device_id devices_all[DEVICES_MAX];
12474 cl_device_id devices[DEVICES_MAX];
12475
12476 uint devices_all_cnt = 0;
12477
12478 hc_clGetDeviceIDs (CL_platform, device_type_filter, DEVICES_MAX, devices_all, (uint *) &devices_all_cnt);
12479
12480 int hm_adapters_all = devices_all_cnt;
12481
12482 hm_attrs_t hm_adapter_all[DEVICES_MAX];
12483
12484 memset (hm_adapter_all, 0, sizeof (hm_adapter_all));
12485
12486 if (gpu_temp_disable == 0)
12487 {
12488 if (vendor_id == VENDOR_ID_NV)
12489 {
12490 #ifdef LINUX
12491 HM_LIB hm_dll = hm_init ();
12492
12493 data.hm_dll = hm_dll;
12494
12495 if (hc_NVML_nvmlInit (hm_dll) == NVML_SUCCESS)
12496 {
12497 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX];
12498
12499 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12500
12501 int tmp_out = 0;
12502
12503 for (int i = 0; i < tmp_in; i++)
12504 {
12505 hm_adapter_all[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12506 }
12507
12508 hm_adapters_all = tmp_out;
12509
12510 for (int i = 0; i < tmp_out; i++)
12511 {
12512 unsigned int speed;
12513
12514 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;
12515 }
12516 }
12517 #endif
12518
12519 #ifdef WIN
12520 if (NvAPI_Initialize () == NVAPI_OK)
12521 {
12522 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX];
12523
12524 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12525
12526 int tmp_out = 0;
12527
12528 for (int i = 0; i < tmp_in; i++)
12529 {
12530 hm_adapter_all[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12531 }
12532
12533 hm_adapters_all = tmp_out;
12534
12535 for (int i = 0; i < tmp_out; i++)
12536 {
12537 NvU32 speed;
12538
12539 if (NvAPI_GPU_GetTachReading (hm_adapter_all[i].adapter_index.nv, &speed) != NVAPI_NOT_SUPPORTED) hm_adapter_all[i].fan_supported = 1;
12540 }
12541 }
12542 #endif
12543 }
12544
12545 if (vendor_id == VENDOR_ID_AMD)
12546 {
12547 HM_LIB hm_dll = hm_init ();
12548
12549 data.hm_dll = hm_dll;
12550
12551 if (hc_ADL_Main_Control_Create (hm_dll, ADL_Main_Memory_Alloc, 0) == ADL_OK)
12552 {
12553 // total number of adapters
12554
12555 int hm_adapters_num;
12556
12557 if (get_adapters_num_amd (hm_dll, &hm_adapters_num) != 0) return (-1);
12558
12559 // adapter info
12560
12561 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (hm_dll, hm_adapters_num);
12562
12563 if (lpAdapterInfo == NULL) return (-1);
12564
12565 // get a list (of ids of) valid/usable adapters
12566
12567 int num_adl_adapters = 0;
12568
12569 uint32_t *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
12570
12571 if (num_adl_adapters > 0)
12572 {
12573 hc_thread_mutex_lock (mux_adl);
12574
12575 // hm_get_opencl_busid_devid (hm_adapter_all, devices_all_cnt, devices_all);
12576
12577 hm_get_adapter_index_amd (hm_adapter_all, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12578
12579 hm_get_overdrive_version (hm_dll, hm_adapter_all, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12580 hm_check_fanspeed_control (hm_dll, hm_adapter_all, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12581
12582 hc_thread_mutex_unlock (mux_adl);
12583 }
12584
12585 hm_adapters_all = num_adl_adapters;
12586
12587 myfree (valid_adl_device_list);
12588 myfree (lpAdapterInfo);
12589 }
12590 }
12591 }
12592
12593 if (hm_adapters_all == 0)
12594 {
12595 gpu_temp_disable = 1;
12596 }
12597
12598 if (gpu_temp_disable == 1)
12599 {
12600 gpu_temp_abort = 0;
12601 gpu_temp_retain = 0;
12602 }
12603
12604 /**
12605 * enable custom signal handler(s)
12606 */
12607
12608 if (benchmark == 0)
12609 {
12610 hc_signal (sigHandler_default);
12611 }
12612 else
12613 {
12614 hc_signal (sigHandler_benchmark);
12615 }
12616
12617 /**
12618 * devices mask and properties
12619 */
12620
12621 uint devices_cnt = 0;
12622
12623 for (uint device_all_id = 0; device_all_id < devices_all_cnt; device_all_id++)
12624 {
12625 if (opencl_devicemask)
12626 {
12627 uint device_all_id_mask = 1 << device_all_id;
12628
12629 if ((device_all_id_mask & opencl_devicemask) != device_all_id_mask)
12630 {
12631 if (quiet == 0 && algorithm_pos == 0) log_info ("Device #%d: skipped by user", device_all_id_mask + 1);
12632
12633 continue;
12634 }
12635 }
12636
12637 const uint device_id = devices_cnt;
12638
12639 devices[device_id] = devices_all[device_all_id];
12640
12641 memcpy (&data.hm_device[device_id], &hm_adapter_all[device_all_id], sizeof (hm_attrs_t));
12642
12643 char device_name[INFOSZ];
12644
12645 memset (device_name, 0, sizeof (device_name));
12646
12647 cl_ulong global_mem_size;
12648 cl_ulong max_mem_alloc_size;
12649 cl_uint max_clock_frequency;
12650 cl_uint max_compute_units;
12651
12652 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_NAME, sizeof (device_name), &device_name, NULL);
12653 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (global_mem_size), &global_mem_size, NULL);
12654 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (max_mem_alloc_size), &max_mem_alloc_size, NULL);
12655 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (max_clock_frequency), &max_clock_frequency, NULL);
12656 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (max_compute_units), &max_compute_units, NULL);
12657
12658 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12659 {
12660 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12661 device_all_id + 1,
12662 device_name,
12663 (unsigned int) (max_mem_alloc_size / 1024 / 1024),
12664 (unsigned int) (global_mem_size / 1024 / 1024),
12665 (unsigned int) (max_clock_frequency),
12666 (unsigned int) max_compute_units);
12667 }
12668
12669 devices_cnt++;
12670 }
12671
12672 if (devices_cnt == 0)
12673 {
12674 log_error ("ERROR: No devices left that matches your specification.");
12675
12676 return (-1);
12677 }
12678
12679 data.devices_cnt = devices_cnt;
12680
12681 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12682 {
12683 log_info ("");
12684 }
12685
12686 /**
12687 * inform the user
12688 */
12689
12690 // gpu temp sanity check
12691
12692 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
12693 {
12694 if (gpu_temp_abort < gpu_temp_retain)
12695 {
12696 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
12697
12698 return (-1);
12699 }
12700 }
12701
12702 data.gpu_temp_disable = gpu_temp_disable;
12703 data.gpu_temp_abort = gpu_temp_abort;
12704 data.gpu_temp_retain = gpu_temp_retain;
12705
12706 if (data.quiet == 0)
12707 {
12708 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
12709
12710 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);
12711
12712 if (attack_mode == ATTACK_MODE_STRAIGHT)
12713 {
12714 log_info ("Rules: %u", kernel_rules_cnt);
12715 }
12716
12717 if (opti_type)
12718 {
12719 log_info ("Applicable Optimizers:");
12720
12721 for (uint i = 0; i < 32; i++)
12722 {
12723 const uint opti_bit = 1 << i;
12724
12725 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
12726 }
12727 }
12728
12729 /**
12730 * Watchdog and Temperature balance
12731 */
12732
12733 if (gpu_temp_abort == 0)
12734 {
12735 log_info ("Watchdog: Temperature abort trigger disabled");
12736 }
12737 else
12738 {
12739 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
12740 }
12741
12742 if (gpu_temp_retain == 0)
12743 {
12744 log_info ("Watchdog: Temperature retain trigger disabled");
12745 }
12746 else
12747 {
12748 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
12749 }
12750 }
12751
12752 /**
12753 * devices init
12754 */
12755
12756 int *temp_retain_fanspeed_value = (int *) mycalloc (devices_cnt, sizeof (int));
12757
12758 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (devices_cnt, sizeof (ADLOD6MemClockState));
12759
12760 int *od_power_control_status = (int *) mycalloc (devices_cnt, sizeof (int));
12761
12762 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (devices_cnt, sizeof (hc_device_param_t));
12763
12764 data.devices_param = devices_param;
12765
12766 for (uint device_id = 0; device_id < devices_cnt; device_id++)
12767 {
12768 hc_device_param_t *device_param = &data.devices_param[device_id];
12769
12770 cl_device_id device = devices[device_id];
12771
12772 device_param->device = device;
12773
12774 cl_device_type device_type = 0;
12775
12776 hc_clGetDeviceInfo (device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12777
12778 device_param->device_type = device_type;
12779
12780 cl_uint max_compute_units = 0;
12781
12782 hc_clGetDeviceInfo (device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (max_compute_units), &max_compute_units, NULL);
12783
12784 device_param->device_processors = max_compute_units;
12785
12786 cl_ulong max_mem_alloc_size = 0;
12787
12788 hc_clGetDeviceInfo (device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (max_mem_alloc_size), &max_mem_alloc_size, NULL);
12789
12790 device_param->device_maxmem_alloc = max_mem_alloc_size;
12791
12792 char tmp[INFOSZ], t1[64];
12793
12794 memset (tmp, 0, sizeof (tmp));
12795
12796 hc_clGetDeviceInfo (device, CL_DEVICE_NAME, sizeof (tmp), &tmp, NULL);
12797
12798 device_param->device_name = mystrdup (tmp);
12799
12800 memset (tmp, 0, sizeof (tmp));
12801
12802 hc_clGetDeviceInfo (device, CL_DEVICE_VERSION, sizeof (tmp), &tmp, NULL);
12803
12804 memset (t1, 0, sizeof (t1));
12805
12806 sscanf (tmp, "%*16s %*16s %*16s (%[^)]16s)", t1);
12807
12808 device_param->device_version = mystrdup (t1);
12809
12810 memset (tmp, 0, sizeof (tmp));
12811
12812 hc_clGetDeviceInfo (device, CL_DRIVER_VERSION, sizeof (tmp), &tmp, NULL);
12813
12814 device_param->driver_version = mystrdup (tmp);
12815
12816 // create some filename that is easier to read on cached folder
12817
12818 snprintf (tmp, sizeof (tmp) - 1, "%s-%s-%s-%d", device_param->device_name, device_param->device_version, device_param->driver_version, COMPTIME);
12819
12820 uint device_name_digest[4];
12821
12822 device_name_digest[0] = 0;
12823 device_name_digest[1] = 0;
12824 device_name_digest[2] = 0;
12825 device_name_digest[3] = 0;
12826
12827 md5_64 ((uint *) tmp, device_name_digest);
12828
12829 sprintf (tmp, "%08x", device_name_digest[0]);
12830
12831 device_param->device_name_chksum = mystrdup (tmp);
12832
12833 if (device_type & CL_DEVICE_TYPE_CPU)
12834 {
12835 cl_uint device_processor_cores = 1;
12836
12837 device_param->device_processor_cores = device_processor_cores;
12838 }
12839
12840 if (device_type & CL_DEVICE_TYPE_GPU)
12841 {
12842 if (vendor_id == VENDOR_ID_AMD)
12843 {
12844 cl_uint device_processor_cores = 0;
12845
12846 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12847
12848 hc_clGetDeviceInfo (device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12849
12850 device_param->device_processor_cores = device_processor_cores;
12851 }
12852
12853 if (vendor_id == VENDOR_ID_NV)
12854 {
12855 cl_uint kernel_exec_timeout = 0;
12856
12857 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12858
12859 hc_clGetDeviceInfo (device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12860
12861 device_param->kernel_exec_timeout = kernel_exec_timeout;
12862
12863 cl_uint device_processor_cores = 0;
12864
12865 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12866
12867 hc_clGetDeviceInfo (device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12868
12869 device_param->device_processor_cores = device_processor_cores;
12870
12871 cl_uint sm_minor = 0;
12872 cl_uint sm_major = 0;
12873
12874 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12875 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12876
12877 hc_clGetDeviceInfo (device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12878 hc_clGetDeviceInfo (device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12879
12880 device_param->sm_minor = sm_minor;
12881 device_param->sm_major = sm_major;
12882 }
12883 }
12884
12885 /**
12886 * common driver check
12887 */
12888
12889 if (device_type & CL_DEVICE_TYPE_GPU)
12890 {
12891 if (vendor_id == VENDOR_ID_NV)
12892 {
12893 if (device_param->kernel_exec_timeout != 0)
12894 {
12895 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);
12896 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12897 }
12898 }
12899
12900 if (vendor_id == VENDOR_ID_AMD)
12901 {
12902 int catalyst_check = (force == 1) ? 0 : 1;
12903
12904 int catalyst_warn = 0;
12905
12906 int catalyst_broken = 0;
12907
12908 if (catalyst_check == 1)
12909 {
12910 catalyst_warn = 1;
12911
12912 // v14.9 and higher
12913 if ((atoi (device_param->device_version) >= 1573)
12914 && (atoi (device_param->driver_version) >= 1573))
12915 {
12916 catalyst_warn = 0;
12917 }
12918
12919 catalyst_check = 0;
12920 }
12921
12922 if (catalyst_broken == 1)
12923 {
12924 log_error ("");
12925 log_error ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12926 log_error ("It will pass over cracked hashes and does not report them as cracked");
12927 log_error ("You are STRONGLY encouraged not to use it");
12928 log_error ("You can use --force to override this but do not post error reports if you do so");
12929
12930 return (-1);
12931 }
12932
12933 if (catalyst_warn == 1)
12934 {
12935 log_error ("");
12936 log_error ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12937 log_error ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12938 log_error ("See oclHashcat's homepage for official supported catalyst drivers");
12939 #ifdef _WIN
12940 log_error ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12941 #endif
12942 log_error ("You can use --force to override this but do not post error reports if you do so");
12943
12944 return (-1);
12945 }
12946 }
12947 }
12948 }
12949
12950 /*
12951 * Temporary fix:
12952 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
12953 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
12954 * were not working @ full speed (setting hc_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
12955 * Driver / ADL bug?
12956 */
12957
12958 if (vendor_id == VENDOR_ID_AMD)
12959 {
12960 if (powertune_enable == 1)
12961 {
12962 hc_thread_mutex_lock (mux_adl);
12963
12964 for (uint i = 0; i < devices_cnt; i++)
12965 {
12966 if (data.hm_device[i].od_version == 6)
12967 {
12968 // set powertune value only
12969
12970 int powertune_supported = 0;
12971
12972 int ADL_rc = 0;
12973
12974 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll, data.hm_device[i].adapter_index.amd, &powertune_supported)) != ADL_OK)
12975 {
12976 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
12977
12978 return (-1);
12979 }
12980
12981 if (powertune_supported != 0)
12982 {
12983 // powertune set
12984 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
12985
12986 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll, data.hm_device[i].adapter_index.amd, &powertune)) != ADL_OK)
12987 {
12988 log_error ("ERROR: Failed to get current ADL PowerControl settings");
12989
12990 return (-1);
12991 }
12992
12993 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll, data.hm_device[i].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
12994 {
12995 log_error ("ERROR: Failed to set new ADL PowerControl values");
12996
12997 return (-1);
12998 }
12999 }
13000 }
13001 }
13002
13003 hc_thread_mutex_unlock (mux_adl);
13004 }
13005 }
13006
13007 uint kernel_blocks_all = 0;
13008
13009 for (uint device_id = 0; device_id < devices_cnt; device_id++)
13010 {
13011 /**
13012 * host buffer
13013 */
13014
13015 hc_device_param_t *device_param = &data.devices_param[device_id];
13016
13017 /**
13018 * device properties
13019 */
13020
13021 char *device_name_chksum = device_param->device_name_chksum;
13022
13023 uint device_processors = device_param->device_processors;
13024
13025 uint device_processor_cores = device_param->device_processor_cores;
13026
13027 cl_device_type device_type = device_param->device_type;
13028
13029 /**
13030 * create context for each device
13031 */
13032
13033 device_param->context = hc_clCreateContext (NULL, 1, &device_param->device, NULL, NULL);
13034
13035 /**
13036 * create command-queue
13037 */
13038
13039 // not support with NV
13040 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13041
13042 device_param->command_queue = hc_clCreateCommandQueue (device_param->context, device_param->device, 0);
13043
13044 /**
13045 * create input buffers on device
13046 */
13047
13048 uint kernel_threads = KERNEL_THREADS;
13049
13050 // bcrypt
13051 if (hash_mode == 3200) kernel_threads = 8;
13052 if (hash_mode == 9000) kernel_threads = 8;
13053
13054 if (device_type & CL_DEVICE_TYPE_CPU)
13055 {
13056 // CPU still need lots of workitems, don't know why...
13057 // for testing phase, lets start with this
13058
13059 kernel_accel = 1;
13060 }
13061
13062 uint kernel_power = device_processors * kernel_threads * kernel_accel;
13063 uint kernel_blocks = kernel_power;
13064
13065 device_param->kernel_threads = kernel_threads;
13066 device_param->kernel_power_user = kernel_power;
13067 device_param->kernel_blocks_user = kernel_blocks;
13068
13069 kernel_blocks_all += kernel_blocks;
13070
13071 uint size_pws = kernel_power * sizeof (pw_t);
13072
13073 uint size_tmps = 4;
13074
13075 switch (hash_mode)
13076 {
13077 case 400: size_tmps = kernel_blocks * sizeof (phpass_tmp_t); break;
13078 case 500: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13079 case 501: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13080 case 1600: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13081 case 1800: size_tmps = kernel_blocks * sizeof (sha512crypt_tmp_t); break;
13082 case 2100: size_tmps = kernel_blocks * sizeof (dcc2_tmp_t); break;
13083 case 2500: size_tmps = kernel_blocks * sizeof (wpa_tmp_t); break;
13084 case 3200: size_tmps = kernel_blocks * sizeof (bcrypt_tmp_t); break;
13085 case 5200: size_tmps = kernel_blocks * sizeof (pwsafe3_tmp_t); break;
13086 case 5800: size_tmps = kernel_blocks * sizeof (androidpin_tmp_t); break;
13087 case 6211:
13088 case 6212:
13089 case 6213: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13090 case 6221:
13091 case 6222:
13092 case 6223: size_tmps = kernel_blocks * sizeof (tc64_tmp_t); break;
13093 case 6231:
13094 case 6232:
13095 case 6233: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13096 case 6241:
13097 case 6242:
13098 case 6243: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13099 case 6300: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13100 case 6400: size_tmps = kernel_blocks * sizeof (sha256aix_tmp_t); break;
13101 case 6500: size_tmps = kernel_blocks * sizeof (sha512aix_tmp_t); break;
13102 case 6600: size_tmps = kernel_blocks * sizeof (agilekey_tmp_t); break;
13103 case 6700: size_tmps = kernel_blocks * sizeof (sha1aix_tmp_t); break;
13104 case 6800: size_tmps = kernel_blocks * sizeof (lastpass_tmp_t); break;
13105 case 7100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13106 case 7200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13107 case 7400: size_tmps = kernel_blocks * sizeof (sha256crypt_tmp_t); break;
13108 case 7900: size_tmps = kernel_blocks * sizeof (drupal7_tmp_t); break;
13109 case 8200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13110 case 8800: size_tmps = kernel_blocks * sizeof (androidfde_tmp_t); break;
13111 case 8900: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13112 case 9000: size_tmps = kernel_blocks * sizeof (pwsafe2_tmp_t); break;
13113 case 9100: size_tmps = kernel_blocks * sizeof (lotus8_tmp_t); break;
13114 case 9200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13115 case 9300: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13116 case 9400: size_tmps = kernel_blocks * sizeof (office2007_tmp_t); break;
13117 case 9500: size_tmps = kernel_blocks * sizeof (office2010_tmp_t); break;
13118 case 9600: size_tmps = kernel_blocks * sizeof (office2013_tmp_t); break;
13119 case 10000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13120 case 10200: size_tmps = kernel_blocks * sizeof (cram_md5_t); break;
13121 case 10300: size_tmps = kernel_blocks * sizeof (saph_sha1_tmp_t); break;
13122 case 10500: size_tmps = kernel_blocks * sizeof (pdf14_tmp_t); break;
13123 case 10700: size_tmps = kernel_blocks * sizeof (pdf17l8_tmp_t); break;
13124 case 10900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13125 case 11300: size_tmps = kernel_blocks * sizeof (bitcoin_wallet_tmp_t); break;
13126 case 11600: size_tmps = kernel_blocks * sizeof (seven_zip_tmp_t); break;
13127 case 11900: size_tmps = kernel_blocks * sizeof (pbkdf2_md5_tmp_t); break;
13128 case 12000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha1_tmp_t); break;
13129 case 12100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13130 case 12200: size_tmps = kernel_blocks * sizeof (ecryptfs_tmp_t); break;
13131 case 12300: size_tmps = kernel_blocks * sizeof (oraclet_tmp_t); break;
13132 case 12400: size_tmps = kernel_blocks * sizeof (bsdicrypt_tmp_t); break;
13133 case 12500: size_tmps = kernel_blocks * sizeof (rar3_tmp_t); break;
13134 case 12700: size_tmps = kernel_blocks * sizeof (mywallet_tmp_t); break;
13135 case 12800: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13136 case 12900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13137 case 13000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13138 };
13139
13140 uint size_hooks = 4;
13141
13142 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13143 {
13144 // insert correct hook size
13145 }
13146
13147 // we can optimize some stuff here...
13148
13149 device_param->size_pws = size_pws;
13150 device_param->size_tmps = size_tmps;
13151 device_param->size_hooks = size_hooks;
13152
13153 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13154 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13155
13156 device_param->size_root_css = size_root_css;
13157 device_param->size_markov_css = size_markov_css;
13158
13159 uint size_results = KERNEL_THREADS * sizeof (uint);
13160
13161 device_param->size_results = size_results;
13162
13163 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13164 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13165
13166 uint size_plains = digests_cnt * sizeof (plain_t);
13167 uint size_salts = salts_cnt * sizeof (salt_t);
13168 uint size_esalts = salts_cnt * esalt_size;
13169
13170 device_param->size_plains = size_plains;
13171 device_param->size_digests = size_digests;
13172 device_param->size_shown = size_shown;
13173 device_param->size_salts = size_salts;
13174
13175 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13176 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13177 uint size_tm = 32 * sizeof (bs_word_t);
13178
13179 uint64_t size_scryptV = 1;
13180
13181 if ((hash_mode == 8900) || (hash_mode == 9300))
13182 {
13183 uint tmto_start = 0;
13184 uint tmto_stop = 10;
13185
13186 if (scrypt_tmto)
13187 {
13188 tmto_start = scrypt_tmto;
13189 }
13190 else
13191 {
13192 // in case the user did not specify the tmto manually
13193 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13194 // but set the lower end only in case the user has a device with too less memory
13195
13196 if (hash_mode == 8900)
13197 {
13198 if (vendor_id == VENDOR_ID_AMD)
13199 {
13200 tmto_start = 1;
13201 }
13202 else if (vendor_id == VENDOR_ID_NV)
13203 {
13204 tmto_start = 3;
13205 }
13206 }
13207 else if (hash_mode == 9300)
13208 {
13209 if (vendor_id == VENDOR_ID_AMD)
13210 {
13211 tmto_start = 3;
13212 }
13213 else if (vendor_id == VENDOR_ID_NV)
13214 {
13215 tmto_start = 5;
13216 }
13217 }
13218 }
13219
13220 if (quiet == 0) log_info ("");
13221
13222 uint shader_per_mp = 1;
13223
13224 if (vendor_id == VENDOR_ID_AMD)
13225 {
13226 shader_per_mp = 8;
13227 }
13228
13229 if (vendor_id == VENDOR_ID_NV)
13230 {
13231 shader_per_mp = 32;
13232 }
13233
13234 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13235 {
13236 // TODO: in theory the following calculation needs to be done per salt, not global
13237 // we assume all hashes have the same scrypt settings
13238
13239 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13240
13241 size_scryptV /= 1 << tmto;
13242
13243 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13244
13245 if (size_scryptV > device_param->device_maxmem_alloc)
13246 {
13247 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13248
13249 continue;
13250 }
13251
13252 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13253 {
13254 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13255 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13256 }
13257
13258 break;
13259 }
13260
13261 if (data.salts_buf[0].scrypt_phy == 0)
13262 {
13263 log_error ("ERROR: can't allocate enough device memory");
13264
13265 return -1;
13266 }
13267
13268 if (quiet == 0) log_info ("");
13269 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13270 }
13271
13272 /**
13273 * default building options
13274 */
13275
13276 char build_opts[1024];
13277
13278 // we don't have sm_* on AMD but it doesn't matter
13279
13280 sprintf (build_opts, "-I%s/ -DVENDOR_ID=%d -DCUDA_ARCH=%d", shared_dir, vendor_id, (device_param->sm_major * 100) + device_param->sm_minor);
13281
13282 /**
13283 * main kernel
13284 */
13285
13286 {
13287 /**
13288 * kernel source filename
13289 */
13290
13291 char source_file[256];
13292
13293 memset (source_file, 0, sizeof (source_file));
13294
13295 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13296
13297 struct stat sst;
13298
13299 if (stat (source_file, &sst) == -1)
13300 {
13301 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13302
13303 return -1;
13304 }
13305
13306 /**
13307 * kernel cached filename
13308 */
13309
13310 char cached_file[256];
13311
13312 memset (cached_file, 0, sizeof (cached_file));
13313
13314 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, vendor_id, cached_file);
13315
13316 int cached = 1;
13317
13318 struct stat cst;
13319
13320 if (stat (cached_file, &cst) == -1)
13321 {
13322 cached = 0;
13323 }
13324
13325 /**
13326 * kernel compile or load
13327 */
13328
13329 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13330
13331 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13332
13333 if (force_jit_compilation == 0)
13334 {
13335 if (cached == 0)
13336 {
13337 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13338
13339 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13340
13341 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13342
13343 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13344
13345 size_t binary_size;
13346
13347 clGetProgramInfo (device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13348
13349 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13350
13351 clGetProgramInfo (device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13352
13353 writeProgramBin (cached_file, binary, binary_size);
13354
13355 local_free (binary);
13356 }
13357 else
13358 {
13359 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13360
13361 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13362
13363 device_param->program = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13364
13365 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13366 }
13367 }
13368 else
13369 {
13370 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13371
13372 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13373
13374 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13375
13376 if (force_jit_compilation == 1500)
13377 {
13378 sprintf (build_opts, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13379 }
13380 else if (force_jit_compilation == 8900)
13381 {
13382 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);
13383 }
13384
13385 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13386 }
13387
13388 local_free (kernel_lengths);
13389 local_free (kernel_sources[0]);
13390 local_free (kernel_sources);
13391
13392 // this is mostly for debug
13393
13394 size_t ret_val_size = 0;
13395
13396 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13397
13398 if (ret_val_size > 2)
13399 {
13400 char *build_log = (char *) mymalloc (ret_val_size + 1);
13401
13402 memset (build_log, 0, ret_val_size + 1);
13403
13404 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13405
13406 puts (build_log);
13407
13408 myfree (build_log);
13409 }
13410 }
13411
13412 /**
13413 * word generator kernel
13414 */
13415
13416 if (attack_mode != ATTACK_MODE_STRAIGHT)
13417 {
13418 /**
13419 * kernel mp source filename
13420 */
13421
13422 char source_file[256];
13423
13424 memset (source_file, 0, sizeof (source_file));
13425
13426 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
13427
13428 struct stat sst;
13429
13430 if (stat (source_file, &sst) == -1)
13431 {
13432 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13433
13434 return -1;
13435 }
13436
13437 /**
13438 * kernel mp cached filename
13439 */
13440
13441 char cached_file[256];
13442
13443 memset (cached_file, 0, sizeof (cached_file));
13444
13445 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, vendor_id, cached_file);
13446
13447 int cached = 1;
13448
13449 struct stat cst;
13450
13451 if (stat (cached_file, &cst) == -1)
13452 {
13453 cached = 0;
13454 }
13455
13456 /**
13457 * kernel compile or load
13458 */
13459
13460 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13461
13462 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13463
13464 if (cached == 0)
13465 {
13466 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13467
13468 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13469
13470 device_param->program_mp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13471
13472 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13473
13474 size_t binary_size;
13475
13476 clGetProgramInfo (device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13477
13478 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13479
13480 clGetProgramInfo (device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13481
13482 writeProgramBin (cached_file, binary, binary_size);
13483
13484 local_free (binary);
13485 }
13486 else
13487 {
13488 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13489
13490 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13491
13492 device_param->program_mp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13493
13494 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13495 }
13496
13497 local_free (kernel_lengths);
13498 local_free (kernel_sources[0]);
13499 local_free (kernel_sources);
13500
13501 // this is mostly for debug
13502
13503 size_t ret_val_size = 0;
13504
13505 clGetProgramBuildInfo (device_param->program_mp, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13506
13507 if (ret_val_size > 2)
13508 {
13509 char *build_log = (char *) mymalloc (ret_val_size + 1);
13510
13511 memset (build_log, 0, ret_val_size + 1);
13512
13513 clGetProgramBuildInfo (device_param->program_mp, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13514
13515 puts (build_log);
13516
13517 myfree (build_log);
13518 }
13519 }
13520
13521 /**
13522 * amplifier kernel
13523 */
13524
13525 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13526 {
13527
13528 }
13529 else
13530 {
13531 /**
13532 * kernel amp source filename
13533 */
13534
13535 char source_file[256];
13536
13537 memset (source_file, 0, sizeof (source_file));
13538
13539 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
13540
13541 struct stat sst;
13542
13543 if (stat (source_file, &sst) == -1)
13544 {
13545 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13546
13547 return -1;
13548 }
13549
13550 /**
13551 * kernel amp cached filename
13552 */
13553
13554 char cached_file[256];
13555
13556 memset (cached_file, 0, sizeof (cached_file));
13557
13558 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, vendor_id, cached_file);
13559
13560 int cached = 1;
13561
13562 struct stat cst;
13563
13564 if (stat (cached_file, &cst) == -1)
13565 {
13566 cached = 0;
13567 }
13568
13569 /**
13570 * kernel compile or load
13571 */
13572
13573 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13574
13575 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13576
13577 if (cached == 0)
13578 {
13579 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13580
13581 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13582
13583 device_param->program_amp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13584
13585 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13586
13587 size_t binary_size;
13588
13589 clGetProgramInfo (device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13590
13591 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13592
13593 clGetProgramInfo (device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13594
13595 writeProgramBin (cached_file, binary, binary_size);
13596
13597 local_free (binary);
13598 }
13599 else
13600 {
13601 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13602
13603 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13604
13605 device_param->program_amp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13606
13607 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13608 }
13609
13610 local_free (kernel_lengths);
13611 local_free (kernel_sources[0]);
13612 local_free (kernel_sources);
13613
13614 // this is mostly for debug
13615
13616 size_t ret_val_size = 0;
13617
13618 clGetProgramBuildInfo (device_param->program_amp, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13619
13620 if (ret_val_size > 2)
13621 {
13622 char *build_log = (char *) mymalloc (ret_val_size + 1);
13623
13624 memset (build_log, 0, ret_val_size + 1);
13625
13626 clGetProgramBuildInfo (device_param->program_amp, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13627
13628 puts (build_log);
13629
13630 myfree (build_log);
13631 }
13632 }
13633
13634 /**
13635 * global buffers
13636 */
13637
13638 device_param->d_pws_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13639 device_param->d_pws_amp_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13640 device_param->d_tmps = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
13641 device_param->d_hooks = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
13642 device_param->d_bitmap_s1_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13643 device_param->d_bitmap_s1_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13644 device_param->d_bitmap_s1_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13645 device_param->d_bitmap_s1_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13646 device_param->d_bitmap_s2_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13647 device_param->d_bitmap_s2_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13648 device_param->d_bitmap_s2_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13649 device_param->d_bitmap_s2_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13650 device_param->d_plain_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
13651 device_param->d_digests_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
13652 device_param->d_digests_shown = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
13653 device_param->d_salt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
13654 device_param->d_result = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
13655 device_param->d_scryptV_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
13656
13657 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_a, CL_TRUE, 0, bitmap_size, bitmap_s1_a, 0, NULL, NULL);
13658 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_b, CL_TRUE, 0, bitmap_size, bitmap_s1_b, 0, NULL, NULL);
13659 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_c, CL_TRUE, 0, bitmap_size, bitmap_s1_c, 0, NULL, NULL);
13660 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_d, CL_TRUE, 0, bitmap_size, bitmap_s1_d, 0, NULL, NULL);
13661 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_a, CL_TRUE, 0, bitmap_size, bitmap_s2_a, 0, NULL, NULL);
13662 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_b, CL_TRUE, 0, bitmap_size, bitmap_s2_b, 0, NULL, NULL);
13663 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_c, CL_TRUE, 0, bitmap_size, bitmap_s2_c, 0, NULL, NULL);
13664 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_d, CL_TRUE, 0, bitmap_size, bitmap_s2_d, 0, NULL, NULL);
13665 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
13666 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
13667 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
13668
13669 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
13670 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
13671 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
13672 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
13673 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
13674 run_kernel_bzero (device_param, device_param->d_result, size_results);
13675
13676 /**
13677 * special buffers
13678 */
13679
13680 if (attack_kern == ATTACK_KERN_STRAIGHT)
13681 {
13682 device_param->d_rules = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
13683 device_param->d_rules_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
13684
13685 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
13686
13687 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
13688 }
13689 else if (attack_kern == ATTACK_KERN_COMBI)
13690 {
13691 device_param->d_combs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13692 device_param->d_combs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13693 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13694 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13695
13696 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
13697 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
13698 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13699 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13700 }
13701 else if (attack_kern == ATTACK_KERN_BF)
13702 {
13703 device_param->d_bfs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13704 device_param->d_bfs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13705 device_param->d_tm_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
13706 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13707 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13708
13709 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
13710 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
13711 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
13712 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13713 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13714 }
13715
13716 if (size_esalts)
13717 {
13718 device_param->d_esalt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
13719
13720 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
13721 }
13722
13723 /**
13724 * main host data
13725 */
13726
13727 uint *result = (uint *) mymalloc (size_results);
13728
13729 memset (result, 0, size_results);
13730
13731 device_param->result = result;
13732
13733 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
13734
13735 memset (pws_buf, 0, size_pws);
13736
13737 device_param->pws_buf = pws_buf;
13738
13739 pw_cache_t *pw_caches = (pw_cache_t *) mycalloc (64, sizeof (pw_cache_t));
13740
13741 for (int i = 0; i < 64; i++)
13742 {
13743 pw_caches[i].pw_buf.pw_len = i;
13744 pw_caches[i].cnt = 0;
13745 }
13746
13747 device_param->pw_caches = pw_caches;
13748
13749 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
13750
13751 device_param->combs_buf = combs_buf;
13752
13753 void *hooks_buf = mymalloc (size_hooks);
13754
13755 device_param->hooks_buf = hooks_buf;
13756
13757 device_param->pw_transpose = pw_transpose_to_hi1;
13758 device_param->pw_add = pw_add_to_hc1;
13759
13760 /**
13761 * kernel args
13762 */
13763
13764 device_param->kernel_params_buf32[21] = bitmap_mask;
13765 device_param->kernel_params_buf32[22] = bitmap_shift1;
13766 device_param->kernel_params_buf32[23] = bitmap_shift2;
13767 device_param->kernel_params_buf32[24] = 0; // salt_pos
13768 device_param->kernel_params_buf32[25] = 0; // loop_pos
13769 device_param->kernel_params_buf32[26] = 0; // loop_cnt
13770 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
13771 device_param->kernel_params_buf32[28] = 0; // digests_cnt
13772 device_param->kernel_params_buf32[29] = 0; // digests_offset
13773 device_param->kernel_params_buf32[30] = 0; // combs_mode
13774 device_param->kernel_params_buf32[31] = 0; // gid_max
13775
13776 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13777 ? &device_param->d_pws_buf
13778 : &device_param->d_pws_amp_buf;
13779 device_param->kernel_params[ 1] = &device_param->d_rules_c;
13780 device_param->kernel_params[ 2] = &device_param->d_combs_c;
13781 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
13782 device_param->kernel_params[ 4] = &device_param->d_tmps;
13783 device_param->kernel_params[ 5] = &device_param->d_hooks;
13784 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
13785 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
13786 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
13787 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
13788 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
13789 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
13790 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
13791 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
13792 device_param->kernel_params[14] = &device_param->d_plain_bufs;
13793 device_param->kernel_params[15] = &device_param->d_digests_buf;
13794 device_param->kernel_params[16] = &device_param->d_digests_shown;
13795 device_param->kernel_params[17] = &device_param->d_salt_bufs;
13796 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
13797 device_param->kernel_params[19] = &device_param->d_result;
13798 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
13799 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
13800 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
13801 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
13802 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
13803 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
13804 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
13805 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
13806 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
13807 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
13808 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
13809 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
13810
13811 device_param->kernel_params_mp_buf64[3] = 0;
13812 device_param->kernel_params_mp_buf32[4] = 0;
13813 device_param->kernel_params_mp_buf32[5] = 0;
13814 device_param->kernel_params_mp_buf32[6] = 0;
13815 device_param->kernel_params_mp_buf32[7] = 0;
13816 device_param->kernel_params_mp_buf32[8] = 0;
13817
13818 device_param->kernel_params_mp[0] = NULL;
13819 device_param->kernel_params_mp[1] = NULL;
13820 device_param->kernel_params_mp[2] = NULL;
13821 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
13822 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
13823 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
13824 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
13825 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
13826 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
13827
13828 device_param->kernel_params_mp_l_buf64[3] = 0;
13829 device_param->kernel_params_mp_l_buf32[4] = 0;
13830 device_param->kernel_params_mp_l_buf32[5] = 0;
13831 device_param->kernel_params_mp_l_buf32[6] = 0;
13832 device_param->kernel_params_mp_l_buf32[7] = 0;
13833 device_param->kernel_params_mp_l_buf32[8] = 0;
13834 device_param->kernel_params_mp_l_buf32[9] = 0;
13835
13836 device_param->kernel_params_mp_l[0] = NULL;
13837 device_param->kernel_params_mp_l[1] = NULL;
13838 device_param->kernel_params_mp_l[2] = NULL;
13839 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
13840 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
13841 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
13842 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
13843 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
13844 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
13845 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
13846
13847 device_param->kernel_params_mp_r_buf64[3] = 0;
13848 device_param->kernel_params_mp_r_buf32[4] = 0;
13849 device_param->kernel_params_mp_r_buf32[5] = 0;
13850 device_param->kernel_params_mp_r_buf32[6] = 0;
13851 device_param->kernel_params_mp_r_buf32[7] = 0;
13852 device_param->kernel_params_mp_r_buf32[8] = 0;
13853
13854 device_param->kernel_params_mp_r[0] = NULL;
13855 device_param->kernel_params_mp_r[1] = NULL;
13856 device_param->kernel_params_mp_r[2] = NULL;
13857 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
13858 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
13859 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
13860 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
13861 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
13862 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
13863
13864 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
13865 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
13866
13867 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
13868 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
13869 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
13870 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
13871 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
13872 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
13873 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
13874
13875 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
13876
13877 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
13878 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
13879
13880 /**
13881 * kernel name
13882 */
13883
13884 char kernel_name[64];
13885
13886 memset (kernel_name, 0, sizeof (kernel_name));
13887
13888 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13889 {
13890 if (opti_type & OPTI_TYPE_SINGLE_HASH)
13891 {
13892 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
13893
13894 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
13895
13896 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
13897
13898 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
13899
13900 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
13901
13902 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
13903 }
13904 else
13905 {
13906 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
13907
13908 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
13909
13910 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
13911
13912 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
13913
13914 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
13915
13916 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
13917 }
13918
13919 if (data.attack_mode == ATTACK_MODE_BF)
13920 {
13921 if (opts_type & OPTS_TYPE_PT_BITSLICE)
13922 {
13923 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
13924
13925 device_param->kernel_tb = hc_clCreateKernel (device_param->program, kernel_name);
13926
13927 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
13928
13929 device_param->kernel_tm = hc_clCreateKernel (device_param->program, kernel_name);
13930 }
13931 }
13932 }
13933 else
13934 {
13935 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
13936
13937 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
13938
13939 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
13940
13941 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
13942
13943 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
13944
13945 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
13946
13947 if (opts_type & OPTS_TYPE_HOOK12)
13948 {
13949 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
13950
13951 device_param->kernel12 = hc_clCreateKernel (device_param->program, kernel_name);
13952 }
13953
13954 if (opts_type & OPTS_TYPE_HOOK23)
13955 {
13956 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
13957
13958 device_param->kernel23 = hc_clCreateKernel (device_param->program, kernel_name);
13959 }
13960 }
13961
13962 for (uint i = 0; i <= 20; i++)
13963 {
13964 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
13965 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
13966 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
13967
13968 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
13969 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
13970 }
13971
13972 for (uint i = 21; i <= 31; i++)
13973 {
13974 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
13975 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
13976 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
13977
13978 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
13979 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
13980 }
13981
13982 if (attack_mode == ATTACK_MODE_BF)
13983 {
13984 device_param->kernel_mp_l = hc_clCreateKernel (device_param->program_mp, "l_markov");
13985 device_param->kernel_mp_r = hc_clCreateKernel (device_param->program_mp, "r_markov");
13986
13987 if (opts_type & OPTS_TYPE_PT_BITSLICE)
13988 {
13989 hc_clSetKernelArg (device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
13990
13991 hc_clSetKernelArg (device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
13992 hc_clSetKernelArg (device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
13993 }
13994 }
13995 else if (attack_mode == ATTACK_MODE_HYBRID1)
13996 {
13997 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
13998 }
13999 else if (attack_mode == ATTACK_MODE_HYBRID2)
14000 {
14001 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
14002 }
14003
14004 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14005 {
14006 // nothing to do
14007 }
14008 else
14009 {
14010 device_param->kernel_amp = hc_clCreateKernel (device_param->program_amp, "amp");
14011 }
14012
14013 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14014 {
14015 // nothing to do
14016 }
14017 else
14018 {
14019 for (uint i = 0; i < 5; i++)
14020 {
14021 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14022 }
14023
14024 for (uint i = 5; i < 7; i++)
14025 {
14026 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14027 }
14028 }
14029
14030 /**
14031 * Store initial fanspeed if gpu_temp_retain is enabled
14032 */
14033
14034 int gpu_temp_retain_set = 0;
14035
14036 if (gpu_temp_disable == 0)
14037 {
14038 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14039 {
14040 hc_thread_mutex_lock (mux_adl);
14041
14042 if (data.hm_device[device_id].fan_supported == 1)
14043 {
14044 if (gpu_temp_retain_chgd == 0)
14045 {
14046 uint cur_temp = 0;
14047 uint default_temp = 0;
14048
14049 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);
14050
14051 if (ADL_rc == ADL_OK)
14052 {
14053 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14054
14055 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14056
14057 // special case with multi gpu setups: always use minimum retain
14058
14059 if (gpu_temp_retain_set == 0)
14060 {
14061 gpu_temp_retain = gpu_temp_retain_target;
14062 gpu_temp_retain_set = 1;
14063 }
14064 else
14065 {
14066 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14067 }
14068
14069 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14070 }
14071 }
14072
14073 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14074
14075 temp_retain_fanspeed_value[device_id] = fan_speed;
14076
14077 if (fan_speed == -1)
14078 {
14079 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14080
14081 temp_retain_fanspeed_value[device_id] = 0;
14082 }
14083 }
14084
14085 hc_thread_mutex_unlock (mux_adl);
14086 }
14087 }
14088
14089 /**
14090 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14091 */
14092
14093 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14094 {
14095 hc_thread_mutex_lock (mux_adl);
14096
14097 if (data.hm_device[device_id].od_version == 6)
14098 {
14099 int ADL_rc;
14100
14101 // check powertune capabilities first, if not available then skip device
14102
14103 int powertune_supported = 0;
14104
14105 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14106 {
14107 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14108
14109 return (-1);
14110 }
14111
14112 if (powertune_supported != 0)
14113 {
14114 // powercontrol settings
14115
14116 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14117
14118 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14119 {
14120 ADL_rc = hc_ADL_Overdrive_PowerControl_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14121 }
14122
14123 if (ADL_rc != ADL_OK)
14124 {
14125 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14126
14127 return (-1);
14128 }
14129
14130 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14131 {
14132 log_error ("ERROR: Failed to set new ADL PowerControl values");
14133
14134 return (-1);
14135 }
14136
14137 // clocks
14138
14139 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14140
14141 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14142
14143 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)
14144 {
14145 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14146
14147 return (-1);
14148 }
14149
14150 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14151
14152 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14153
14154 if ((ADL_rc = hc_ADL_Overdrive_Capabilities_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14155 {
14156 log_error ("ERROR: Failed to get ADL device capabilities");
14157
14158 return (-1);
14159 }
14160
14161 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14162 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14163
14164 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14165 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14166
14167 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14168 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14169
14170 // warning if profile has to low max values
14171
14172 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14173 {
14174 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14175 }
14176
14177 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14178 {
14179 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14180 }
14181
14182 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14183
14184 performance_state->iNumberOfPerformanceLevels = 2;
14185
14186 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14187 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14188 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14189 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14190
14191 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)
14192 {
14193 log_info ("ERROR: Failed to set ADL performance state");
14194
14195 return (-1);
14196 }
14197
14198 local_free (performance_state);
14199 }
14200 }
14201
14202 hc_thread_mutex_unlock (mux_adl);
14203 }
14204 }
14205
14206 data.kernel_blocks_all = kernel_blocks_all;
14207
14208 if (data.quiet == 0) log_info ("");
14209
14210 /**
14211 * Inform user which algorithm is checked and at which workload setting
14212 */
14213
14214 if (benchmark == 1)
14215 {
14216 quiet = 0;
14217
14218 data.quiet = quiet;
14219
14220 char *hash_type = strhashtype (data.hash_mode); // not a bug
14221
14222 log_info ("Hashtype: %s", hash_type);
14223 log_info ("Workload: %u loops, %u accel", kernel_loops, kernel_accel);
14224 log_info ("");
14225 }
14226
14227 /**
14228 * keep track of the progress
14229 */
14230
14231 data.words_progress_done = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
14232 data.words_progress_rejected = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
14233 data.words_progress_restored = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
14234
14235 /**
14236 * open filehandles
14237 */
14238
14239 #if _WIN
14240 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14241 {
14242 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14243
14244 return (-1);
14245 }
14246
14247 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14248 {
14249 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14250
14251 return (-1);
14252 }
14253
14254 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14255 {
14256 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14257
14258 return (-1);
14259 }
14260 #endif
14261
14262 /**
14263 * dictionary pad
14264 */
14265
14266 segment_size *= (1024 * 1024);
14267
14268 data.segment_size = segment_size;
14269
14270 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14271
14272 wl_data->buf = (char *) mymalloc (segment_size);
14273 wl_data->avail = segment_size;
14274 wl_data->incr = segment_size;
14275 wl_data->cnt = 0;
14276 wl_data->pos = 0;
14277
14278 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14279
14280 data.wordlist_mode = wordlist_mode;
14281
14282 cs_t *css_buf = NULL;
14283 uint css_cnt = 0;
14284 uint dictcnt = 0;
14285 uint maskcnt = 1;
14286 char **masks = NULL;
14287 char **dictfiles = NULL;
14288
14289 uint mask_from_file = 0;
14290
14291 if (attack_mode == ATTACK_MODE_STRAIGHT)
14292 {
14293 if (wordlist_mode == WL_MODE_FILE)
14294 {
14295 int wls_left = myargc - (optind + 1);
14296
14297 for (int i = 0; i < wls_left; i++)
14298 {
14299 char *l0_filename = myargv[optind + 1 + i];
14300
14301 struct stat l0_stat;
14302
14303 if (stat (l0_filename, &l0_stat) == -1)
14304 {
14305 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14306
14307 return (-1);
14308 }
14309
14310 uint is_dir = S_ISDIR (l0_stat.st_mode);
14311
14312 if (is_dir == 0)
14313 {
14314 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14315
14316 dictcnt++;
14317
14318 dictfiles[dictcnt - 1] = l0_filename;
14319 }
14320 else
14321 {
14322 // do not allow --keyspace w/ a directory
14323
14324 if (keyspace == 1)
14325 {
14326 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14327
14328 return (-1);
14329 }
14330
14331 char **dictionary_files = NULL;
14332
14333 dictionary_files = scan_directory (l0_filename);
14334
14335 if (dictionary_files != NULL)
14336 {
14337 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14338
14339 for (int d = 0; dictionary_files[d] != NULL; d++)
14340 {
14341 char *l1_filename = dictionary_files[d];
14342
14343 struct stat l1_stat;
14344
14345 if (stat (l1_filename, &l1_stat) == -1)
14346 {
14347 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14348
14349 return (-1);
14350 }
14351
14352 if (S_ISREG (l1_stat.st_mode))
14353 {
14354 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14355
14356 dictcnt++;
14357
14358 dictfiles[dictcnt - 1] = strdup (l1_filename);
14359 }
14360 }
14361 }
14362
14363 local_free (dictionary_files);
14364 }
14365 }
14366
14367 if (dictcnt < 1)
14368 {
14369 log_error ("ERROR: No usable dictionary file found.");
14370
14371 return (-1);
14372 }
14373 }
14374 else if (wordlist_mode == WL_MODE_STDIN)
14375 {
14376 dictcnt = 1;
14377 }
14378 }
14379 else if (attack_mode == ATTACK_MODE_COMBI)
14380 {
14381 // display
14382
14383 char *dictfile1 = myargv[optind + 1 + 0];
14384 char *dictfile2 = myargv[optind + 1 + 1];
14385
14386 // find the bigger dictionary and use as base
14387
14388 FILE *fp1;
14389 FILE *fp2;
14390
14391 struct stat tmp_stat;
14392
14393 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14394 {
14395 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14396
14397 return (-1);
14398 }
14399
14400 if (stat (dictfile1, &tmp_stat) == -1)
14401 {
14402 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14403
14404 fclose (fp1);
14405
14406 return (-1);
14407 }
14408
14409 if (S_ISDIR (tmp_stat.st_mode))
14410 {
14411 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14412
14413 fclose (fp1);
14414
14415 return (-1);
14416 }
14417
14418 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14419 {
14420 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14421
14422 fclose (fp1);
14423
14424 return (-1);
14425 }
14426
14427 if (stat (dictfile2, &tmp_stat) == -1)
14428 {
14429 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14430
14431 fclose (fp1);
14432 fclose (fp2);
14433
14434 return (-1);
14435 }
14436
14437 if (S_ISDIR (tmp_stat.st_mode))
14438 {
14439 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14440
14441 fclose (fp1);
14442 fclose (fp2);
14443
14444 return (-1);
14445 }
14446
14447 data.combs_cnt = 1;
14448
14449 data.quiet = 1;
14450
14451 const uint64_t words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14452
14453 data.quiet = quiet;
14454
14455 if (words1_cnt == 0)
14456 {
14457 log_error ("ERROR: %s: empty file", dictfile1);
14458
14459 fclose (fp1);
14460 fclose (fp2);
14461
14462 return (-1);
14463 }
14464
14465 data.combs_cnt = 1;
14466
14467 data.quiet = 1;
14468
14469 const uint64_t words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14470
14471 data.quiet = quiet;
14472
14473 if (words2_cnt == 0)
14474 {
14475 log_error ("ERROR: %s: empty file", dictfile2);
14476
14477 fclose (fp1);
14478 fclose (fp2);
14479
14480 return (-1);
14481 }
14482
14483 fclose (fp1);
14484 fclose (fp2);
14485
14486 data.dictfile = dictfile1;
14487 data.dictfile2 = dictfile2;
14488
14489 if (words1_cnt >= words2_cnt)
14490 {
14491 data.combs_cnt = words2_cnt;
14492 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14493
14494 dictfiles = &data.dictfile;
14495
14496 dictcnt = 1;
14497 }
14498 else
14499 {
14500 data.combs_cnt = words1_cnt;
14501 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14502
14503 dictfiles = &data.dictfile2;
14504
14505 dictcnt = 1;
14506
14507 // we also have to switch wordlist related rules!
14508
14509 char *tmpc = data.rule_buf_l;
14510
14511 data.rule_buf_l = data.rule_buf_r;
14512 data.rule_buf_r = tmpc;
14513
14514 int tmpi = data.rule_len_l;
14515
14516 data.rule_len_l = data.rule_len_r;
14517 data.rule_len_r = tmpi;
14518 }
14519 }
14520 else if (attack_mode == ATTACK_MODE_BF)
14521 {
14522 char *mask = NULL;
14523
14524 maskcnt = 0;
14525
14526 if (benchmark == 0)
14527 {
14528 mask = myargv[optind + 1];
14529
14530 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
14531
14532 if ((optind + 2) <= myargc)
14533 {
14534 struct stat file_stat;
14535
14536 if (stat (mask, &file_stat) == -1)
14537 {
14538 maskcnt = 1;
14539
14540 masks[maskcnt - 1] = mystrdup (mask);
14541 }
14542 else
14543 {
14544 int wls_left = myargc - (optind + 1);
14545
14546 uint masks_avail = INCR_MASKS;
14547
14548 for (int i = 0; i < wls_left; i++)
14549 {
14550 if (i != 0)
14551 {
14552 mask = myargv[optind + 1 + i];
14553
14554 if (stat (mask, &file_stat) == -1)
14555 {
14556 log_error ("ERROR: %s: %s", mask, strerror (errno));
14557
14558 return (-1);
14559 }
14560 }
14561
14562 uint is_file = S_ISREG (file_stat.st_mode);
14563
14564 if (is_file == 1)
14565 {
14566 FILE *mask_fp;
14567
14568 if ((mask_fp = fopen (mask, "r")) == NULL)
14569 {
14570 log_error ("ERROR: %s: %s", mask, strerror (errno));
14571
14572 return (-1);
14573 }
14574
14575 char line_buf[BUFSIZ];
14576
14577 while (!feof (mask_fp))
14578 {
14579 memset (line_buf, 0, BUFSIZ);
14580
14581 int line_len = fgetl (mask_fp, line_buf);
14582
14583 if (line_len == 0) continue;
14584
14585 if (line_buf[0] == '#') continue;
14586
14587 if (masks_avail == maskcnt)
14588 {
14589 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14590
14591 masks_avail += INCR_MASKS;
14592 }
14593
14594 masks[maskcnt] = mystrdup (line_buf);
14595
14596 maskcnt++;
14597 }
14598
14599 fclose (mask_fp);
14600 }
14601 else
14602 {
14603 log_error ("ERROR: %s: unsupported file-type", mask);
14604
14605 return (-1);
14606 }
14607 }
14608
14609 mask_from_file = 1;
14610 }
14611 }
14612 else
14613 {
14614 custom_charset_1 = (char *) "?l?d?u";
14615 custom_charset_2 = (char *) "?l?d";
14616 custom_charset_3 = (char *) "?l?d*!$@_";
14617
14618 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
14619 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
14620 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
14621
14622 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
14623
14624 wordlist_mode = WL_MODE_MASK;
14625
14626 data.wordlist_mode = wordlist_mode;
14627
14628 increment = 1;
14629
14630 maskcnt = 1;
14631 }
14632 }
14633 else
14634 {
14635 /**
14636 * generate full masks and charsets
14637 */
14638
14639 masks = (char **) mymalloc (sizeof (char *));
14640
14641 switch (hash_mode)
14642 {
14643 case 1731: pw_min = 5;
14644 pw_max = 5;
14645 mask = mystrdup ("?b?b?b?b?b");
14646 break;
14647 case 12500: pw_min = 5;
14648 pw_max = 5;
14649 mask = mystrdup ("?b?b?b?b?b");
14650 break;
14651 default: pw_min = 7;
14652 pw_max = 7;
14653 mask = mystrdup ("?b?b?b?b?b?b?b");
14654 break;
14655 }
14656
14657 maskcnt = 1;
14658
14659 masks[maskcnt - 1] = mystrdup (mask);
14660
14661 wordlist_mode = WL_MODE_MASK;
14662
14663 data.wordlist_mode = wordlist_mode;
14664
14665 increment = 1;
14666 }
14667
14668 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
14669
14670 if (increment)
14671 {
14672 if (increment_min > pw_min) pw_min = increment_min;
14673
14674 if (increment_max < pw_max) pw_max = increment_max;
14675 }
14676 }
14677 else if (attack_mode == ATTACK_MODE_HYBRID1)
14678 {
14679 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14680
14681 // display
14682
14683 char *mask = myargv[myargc - 1];
14684
14685 maskcnt = 0;
14686
14687 masks = (char **) mymalloc (1 * sizeof (char *));
14688
14689 // mod
14690
14691 struct stat file_stat;
14692
14693 if (stat (mask, &file_stat) == -1)
14694 {
14695 maskcnt = 1;
14696
14697 masks[maskcnt - 1] = mystrdup (mask);
14698 }
14699 else
14700 {
14701 uint is_file = S_ISREG (file_stat.st_mode);
14702
14703 if (is_file == 1)
14704 {
14705 FILE *mask_fp;
14706
14707 if ((mask_fp = fopen (mask, "r")) == NULL)
14708 {
14709 log_error ("ERROR: %s: %s", mask, strerror (errno));
14710
14711 return (-1);
14712 }
14713
14714 char line_buf[BUFSIZ];
14715
14716 uint masks_avail = 1;
14717
14718 while (!feof (mask_fp))
14719 {
14720 memset (line_buf, 0, BUFSIZ);
14721
14722 int line_len = fgetl (mask_fp, line_buf);
14723
14724 if (line_len == 0) continue;
14725
14726 if (line_buf[0] == '#') continue;
14727
14728 if (masks_avail == maskcnt)
14729 {
14730 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14731
14732 masks_avail += INCR_MASKS;
14733 }
14734
14735 masks[maskcnt] = mystrdup (line_buf);
14736
14737 maskcnt++;
14738 }
14739
14740 fclose (mask_fp);
14741
14742 mask_from_file = 1;
14743 }
14744 else
14745 {
14746 maskcnt = 1;
14747
14748 masks[maskcnt - 1] = mystrdup (mask);
14749 }
14750 }
14751
14752 // base
14753
14754 int wls_left = myargc - (optind + 2);
14755
14756 for (int i = 0; i < wls_left; i++)
14757 {
14758 char *filename = myargv[optind + 1 + i];
14759
14760 struct stat file_stat;
14761
14762 if (stat (filename, &file_stat) == -1)
14763 {
14764 log_error ("ERROR: %s: %s", filename, strerror (errno));
14765
14766 return (-1);
14767 }
14768
14769 uint is_dir = S_ISDIR (file_stat.st_mode);
14770
14771 if (is_dir == 0)
14772 {
14773 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14774
14775 dictcnt++;
14776
14777 dictfiles[dictcnt - 1] = filename;
14778 }
14779 else
14780 {
14781 // do not allow --keyspace w/ a directory
14782
14783 if (keyspace == 1)
14784 {
14785 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14786
14787 return (-1);
14788 }
14789
14790 char **dictionary_files = NULL;
14791
14792 dictionary_files = scan_directory (filename);
14793
14794 if (dictionary_files != NULL)
14795 {
14796 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14797
14798 for (int d = 0; dictionary_files[d] != NULL; d++)
14799 {
14800 char *l1_filename = dictionary_files[d];
14801
14802 struct stat l1_stat;
14803
14804 if (stat (l1_filename, &l1_stat) == -1)
14805 {
14806 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14807
14808 return (-1);
14809 }
14810
14811 if (S_ISREG (l1_stat.st_mode))
14812 {
14813 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14814
14815 dictcnt++;
14816
14817 dictfiles[dictcnt - 1] = strdup (l1_filename);
14818 }
14819 }
14820 }
14821
14822 local_free (dictionary_files);
14823 }
14824 }
14825
14826 if (dictcnt < 1)
14827 {
14828 log_error ("ERROR: No usable dictionary file found.");
14829
14830 return (-1);
14831 }
14832
14833 if (increment)
14834 {
14835 maskcnt = 0;
14836
14837 uint mask_min = increment_min; // we can't reject smaller masks here
14838 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
14839
14840 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
14841 {
14842 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
14843
14844 if (cur_mask == NULL) break;
14845
14846 masks[maskcnt] = cur_mask;
14847
14848 maskcnt++;
14849
14850 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
14851 }
14852 }
14853 }
14854 else if (attack_mode == ATTACK_MODE_HYBRID2)
14855 {
14856 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14857
14858 // display
14859
14860 char *mask = myargv[optind + 1 + 0];
14861
14862 maskcnt = 0;
14863
14864 masks = (char **) mymalloc (1 * sizeof (char *));
14865
14866 // mod
14867
14868 struct stat file_stat;
14869
14870 if (stat (mask, &file_stat) == -1)
14871 {
14872 maskcnt = 1;
14873
14874 masks[maskcnt - 1] = mystrdup (mask);
14875 }
14876 else
14877 {
14878 uint is_file = S_ISREG (file_stat.st_mode);
14879
14880 if (is_file == 1)
14881 {
14882 FILE *mask_fp;
14883
14884 if ((mask_fp = fopen (mask, "r")) == NULL)
14885 {
14886 log_error ("ERROR: %s: %s", mask, strerror (errno));
14887
14888 return (-1);
14889 }
14890
14891 char line_buf[BUFSIZ];
14892
14893 uint masks_avail = 1;
14894
14895 while (!feof (mask_fp))
14896 {
14897 memset (line_buf, 0, BUFSIZ);
14898
14899 int line_len = fgetl (mask_fp, line_buf);
14900
14901 if (line_len == 0) continue;
14902
14903 if (line_buf[0] == '#') continue;
14904
14905 if (masks_avail == maskcnt)
14906 {
14907 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14908
14909 masks_avail += INCR_MASKS;
14910 }
14911
14912 masks[maskcnt] = mystrdup (line_buf);
14913
14914 maskcnt++;
14915 }
14916
14917 fclose (mask_fp);
14918
14919 mask_from_file = 1;
14920 }
14921 else
14922 {
14923 maskcnt = 1;
14924
14925 masks[maskcnt - 1] = mystrdup (mask);
14926 }
14927 }
14928
14929 // base
14930
14931 int wls_left = myargc - (optind + 2);
14932
14933 for (int i = 0; i < wls_left; i++)
14934 {
14935 char *filename = myargv[optind + 2 + i];
14936
14937 struct stat file_stat;
14938
14939 if (stat (filename, &file_stat) == -1)
14940 {
14941 log_error ("ERROR: %s: %s", filename, strerror (errno));
14942
14943 return (-1);
14944 }
14945
14946 uint is_dir = S_ISDIR (file_stat.st_mode);
14947
14948 if (is_dir == 0)
14949 {
14950 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14951
14952 dictcnt++;
14953
14954 dictfiles[dictcnt - 1] = filename;
14955 }
14956 else
14957 {
14958 // do not allow --keyspace w/ a directory
14959
14960 if (keyspace == 1)
14961 {
14962 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14963
14964 return (-1);
14965 }
14966
14967 char **dictionary_files = NULL;
14968
14969 dictionary_files = scan_directory (filename);
14970
14971 if (dictionary_files != NULL)
14972 {
14973 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14974
14975 for (int d = 0; dictionary_files[d] != NULL; d++)
14976 {
14977 char *l1_filename = dictionary_files[d];
14978
14979 struct stat l1_stat;
14980
14981 if (stat (l1_filename, &l1_stat) == -1)
14982 {
14983 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14984
14985 return (-1);
14986 }
14987
14988 if (S_ISREG (l1_stat.st_mode))
14989 {
14990 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14991
14992 dictcnt++;
14993
14994 dictfiles[dictcnt - 1] = strdup (l1_filename);
14995 }
14996 }
14997 }
14998
14999 local_free (dictionary_files);
15000 }
15001 }
15002
15003 if (dictcnt < 1)
15004 {
15005 log_error ("ERROR: No usable dictionary file found.");
15006
15007 return (-1);
15008 }
15009
15010 if (increment)
15011 {
15012 maskcnt = 0;
15013
15014 uint mask_min = increment_min; // we can't reject smaller masks here
15015 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15016
15017 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15018 {
15019 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15020
15021 if (cur_mask == NULL) break;
15022
15023 masks[maskcnt] = cur_mask;
15024
15025 maskcnt++;
15026
15027 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15028 }
15029 }
15030 }
15031
15032 data.pw_min = pw_min;
15033 data.pw_max = pw_max;
15034
15035 /**
15036 * weak hash check
15037 */
15038
15039 if (weak_hash_threshold >= salts_cnt)
15040 {
15041 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15042
15043 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15044 {
15045 weak_hash_check (&data.devices_param[0], salt_pos, kernel_loops);
15046 }
15047 }
15048
15049 // Display hack, guarantee that there is at least one \r before real start
15050
15051 if (data.quiet == 0) log_info_nn ("");
15052
15053 /**
15054 * status and monitor threads
15055 */
15056
15057 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15058
15059 hc_thread_t i_thread = 0;
15060
15061 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15062 {
15063 hc_thread_create (i_thread, thread_keypress, &benchmark);
15064 }
15065
15066 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15067
15068 uint ni_threads_cnt = 0;
15069
15070 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15071
15072 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15073
15074 ni_threads_cnt++;
15075
15076 /**
15077 * Outfile remove
15078 */
15079
15080 if (keyspace == 0)
15081 {
15082 if (outfile_check_timer != 0)
15083 {
15084 if (data.outfile_check_directory != NULL)
15085 {
15086 if ((hash_mode != 5200) &&
15087 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15088 (hash_mode != 9000))
15089 {
15090 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15091
15092 ni_threads_cnt++;
15093 }
15094 else
15095 {
15096 outfile_check_timer = 0;
15097 }
15098 }
15099 else
15100 {
15101 outfile_check_timer = 0;
15102 }
15103 }
15104 }
15105
15106 /**
15107 * Inform the user if we got some hashes remove because of the pot file remove feature
15108 */
15109
15110 if (data.quiet == 0)
15111 {
15112 if (potfile_remove_cracks > 0)
15113 {
15114 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15115 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15116 }
15117 }
15118
15119 data.outfile_check_timer = outfile_check_timer;
15120
15121 /**
15122 * main loop
15123 */
15124
15125 char **induction_dictionaries = NULL;
15126
15127 int induction_dictionaries_cnt = 0;
15128
15129 hcstat_table_t *root_table_buf = NULL;
15130 hcstat_table_t *markov_table_buf = NULL;
15131
15132 uint initial_restore_done = 0;
15133
15134 data.maskcnt = maskcnt;
15135
15136 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15137 {
15138 if (data.devices_status == STATUS_CRACKED) break;
15139
15140 data.devices_status = STATUS_INIT;
15141
15142 if (maskpos > rd->maskpos)
15143 {
15144 rd->dictpos = 0;
15145 }
15146
15147 rd->maskpos = maskpos;
15148 data.maskpos = maskpos;
15149
15150 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15151 {
15152 char *mask = masks[maskpos];
15153
15154 if (mask_from_file == 1)
15155 {
15156 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15157
15158 char *str_ptr;
15159 uint str_pos;
15160
15161 uint mask_offset = 0;
15162
15163 uint separator_cnt;
15164
15165 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15166 {
15167 str_ptr = strstr (mask + mask_offset, ",");
15168
15169 if (str_ptr == NULL) break;
15170
15171 str_pos = str_ptr - mask;
15172
15173 // escaped separator, i.e. "\,"
15174
15175 if (str_pos > 0)
15176 {
15177 if (mask[str_pos - 1] == '\\')
15178 {
15179 separator_cnt --;
15180
15181 mask_offset = str_pos + 1;
15182
15183 continue;
15184 }
15185 }
15186
15187 // reset the offset
15188
15189 mask_offset = 0;
15190
15191 mask[str_pos] = '\0';
15192
15193 switch (separator_cnt)
15194 {
15195 case 0:
15196 mp_reset_usr (mp_usr, 0);
15197
15198 custom_charset_1 = mask;
15199 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15200 break;
15201
15202 case 1:
15203 mp_reset_usr (mp_usr, 1);
15204
15205 custom_charset_2 = mask;
15206 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15207 break;
15208
15209 case 2:
15210 mp_reset_usr (mp_usr, 2);
15211
15212 custom_charset_3 = mask;
15213 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15214 break;
15215
15216 case 3:
15217 mp_reset_usr (mp_usr, 3);
15218
15219 custom_charset_4 = mask;
15220 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15221 break;
15222 }
15223
15224 mask = mask + str_pos + 1;
15225 }
15226 }
15227
15228 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15229 {
15230 if (maskpos > 0)
15231 {
15232 local_free (css_buf);
15233 local_free (data.root_css_buf);
15234 local_free (data.markov_css_buf);
15235
15236 local_free (masks[maskpos - 1]);
15237 }
15238
15239 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15240
15241 data.mask = mask;
15242 data.css_cnt = css_cnt;
15243 data.css_buf = css_buf;
15244
15245 uint uniq_tbls[SP_PW_MAX][CHARSIZ];
15246
15247 memset (uniq_tbls, 0, sizeof (uniq_tbls));
15248
15249 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15250
15251 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15252 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15253
15254 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15255
15256 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15257
15258 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15259 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15260
15261 data.root_css_buf = root_css_buf;
15262 data.markov_css_buf = markov_css_buf;
15263
15264 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15265
15266 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15267
15268 local_free (root_table_buf);
15269 local_free (markov_table_buf);
15270
15271 // args
15272
15273 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15274 {
15275 hc_device_param_t *device_param = &data.devices_param[device_id];
15276
15277 device_param->kernel_params_mp[0] = &device_param->d_combs;
15278 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15279 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15280
15281 device_param->kernel_params_mp_buf64[3] = 0;
15282 device_param->kernel_params_mp_buf32[4] = css_cnt;
15283 device_param->kernel_params_mp_buf32[5] = 0;
15284 device_param->kernel_params_mp_buf32[6] = 0;
15285 device_param->kernel_params_mp_buf32[7] = 0;
15286
15287 if (attack_mode == ATTACK_MODE_HYBRID1)
15288 {
15289 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15290 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15291 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15292 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15293 }
15294 else if (attack_mode == ATTACK_MODE_HYBRID2)
15295 {
15296 device_param->kernel_params_mp_buf32[5] = 0;
15297 device_param->kernel_params_mp_buf32[6] = 0;
15298 device_param->kernel_params_mp_buf32[7] = 0;
15299 }
15300
15301 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp[i]);
15302 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp[i]);
15303 for (uint i = 4; i < 8; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp[i]);
15304
15305 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);
15306 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);
15307 }
15308 }
15309 else if (attack_mode == ATTACK_MODE_BF)
15310 {
15311 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15312
15313 if (increment)
15314 {
15315 for (uint i = 0; i < dictcnt; i++)
15316 {
15317 local_free (dictfiles[i]);
15318 }
15319
15320 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15321 {
15322 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15323
15324 if (l1_filename == NULL) break;
15325
15326 dictcnt++;
15327
15328 dictfiles[dictcnt - 1] = l1_filename;
15329 }
15330 }
15331 else
15332 {
15333 dictcnt++;
15334
15335 dictfiles[dictcnt - 1] = mask;
15336 }
15337
15338 if (dictcnt == 0)
15339 {
15340 log_error ("ERROR: Mask is too small");
15341
15342 return (-1);
15343 }
15344 }
15345 }
15346
15347 free (induction_dictionaries);
15348
15349 // induction_dictionaries_cnt = 0; // implied
15350
15351 if (attack_mode != ATTACK_MODE_BF)
15352 {
15353 if (keyspace == 0)
15354 {
15355 induction_dictionaries = scan_directory (induction_directory);
15356
15357 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15358 }
15359 }
15360
15361 if (induction_dictionaries_cnt)
15362 {
15363 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15364 }
15365
15366 /**
15367 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15368 */
15369 if (keyspace == 1)
15370 {
15371 if ((maskcnt > 1) || (dictcnt > 1))
15372 {
15373 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15374
15375 return (-1);
15376 }
15377 }
15378
15379 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15380 {
15381 char *subid = logfile_generate_subid ();
15382
15383 data.subid = subid;
15384
15385 logfile_sub_msg ("START");
15386
15387 data.devices_status = STATUS_INIT;
15388
15389 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (uint64_t));
15390 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (uint64_t));
15391 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (uint64_t));
15392
15393 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15394
15395 data.cpt_pos = 0;
15396
15397 data.cpt_start = time (NULL);
15398
15399 data.cpt_total = 0;
15400
15401 if (data.restore == 0)
15402 {
15403 rd->words_cur = skip;
15404
15405 skip = 0;
15406
15407 data.skip = 0;
15408 }
15409
15410 data.ms_paused = 0;
15411
15412 data.words_cur = rd->words_cur;
15413
15414 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15415 {
15416 hc_device_param_t *device_param = &data.devices_param[device_id];
15417
15418 device_param->speed_pos = 0;
15419
15420 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (uint64_t));
15421 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15422 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15423
15424 device_param->kernel_power = device_param->kernel_power_user;
15425 device_param->kernel_blocks = device_param->kernel_blocks_user;
15426
15427 device_param->outerloop_pos = 0;
15428 device_param->outerloop_left = 0;
15429 device_param->innerloop_pos = 0;
15430 device_param->innerloop_left = 0;
15431
15432 // some more resets:
15433
15434 memset (device_param->pw_caches, 0, 64 * sizeof (pw_cache_t));
15435
15436 memset (device_param->pws_buf, 0, device_param->size_pws);
15437
15438 device_param->pw_cnt = 0;
15439 device_param->pws_cnt = 0;
15440
15441 device_param->words_off = 0;
15442 device_param->words_done = 0;
15443 }
15444
15445 data.kernel_blocks_div = 0;
15446
15447 // figure out some workload
15448
15449 if (attack_mode == ATTACK_MODE_STRAIGHT)
15450 {
15451 if (data.wordlist_mode == WL_MODE_FILE)
15452 {
15453 char *dictfile = NULL;
15454
15455 if (induction_dictionaries_cnt)
15456 {
15457 dictfile = induction_dictionaries[0];
15458 }
15459 else
15460 {
15461 dictfile = dictfiles[dictpos];
15462 }
15463
15464 data.dictfile = dictfile;
15465
15466 logfile_sub_string (dictfile);
15467
15468 for (uint i = 0; i < rp_files_cnt; i++)
15469 {
15470 logfile_sub_var_string ("rulefile", rp_files[i]);
15471 }
15472
15473 FILE *fd2 = fopen (dictfile, "rb");
15474
15475 if (fd2 == NULL)
15476 {
15477 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15478
15479 return (-1);
15480 }
15481
15482 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15483
15484 fclose (fd2);
15485
15486 if (data.words_cnt == 0)
15487 {
15488 if (data.devices_status == STATUS_CRACKED) break;
15489 if (data.devices_status == STATUS_ABORTED) break;
15490
15491 dictpos++;
15492
15493 continue;
15494 }
15495 }
15496 }
15497 else if (attack_mode == ATTACK_MODE_COMBI)
15498 {
15499 char *dictfile = data.dictfile;
15500 char *dictfile2 = data.dictfile2;
15501
15502 logfile_sub_string (dictfile);
15503 logfile_sub_string (dictfile2);
15504
15505 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
15506 {
15507 FILE *fd2 = fopen (dictfile, "rb");
15508
15509 if (fd2 == NULL)
15510 {
15511 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15512
15513 return (-1);
15514 }
15515
15516 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15517
15518 fclose (fd2);
15519 }
15520 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
15521 {
15522 FILE *fd2 = fopen (dictfile2, "rb");
15523
15524 if (fd2 == NULL)
15525 {
15526 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15527
15528 return (-1);
15529 }
15530
15531 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
15532
15533 fclose (fd2);
15534 }
15535
15536 if (data.words_cnt == 0)
15537 {
15538 if (data.devices_status == STATUS_CRACKED) break;
15539 if (data.devices_status == STATUS_ABORTED) break;
15540
15541 dictpos++;
15542
15543 continue;
15544 }
15545 }
15546 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15547 {
15548 char *dictfile = NULL;
15549
15550 if (induction_dictionaries_cnt)
15551 {
15552 dictfile = induction_dictionaries[0];
15553 }
15554 else
15555 {
15556 dictfile = dictfiles[dictpos];
15557 }
15558
15559 data.dictfile = dictfile;
15560
15561 char *mask = data.mask;
15562
15563 logfile_sub_string (dictfile);
15564 logfile_sub_string (mask);
15565
15566 FILE *fd2 = fopen (dictfile, "rb");
15567
15568 if (fd2 == NULL)
15569 {
15570 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15571
15572 return (-1);
15573 }
15574
15575 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15576
15577 fclose (fd2);
15578
15579 if (data.words_cnt == 0)
15580 {
15581 if (data.devices_status == STATUS_CRACKED) break;
15582 if (data.devices_status == STATUS_ABORTED) break;
15583
15584 dictpos++;
15585
15586 continue;
15587 }
15588 }
15589 else if (attack_mode == ATTACK_MODE_BF)
15590 {
15591 local_free (css_buf);
15592 local_free (data.root_css_buf);
15593 local_free (data.markov_css_buf);
15594
15595 char *mask = dictfiles[dictpos];
15596
15597 logfile_sub_string (mask);
15598
15599 // base
15600
15601 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15602
15603 if (opts_type & OPTS_TYPE_PT_UNICODE)
15604 {
15605 uint css_cnt_unicode = css_cnt * 2;
15606
15607 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
15608
15609 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
15610 {
15611 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
15612
15613 css_buf_unicode[j + 1].cs_buf[0] = 0;
15614 css_buf_unicode[j + 1].cs_len = 1;
15615 }
15616
15617 free (css_buf);
15618
15619 css_buf = css_buf_unicode;
15620 css_cnt = css_cnt_unicode;
15621 }
15622
15623 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
15624
15625 uint mask_min = pw_min;
15626 uint mask_max = pw_max;
15627
15628 if (opts_type & OPTS_TYPE_PT_UNICODE)
15629 {
15630 mask_min *= 2;
15631 mask_max *= 2;
15632 }
15633
15634 if ((css_cnt < mask_min) || (css_cnt > mask_max))
15635 {
15636 if (css_cnt < mask_min)
15637 {
15638 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
15639 }
15640
15641 if (css_cnt > mask_max)
15642 {
15643 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
15644 }
15645
15646 // skip to next mask
15647
15648 dictpos++;
15649
15650 rd->dictpos = dictpos;
15651
15652 logfile_sub_msg ("STOP");
15653
15654 continue;
15655 }
15656
15657 uint save_css_cnt = css_cnt;
15658
15659 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15660 {
15661 if (opti_type & OPTI_TYPE_APPENDED_SALT)
15662 {
15663 uint salt_len = (uint) data.salts_buf[0].salt_len;
15664 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
15665
15666 uint css_cnt_salt = css_cnt + salt_len;
15667
15668 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
15669
15670 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
15671
15672 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
15673 {
15674 css_buf_salt[j].cs_buf[0] = salt_buf[i];
15675 css_buf_salt[j].cs_len = 1;
15676 }
15677
15678 free (css_buf);
15679
15680 css_buf = css_buf_salt;
15681 css_cnt = css_cnt_salt;
15682 }
15683 }
15684
15685 data.mask = mask;
15686 data.css_cnt = css_cnt;
15687 data.css_buf = css_buf;
15688
15689 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
15690
15691 uint uniq_tbls[SP_PW_MAX][CHARSIZ];
15692
15693 memset (uniq_tbls, 0, sizeof (uniq_tbls));
15694
15695 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15696
15697 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15698 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15699
15700 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15701
15702 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15703
15704 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15705 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15706
15707 data.root_css_buf = root_css_buf;
15708 data.markov_css_buf = markov_css_buf;
15709
15710 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15711
15712 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15713
15714 local_free (root_table_buf);
15715 local_free (markov_table_buf);
15716
15717 // copy + args
15718
15719 uint css_cnt_l = css_cnt;
15720 uint css_cnt_r;
15721
15722 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15723 {
15724 if (save_css_cnt < 6)
15725 {
15726 css_cnt_r = 1;
15727 }
15728 else if (save_css_cnt == 6)
15729 {
15730 css_cnt_r = 2;
15731 }
15732 else
15733 {
15734 if (opts_type & OPTS_TYPE_PT_UNICODE)
15735 {
15736 if (save_css_cnt == 8 || save_css_cnt == 10)
15737 {
15738 css_cnt_r = 2;
15739 }
15740 else
15741 {
15742 css_cnt_r = 4;
15743 }
15744 }
15745 else
15746 {
15747 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
15748 {
15749 css_cnt_r = 3;
15750 }
15751 else
15752 {
15753 css_cnt_r = 4;
15754 }
15755 }
15756 }
15757 }
15758 else
15759 {
15760 css_cnt_r = 1;
15761
15762 /* unfinished code?
15763 int sum = css_buf[css_cnt_r - 1].cs_len;
15764
15765 for (uint i = 1; i < 4 && i < css_cnt; i++)
15766 {
15767 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
15768
15769 css_cnt_r++;
15770
15771 sum *= css_buf[css_cnt_r - 1].cs_len;
15772 }
15773 */
15774 }
15775
15776 css_cnt_l -= css_cnt_r;
15777
15778 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
15779
15780 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15781 {
15782 hc_device_param_t *device_param = &data.devices_param[device_id];
15783
15784 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
15785 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
15786 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
15787
15788 device_param->kernel_params_mp_l_buf64[3] = 0;
15789 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
15790 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
15791 device_param->kernel_params_mp_l_buf32[6] = 0;
15792 device_param->kernel_params_mp_l_buf32[7] = 0;
15793 device_param->kernel_params_mp_l_buf32[8] = 0;
15794
15795 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
15796 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
15797 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
15798 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
15799
15800 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
15801 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
15802 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
15803
15804 device_param->kernel_params_mp_r_buf64[3] = 0;
15805 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
15806 device_param->kernel_params_mp_r_buf32[5] = 0;
15807 device_param->kernel_params_mp_r_buf32[6] = 0;
15808 device_param->kernel_params_mp_r_buf32[7] = 0;
15809
15810 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]);
15811 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]);
15812 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]);
15813
15814 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]);
15815 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]);
15816 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]);
15817
15818 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);
15819 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);
15820 }
15821 }
15822
15823 uint64_t words_base = data.words_cnt;
15824
15825 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
15826 {
15827 if (data.kernel_rules_cnt)
15828 {
15829 words_base /= data.kernel_rules_cnt;
15830 }
15831 }
15832 else if (data.attack_kern == ATTACK_KERN_COMBI)
15833 {
15834 if (data.combs_cnt)
15835 {
15836 words_base /= data.combs_cnt;
15837 }
15838 }
15839 else if (data.attack_kern == ATTACK_KERN_BF)
15840 {
15841 if (data.bfs_cnt)
15842 {
15843 words_base /= data.bfs_cnt;
15844 }
15845 }
15846
15847 data.words_base = words_base;
15848
15849 if (keyspace == 1)
15850 {
15851 log_info ("%llu", (unsigned long long int) words_base);
15852
15853 return (0);
15854 }
15855
15856 if (data.words_cur > data.words_base)
15857 {
15858 log_error ("ERROR: restore value greater keyspace");
15859
15860 return (-1);
15861 }
15862
15863 if (data.words_cur)
15864 {
15865 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
15866 {
15867 for (uint i = 0; i < data.salts_cnt; i++)
15868 {
15869 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
15870 }
15871 }
15872 else if (data.attack_kern == ATTACK_KERN_COMBI)
15873 {
15874 for (uint i = 0; i < data.salts_cnt; i++)
15875 {
15876 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
15877 }
15878 }
15879 else if (data.attack_kern == ATTACK_KERN_BF)
15880 {
15881 for (uint i = 0; i < data.salts_cnt; i++)
15882 {
15883 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
15884 }
15885 }
15886 }
15887
15888 /*
15889 * Inform user about possible slow speeds
15890 */
15891
15892 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
15893 {
15894 if (data.words_base < kernel_blocks_all)
15895 {
15896 if (quiet == 0)
15897 {
15898 log_info ("");
15899 log_info ("ATTENTION!");
15900 log_info (" The wordlist or mask you are using is too small.");
15901 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
15902 log_info (" The cracking speed will drop.");
15903 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
15904 log_info ("");
15905 }
15906 }
15907 }
15908
15909 /*
15910 * Update loopback file
15911 */
15912
15913 if (loopback == 1)
15914 {
15915 time_t now;
15916
15917 time (&now);
15918
15919 uint random_num = get_random_num (0, 9999);
15920
15921 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
15922
15923 data.loopback_file = loopback_file;
15924 }
15925
15926 /*
15927 * Update dictionary statistic
15928 */
15929
15930 if (keyspace == 0)
15931 {
15932 dictstat_fp = fopen (dictstat, "wb");
15933
15934 if (dictstat_fp)
15935 {
15936 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
15937
15938 fclose (dictstat_fp);
15939 }
15940 }
15941
15942 data.devices_status = STATUS_RUNNING;
15943
15944 if (initial_restore_done == 0)
15945 {
15946 if (data.restore_disable == 0) cycle_restore ();
15947
15948 initial_restore_done = 1;
15949 }
15950
15951 hc_timer_set (&data.timer_running);
15952
15953 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
15954 {
15955 if ((quiet == 0) && (status == 0) && (benchmark == 0))
15956 {
15957 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
15958 if (quiet == 0) fflush (stdout);
15959 }
15960 }
15961 else if (wordlist_mode == WL_MODE_STDIN)
15962 {
15963 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
15964 if (data.quiet == 0) log_info ("");
15965 }
15966
15967 time_t runtime_start;
15968
15969 time (&runtime_start);
15970
15971 data.runtime_start = runtime_start;
15972
15973 /**
15974 * create cracker threads
15975 */
15976
15977 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (devices_cnt, sizeof (hc_thread_t));
15978
15979 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15980 {
15981 hc_device_param_t *device_param = &devices_param[device_id];
15982
15983 device_param->device_id = device_id;
15984
15985 if (wordlist_mode == WL_MODE_STDIN)
15986 {
15987 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
15988 }
15989 else
15990 {
15991 hc_thread_create (c_threads[device_id], thread_calc, device_param);
15992 }
15993 }
15994
15995 // wait for crack threads to exit
15996
15997 hc_thread_wait (devices_cnt, c_threads);
15998
15999 local_free (c_threads);
16000
16001 data.restore = 0;
16002
16003 // finalize task
16004
16005 logfile_sub_var_uint ("status-after-work", data.devices_status);
16006
16007 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16008
16009 if (data.devices_status == STATUS_CRACKED) break;
16010 if (data.devices_status == STATUS_ABORTED) break;
16011
16012 if (data.devices_status == STATUS_BYPASS)
16013 {
16014 data.devices_status = STATUS_RUNNING;
16015 }
16016
16017 if (induction_dictionaries_cnt)
16018 {
16019 unlink (induction_dictionaries[0]);
16020 }
16021
16022 free (induction_dictionaries);
16023
16024 if (attack_mode != ATTACK_MODE_BF)
16025 {
16026 induction_dictionaries = scan_directory (induction_directory);
16027
16028 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16029 }
16030
16031 if (benchmark == 0)
16032 {
16033 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16034 {
16035 if (quiet == 0) clear_prompt ();
16036
16037 if (quiet == 0) log_info ("");
16038
16039 if (status == 1)
16040 {
16041 status_display ();
16042 }
16043 else
16044 {
16045 if (quiet == 0) status_display ();
16046 }
16047
16048 if (quiet == 0) log_info ("");
16049 }
16050 }
16051
16052 if (attack_mode == ATTACK_MODE_BF)
16053 {
16054 dictpos++;
16055
16056 rd->dictpos = dictpos;
16057 }
16058 else
16059 {
16060 if (induction_dictionaries_cnt)
16061 {
16062 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16063 }
16064 else
16065 {
16066 dictpos++;
16067
16068 rd->dictpos = dictpos;
16069 }
16070 }
16071
16072 time_t runtime_stop;
16073
16074 time (&runtime_stop);
16075
16076 data.runtime_stop = runtime_stop;
16077
16078 logfile_sub_uint (runtime_start);
16079 logfile_sub_uint (runtime_stop);
16080
16081 logfile_sub_msg ("STOP");
16082
16083 global_free (subid);
16084 }
16085
16086 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16087
16088 if (data.devices_status == STATUS_CRACKED) break;
16089 if (data.devices_status == STATUS_ABORTED) break;
16090 if (data.devices_status == STATUS_QUIT) break;
16091
16092 if (data.devices_status == STATUS_BYPASS)
16093 {
16094 data.devices_status = STATUS_RUNNING;
16095 }
16096 }
16097
16098 // 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
16099
16100 if (attack_mode == ATTACK_MODE_STRAIGHT)
16101 {
16102 if (data.wordlist_mode == WL_MODE_FILE)
16103 {
16104 if (data.dictfile == NULL)
16105 {
16106 if (dictfiles != NULL)
16107 {
16108 data.dictfile = dictfiles[0];
16109
16110 hc_timer_set (&data.timer_running);
16111 }
16112 }
16113 }
16114 }
16115 // NOTE: combi is okay because it is already set beforehand
16116 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16117 {
16118 if (data.dictfile == NULL)
16119 {
16120 if (dictfiles != NULL)
16121 {
16122 hc_timer_set (&data.timer_running);
16123
16124 data.dictfile = dictfiles[0];
16125 }
16126 }
16127 }
16128 else if (attack_mode == ATTACK_MODE_BF)
16129 {
16130 if (data.mask == NULL)
16131 {
16132 hc_timer_set (&data.timer_running);
16133
16134 data.mask = masks[0];
16135 }
16136 }
16137
16138 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16139 {
16140 data.devices_status = STATUS_EXHAUSTED;
16141 }
16142
16143 // if cracked / aborted remove last induction dictionary
16144
16145 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16146 {
16147 struct stat induct_stat;
16148
16149 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16150 {
16151 unlink (induction_dictionaries[file_pos]);
16152 }
16153 }
16154
16155 // wait for non-interactive threads
16156
16157 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16158 {
16159 hc_thread_wait (1, &ni_threads[thread_idx]);
16160 }
16161
16162 local_free (ni_threads);
16163
16164 // wait for interactive threads
16165
16166 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16167 {
16168 hc_thread_wait (1, &i_thread);
16169 }
16170
16171 // we dont need restore file anymore
16172 if (data.restore_disable == 0)
16173 {
16174 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16175 {
16176 unlink (eff_restore_file);
16177 unlink (new_restore_file);
16178 }
16179 else
16180 {
16181 cycle_restore ();
16182 }
16183 }
16184
16185 // finally save left hashes
16186
16187 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16188 {
16189 save_hash ();
16190 }
16191
16192 /**
16193 * Clean up
16194 */
16195
16196 if (benchmark == 1)
16197 {
16198 status_benchmark ();
16199
16200 log_info ("");
16201 }
16202 else
16203 {
16204 if (quiet == 0) clear_prompt ();
16205
16206 if (quiet == 0) log_info ("");
16207
16208 if (status == 1)
16209 {
16210 status_display ();
16211 }
16212 else
16213 {
16214 if (quiet == 0) status_display ();
16215 }
16216
16217 if (quiet == 0) log_info ("");
16218 }
16219
16220 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16221 {
16222 hc_device_param_t *device_param = &data.devices_param[device_id];
16223
16224 local_free (device_param->result);
16225
16226 local_free (device_param->pw_caches);
16227
16228 local_free (device_param->combs_buf);
16229
16230 local_free (device_param->hooks_buf);
16231
16232 local_free (device_param->device_name);
16233
16234 local_free (device_param->device_name_chksum);
16235
16236 local_free (device_param->device_version);
16237
16238 local_free (device_param->driver_version);
16239
16240 if (device_param->pws_buf) myfree (device_param->pws_buf);
16241 if (device_param->d_pws_buf) hc_clReleaseMemObject (device_param->d_pws_buf);
16242 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (device_param->d_pws_amp_buf);
16243 if (device_param->d_rules) hc_clReleaseMemObject (device_param->d_rules);
16244 if (device_param->d_rules_c) hc_clReleaseMemObject (device_param->d_rules_c);
16245 if (device_param->d_combs) hc_clReleaseMemObject (device_param->d_combs);
16246 if (device_param->d_combs_c) hc_clReleaseMemObject (device_param->d_combs_c);
16247 if (device_param->d_bfs) hc_clReleaseMemObject (device_param->d_bfs);
16248 if (device_param->d_bfs_c) hc_clReleaseMemObject (device_param->d_bfs_c);
16249 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (device_param->d_bitmap_s1_a);
16250 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (device_param->d_bitmap_s1_b);
16251 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (device_param->d_bitmap_s1_c);
16252 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (device_param->d_bitmap_s1_d);
16253 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (device_param->d_bitmap_s2_a);
16254 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (device_param->d_bitmap_s2_b);
16255 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (device_param->d_bitmap_s2_c);
16256 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (device_param->d_bitmap_s2_d);
16257 if (device_param->d_plain_bufs) hc_clReleaseMemObject (device_param->d_plain_bufs);
16258 if (device_param->d_digests_buf) hc_clReleaseMemObject (device_param->d_digests_buf);
16259 if (device_param->d_digests_shown) hc_clReleaseMemObject (device_param->d_digests_shown);
16260 if (device_param->d_salt_bufs) hc_clReleaseMemObject (device_param->d_salt_bufs);
16261 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (device_param->d_esalt_bufs);
16262 if (device_param->d_tmps) hc_clReleaseMemObject (device_param->d_tmps);
16263 if (device_param->d_hooks) hc_clReleaseMemObject (device_param->d_hooks);
16264 if (device_param->d_result) hc_clReleaseMemObject (device_param->d_result);
16265 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (device_param->d_scryptV_buf);
16266 if (device_param->d_root_css_buf) hc_clReleaseMemObject (device_param->d_root_css_buf);
16267 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (device_param->d_markov_css_buf);
16268 if (device_param->d_tm_c) hc_clReleaseMemObject (device_param->d_tm_c);
16269
16270 if (device_param->kernel1) hc_clReleaseKernel (device_param->kernel1);
16271 if (device_param->kernel12) hc_clReleaseKernel (device_param->kernel12);
16272 if (device_param->kernel2) hc_clReleaseKernel (device_param->kernel2);
16273 if (device_param->kernel23) hc_clReleaseKernel (device_param->kernel23);
16274 if (device_param->kernel3) hc_clReleaseKernel (device_param->kernel3);
16275 if (device_param->kernel_mp) hc_clReleaseKernel (device_param->kernel_mp);
16276 if (device_param->kernel_mp_l) hc_clReleaseKernel (device_param->kernel_mp_l);
16277 if (device_param->kernel_mp_r) hc_clReleaseKernel (device_param->kernel_mp_r);
16278 if (device_param->kernel_tb) hc_clReleaseKernel (device_param->kernel_tb);
16279 if (device_param->kernel_tm) hc_clReleaseKernel (device_param->kernel_tm);
16280 if (device_param->kernel_amp) hc_clReleaseKernel (device_param->kernel_amp);
16281
16282 if (device_param->program) hc_clReleaseProgram (device_param->program);
16283 if (device_param->program_mp) hc_clReleaseProgram (device_param->program_mp);
16284 if (device_param->program_amp) hc_clReleaseProgram (device_param->program_amp);
16285 if (device_param->command_queue) hc_clReleaseCommandQueue (device_param->command_queue);
16286 if (device_param->context) hc_clReleaseContext (device_param->context);
16287 }
16288
16289 // reset default fan speed
16290
16291 if (gpu_temp_disable == 0)
16292 {
16293 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16294 {
16295 hc_thread_mutex_lock (mux_adl);
16296
16297 for (uint i = 0; i < data.devices_cnt; i++)
16298 {
16299 if (data.hm_device[i].fan_supported == 1)
16300 {
16301 int fanspeed = temp_retain_fanspeed_value[i];
16302
16303 if (fanspeed == -1) continue;
16304
16305 int rc = hm_set_fanspeed_with_device_id_amd (i, fanspeed);
16306
16307 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", i);
16308 }
16309 }
16310
16311 hc_thread_mutex_unlock (mux_adl);
16312 }
16313 }
16314
16315 // reset power tuning
16316
16317 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16318 {
16319 hc_thread_mutex_lock (mux_adl);
16320
16321 for (uint i = 0; i < data.devices_cnt; i++)
16322 {
16323 if (data.hm_device[i].od_version == 6)
16324 {
16325 // check powertune capabilities first, if not available then skip device
16326
16327 int powertune_supported = 0;
16328
16329 if ((hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll, data.hm_device[i].adapter_index.amd, &powertune_supported)) != ADL_OK)
16330 {
16331 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16332
16333 return (-1);
16334 }
16335
16336 if (powertune_supported != 0)
16337 {
16338 // powercontrol settings
16339
16340 if ((hc_ADL_Overdrive_PowerControl_Set (data.hm_dll, data.hm_device[i].adapter_index.amd, od_power_control_status[i])) != ADL_OK)
16341 {
16342 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16343
16344 return (-1);
16345 }
16346
16347 // clocks
16348
16349 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16350
16351 performance_state->iNumberOfPerformanceLevels = 2;
16352
16353 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[i].state.aLevels[0].iEngineClock;
16354 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[i].state.aLevels[1].iEngineClock;
16355 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[i].state.aLevels[0].iMemoryClock;
16356 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[i].state.aLevels[1].iMemoryClock;
16357
16358 if ((hc_ADL_Overdrive_State_Set (data.hm_dll, data.hm_device[i].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
16359 {
16360 log_info ("ERROR: Failed to restore ADL performance state");
16361
16362 return (-1);
16363 }
16364
16365 local_free (performance_state);
16366 }
16367 }
16368 }
16369
16370 hc_thread_mutex_unlock (mux_adl);
16371 }
16372
16373 if (gpu_temp_disable == 0)
16374 {
16375 if (vendor_id == VENDOR_ID_NV)
16376 {
16377 #ifdef LINUX
16378 hc_NVML_nvmlShutdown (data.hm_dll);
16379 #endif
16380
16381 #ifdef WIN
16382 NvAPI_Unload ();
16383 #endif
16384 }
16385
16386 if (vendor_id == VENDOR_ID_AMD)
16387 {
16388 hc_ADL_Main_Control_Destroy (data.hm_dll);
16389
16390 hm_close (data.hm_dll);
16391 }
16392
16393 #ifdef LINUX
16394 if (vendor_id == VENDOR_ID_NV)
16395 {
16396 hm_close (data.hm_dll);
16397 }
16398 #endif
16399 }
16400
16401 // free memory
16402
16403 local_free (masks);
16404
16405 local_free (dictstat_base);
16406
16407 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16408 {
16409 pot_t *pot_ptr = &pot[pot_pos];
16410
16411 hash_t *hash = &pot_ptr->hash;
16412
16413 local_free (hash->digest);
16414
16415 if (isSalted)
16416 {
16417 local_free (hash->salt);
16418 }
16419 }
16420
16421 local_free (pot);
16422
16423 local_free (all_kernel_rules_cnt);
16424 local_free (all_kernel_rules_buf);
16425
16426 local_free (wl_data->buf);
16427 local_free (wl_data);
16428
16429 local_free (bitmap_s1_a);
16430 local_free (bitmap_s1_b);
16431 local_free (bitmap_s1_c);
16432 local_free (bitmap_s1_d);
16433 local_free (bitmap_s2_a);
16434 local_free (bitmap_s2_b);
16435 local_free (bitmap_s2_c);
16436 local_free (bitmap_s2_d);
16437
16438 local_free (temp_retain_fanspeed_value);
16439 local_free (od_clock_mem_status);
16440 local_free (od_power_control_status);
16441
16442 global_free (devices_param);
16443
16444 global_free (kernel_rules_buf);
16445
16446 global_free (root_css_buf);
16447 global_free (markov_css_buf);
16448
16449 global_free (digests_buf);
16450 global_free (digests_shown);
16451 global_free (digests_shown_tmp);
16452
16453 global_free (salts_buf);
16454 global_free (salts_shown);
16455
16456 global_free (esalts_buf);
16457
16458 global_free (words_progress_done);
16459 global_free (words_progress_rejected);
16460 global_free (words_progress_restored);
16461
16462 if (pot_fp) fclose (pot_fp);
16463
16464 if (data.devices_status == STATUS_QUIT) break;
16465 }
16466
16467 // destroy others mutex
16468
16469 hc_thread_mutex_delete (mux_dispatcher);
16470 hc_thread_mutex_delete (mux_counter);
16471 hc_thread_mutex_delete (mux_display);
16472 hc_thread_mutex_delete (mux_adl);
16473
16474 // free memory
16475
16476 local_free (eff_restore_file);
16477 local_free (new_restore_file);
16478
16479 local_free (rd);
16480
16481 // loopback
16482
16483 local_free (loopback_file);
16484
16485 if (loopback == 1) unlink (loopback_file);
16486
16487 // induction directory
16488
16489 if (induction_dir == NULL)
16490 {
16491 if (attack_mode != ATTACK_MODE_BF)
16492 {
16493 if (rmdir (induction_directory) == -1)
16494 {
16495 if (errno == ENOENT)
16496 {
16497 // good, we can ignore
16498 }
16499 else if (errno == ENOTEMPTY)
16500 {
16501 // good, we can ignore
16502 }
16503 else
16504 {
16505 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
16506
16507 return (-1);
16508 }
16509 }
16510
16511 local_free (induction_directory);
16512 }
16513 }
16514
16515 // outfile-check directory
16516
16517 if (outfile_check_dir == NULL)
16518 {
16519 if (rmdir (outfile_check_directory) == -1)
16520 {
16521 if (errno == ENOENT)
16522 {
16523 // good, we can ignore
16524 }
16525 else if (errno == ENOTEMPTY)
16526 {
16527 // good, we can ignore
16528 }
16529 else
16530 {
16531 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
16532
16533 return (-1);
16534 }
16535 }
16536
16537 local_free (outfile_check_directory);
16538 }
16539
16540 time_t proc_stop;
16541
16542 time (&proc_stop);
16543
16544 logfile_top_uint (proc_start);
16545 logfile_top_uint (proc_stop);
16546
16547 logfile_top_msg ("STOP");
16548
16549 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
16550 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
16551
16552 if (data.devices_status == STATUS_ABORTED) return 2;
16553 if (data.devices_status == STATUS_QUIT) return 2;
16554 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
16555 if (data.devices_status == STATUS_EXHAUSTED) return 1;
16556 if (data.devices_status == STATUS_CRACKED) return 0;
16557
16558 return -1;
16559 }
Hashcat additions to support pwdhash