projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
The weak-hash-check feature didn't work for algorithms that made use of some automati...
[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 case KERN_RUN_WEAK: kernel = device_param->kernel_weak; break;
2347 }
2348
2349 hc_clSetKernelArg (kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2350 hc_clSetKernelArg (kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2351 hc_clSetKernelArg (kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2352 hc_clSetKernelArg (kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2353 hc_clSetKernelArg (kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2354 hc_clSetKernelArg (kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2355 hc_clSetKernelArg (kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2356 hc_clSetKernelArg (kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2357 hc_clSetKernelArg (kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2358 hc_clSetKernelArg (kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2359 hc_clSetKernelArg (kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2360
2361 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2362 {
2363 const size_t global_work_size[3] = { num_elements, 32, 1 };
2364 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2365
2366 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2367 }
2368 else
2369 {
2370 const size_t global_work_size[3] = { num_elements, 1, 1 };
2371 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2372
2373 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2374 }
2375
2376 hc_clFlush (device_param->command_queue);
2377
2378 hc_clFinish (device_param->command_queue);
2379 }
2380
2381 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2382 {
2383 uint num_elements = num;
2384
2385 switch (kern_run)
2386 {
2387 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2388 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2389 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2390 }
2391
2392 // causes problems with special threads like in bcrypt
2393 // const uint kernel_threads = device_param->kernel_threads;
2394
2395 const uint kernel_threads = KERNEL_THREADS;
2396
2397 while (num_elements % kernel_threads) num_elements++;
2398
2399 cl_kernel kernel = NULL;
2400
2401 switch (kern_run)
2402 {
2403 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2404 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2405 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2406 }
2407
2408 switch (kern_run)
2409 {
2410 case KERN_RUN_MP: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2411 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2412 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2413 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2414 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2415 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2416 break;
2417 case KERN_RUN_MP_R: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2418 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2419 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2420 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2421 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2422 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2423 break;
2424 case KERN_RUN_MP_L: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2425 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2426 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2427 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2428 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2429 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2430 hc_clSetKernelArg (kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2431 break;
2432 }
2433
2434 const size_t global_work_size[3] = { num_elements, 1, 1 };
2435 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2436
2437 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2438
2439 hc_clFlush (device_param->command_queue);
2440
2441 hc_clFinish (device_param->command_queue);
2442 }
2443
2444 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2445 {
2446 uint num_elements = num;
2447
2448 uint kernel_threads = device_param->kernel_threads;
2449
2450 while (num_elements % kernel_threads) num_elements++;
2451
2452 cl_kernel kernel = device_param->kernel_tb;
2453
2454 const size_t global_work_size[3] = { num_elements, 1, 1 };
2455 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2456
2457 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2458
2459 hc_clFlush (device_param->command_queue);
2460
2461 hc_clFinish (device_param->command_queue);
2462 }
2463
2464 static void run_kernel_tm (hc_device_param_t *device_param)
2465 {
2466 const uint num_elements = 1024; // fixed
2467
2468 const uint kernel_threads = 32;
2469
2470 cl_kernel kernel = device_param->kernel_tm;
2471
2472 const size_t global_work_size[3] = { num_elements, 1, 1 };
2473 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2474
2475 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2476
2477 hc_clFlush (device_param->command_queue);
2478
2479 hc_clFinish (device_param->command_queue);
2480 }
2481
2482 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2483 {
2484 uint num_elements = num;
2485
2486 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2487 device_param->kernel_params_amp_buf32[6] = num_elements;
2488
2489 // causes problems with special threads like in bcrypt
2490 // const uint kernel_threads = device_param->kernel_threads;
2491
2492 const uint kernel_threads = KERNEL_THREADS;
2493
2494 while (num_elements % kernel_threads) num_elements++;
2495
2496 cl_kernel kernel = device_param->kernel_amp;
2497
2498 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2499 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2500
2501 const size_t global_work_size[3] = { num_elements, 1, 1 };
2502 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2503
2504 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2505
2506 hc_clFlush (device_param->command_queue);
2507
2508 hc_clFinish (device_param->command_queue);
2509 }
2510
2511 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2512 {
2513 if (data.vendor_id == VENDOR_ID_AMD)
2514 {
2515 const cl_uchar zero = 0;
2516
2517 hc_clEnqueueFillBuffer (device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2518 }
2519
2520 if (data.vendor_id == VENDOR_ID_NV)
2521 {
2522 // NOTE: clEnqueueFillBuffer () always fails with -59
2523 // IOW, it's not supported by Nvidia ForceWare <= 352.21,
2524 // How's that possible, OpenCL 1.2 support is advertised??
2525 // We need to workaround...
2526
2527 #define FILLSZ 0x100000
2528
2529 char *tmp = (char *) mymalloc (FILLSZ);
2530
2531 memset (tmp, 0, FILLSZ);
2532
2533 for (uint i = 0; i < size; i += FILLSZ)
2534 {
2535 const int left = size - i;
2536
2537 const int fillsz = MIN (FILLSZ, left);
2538
2539 hc_clEnqueueWriteBuffer (device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2540 }
2541
2542 myfree (tmp);
2543 }
2544
2545 if (data.vendor_id == VENDOR_ID_GENERIC)
2546 {
2547 const cl_uchar zero = 0;
2548
2549 hc_clEnqueueFillBuffer (device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2550 }
2551 }
2552
2553 static int run_rule_engine (const int rule_len, const char *rule_buf)
2554 {
2555 if (rule_len == 0)
2556 {
2557 return 0;
2558 }
2559 else if (rule_len == 1)
2560 {
2561 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2562 }
2563
2564 return 1;
2565 }
2566
2567 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2568 {
2569 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2570 {
2571 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);
2572 }
2573 else if (data.attack_kern == ATTACK_KERN_COMBI)
2574 {
2575 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);
2576 }
2577 else if (data.attack_kern == ATTACK_KERN_BF)
2578 {
2579 const uint64_t off = device_param->words_off;
2580
2581 device_param->kernel_params_mp_l_buf64[3] = off;
2582
2583 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2584 }
2585 }
2586
2587 static void run_cracker (hc_device_param_t *device_param, const uint pw_cnt, const uint pws_cnt)
2588 {
2589 const uint kernel_loops = data.kernel_loops;
2590
2591 // init speed timer
2592
2593 uint speed_pos = device_param->speed_pos;
2594
2595 #ifdef _POSIX
2596 if (device_param->timer_speed.tv_sec == 0)
2597 {
2598 hc_timer_set (&device_param->timer_speed);
2599 }
2600 #endif
2601
2602 #ifdef _WIN
2603 if (device_param->timer_speed.QuadPart == 0)
2604 {
2605 hc_timer_set (&device_param->timer_speed);
2606 }
2607 #endif
2608
2609 // find higest password length, this is for optimization stuff
2610
2611 uint highest_pw_len = 0;
2612
2613 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2614 {
2615 }
2616 else if (data.attack_kern == ATTACK_KERN_COMBI)
2617 {
2618 }
2619 else if (data.attack_kern == ATTACK_KERN_BF)
2620 {
2621 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
2622 + device_param->kernel_params_mp_l_buf32[5];
2623 }
2624
2625 // bitslice optimization stuff
2626
2627 if (data.attack_mode == ATTACK_MODE_BF)
2628 {
2629 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2630 {
2631 run_kernel_tb (device_param, pws_cnt);
2632 }
2633 }
2634
2635 // iteration type
2636
2637 uint innerloop_step = 0;
2638 uint innerloop_cnt = 0;
2639
2640 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = kernel_loops;
2641 else innerloop_step = 1;
2642
2643 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
2644 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
2645 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
2646
2647 // loop start: most outer loop = salt iteration, then innerloops (if multi)
2648
2649 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2650 {
2651 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2652
2653 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2654
2655 if (data.devices_status == STATUS_CRACKED) break;
2656 if (data.devices_status == STATUS_ABORTED) break;
2657 if (data.devices_status == STATUS_QUIT) break;
2658 if (data.devices_status == STATUS_BYPASS) break;
2659
2660 if (data.salts_shown[salt_pos] == 1) continue;
2661
2662 salt_t *salt_buf = &data.salts_buf[salt_pos];
2663
2664 device_param->kernel_params_buf32[24] = salt_pos;
2665 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
2666 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
2667
2668 FILE *combs_fp = device_param->combs_fp;
2669
2670 if (data.attack_mode == ATTACK_MODE_COMBI)
2671 {
2672 rewind (combs_fp);
2673 }
2674
2675 // innerloops
2676
2677 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
2678 {
2679 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2680
2681 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2682
2683 if (data.devices_status == STATUS_CRACKED) break;
2684 if (data.devices_status == STATUS_ABORTED) break;
2685 if (data.devices_status == STATUS_QUIT) break;
2686 if (data.devices_status == STATUS_BYPASS) break;
2687
2688 uint innerloop_left = innerloop_cnt - innerloop_pos;
2689
2690 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
2691
2692 device_param->innerloop_pos = innerloop_pos;
2693 device_param->innerloop_left = innerloop_left;
2694
2695 device_param->kernel_params_buf32[27] = innerloop_left;
2696
2697 if (innerloop_left == 0) continue;
2698
2699 // initialize amplifiers
2700
2701 if (data.attack_mode == ATTACK_MODE_COMBI)
2702 {
2703 char line_buf[BUFSIZ];
2704
2705 uint i = 0;
2706
2707 while (i < innerloop_left)
2708 {
2709 if (feof (combs_fp)) break;
2710
2711 int line_len = fgetl (combs_fp, line_buf);
2712
2713 if (line_len >= PW_MAX1) continue;
2714
2715 line_len = convert_from_hex (line_buf, line_len);
2716
2717 char *line_buf_new = line_buf;
2718
2719 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
2720 {
2721 char rule_buf_out[BLOCK_SIZE];
2722
2723 memset (rule_buf_out, 0, sizeof (rule_buf_out));
2724
2725 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
2726
2727 if (rule_len_out < 0)
2728 {
2729 data.words_progress_rejected[salt_pos] += pw_cnt;
2730
2731 continue;
2732 }
2733
2734 line_len = rule_len_out;
2735
2736 line_buf_new = rule_buf_out;
2737 }
2738
2739 line_len = MIN (line_len, PW_DICTMAX);
2740
2741 char *ptr = (char *) device_param->combs_buf[i].i;
2742
2743 memcpy (ptr, line_buf_new, line_len);
2744
2745 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
2746
2747 if (data.opts_type & OPTS_TYPE_PT_UPPER)
2748 {
2749 uppercase (ptr, line_len);
2750 }
2751
2752 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2753 {
2754 if (data.opts_type & OPTS_TYPE_PT_ADD80)
2755 {
2756 ptr[line_len] = 0x80;
2757 }
2758
2759 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2760 {
2761 ptr[line_len] = 0x01;
2762 }
2763 }
2764
2765 device_param->combs_buf[i].pw_len = line_len;
2766
2767 i++;
2768 }
2769
2770 for (uint j = i; j < innerloop_left; j++)
2771 {
2772 device_param->combs_buf[j].i[0] = 0;
2773 device_param->combs_buf[j].i[1] = 0;
2774 device_param->combs_buf[j].i[2] = 0;
2775 device_param->combs_buf[j].i[3] = 0;
2776 device_param->combs_buf[j].i[4] = 0;
2777 device_param->combs_buf[j].i[5] = 0;
2778 device_param->combs_buf[j].i[6] = 0;
2779 device_param->combs_buf[j].i[7] = 0;
2780
2781 device_param->combs_buf[j].pw_len = 0;
2782 }
2783
2784 innerloop_left = i;
2785 }
2786 else if (data.attack_mode == ATTACK_MODE_BF)
2787 {
2788 uint64_t off = innerloop_pos;
2789
2790 device_param->kernel_params_mp_r_buf64[3] = off;
2791
2792 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
2793 }
2794 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2795 {
2796 uint64_t off = innerloop_pos;
2797
2798 device_param->kernel_params_mp_buf64[3] = off;
2799
2800 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2801 }
2802 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2803 {
2804 uint64_t off = innerloop_pos;
2805
2806 device_param->kernel_params_mp_buf64[3] = off;
2807
2808 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2809 }
2810
2811 // copy amplifiers
2812
2813 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2814 {
2815 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);
2816 }
2817 else if (data.attack_mode == ATTACK_MODE_COMBI)
2818 {
2819 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);
2820 }
2821 else if (data.attack_mode == ATTACK_MODE_BF)
2822 {
2823 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);
2824 }
2825 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2826 {
2827 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);
2828 }
2829 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2830 {
2831 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);
2832 }
2833
2834 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2835 {
2836 if (data.attack_mode == ATTACK_MODE_BF)
2837 {
2838 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2839 {
2840 const uint size_tm = 32 * sizeof (bs_word_t);
2841
2842 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2843
2844 run_kernel_tm (device_param);
2845
2846 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2847 }
2848 }
2849
2850 if (highest_pw_len < 16)
2851 {
2852 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2853 }
2854 else if (highest_pw_len < 32)
2855 {
2856 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2857 }
2858 else
2859 {
2860 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2861 }
2862 }
2863 else
2864 {
2865 run_kernel_amp (device_param, pws_cnt);
2866
2867 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2868
2869 if (data.opts_type & OPTS_TYPE_HOOK12)
2870 {
2871 run_kernel (KERN_RUN_12, device_param, pws_cnt);
2872 }
2873
2874 uint iter = salt_buf->salt_iter;
2875
2876 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
2877 {
2878 uint loop_left = iter - loop_pos;
2879
2880 loop_left = MIN (loop_left, kernel_loops);
2881
2882 device_param->kernel_params_buf32[25] = loop_pos;
2883 device_param->kernel_params_buf32[26] = loop_left;
2884
2885 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2886
2887 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2888
2889 if (data.devices_status == STATUS_CRACKED) break;
2890 if (data.devices_status == STATUS_ABORTED) break;
2891 if (data.devices_status == STATUS_QUIT) break;
2892 }
2893
2894 if (data.opts_type & OPTS_TYPE_HOOK23)
2895 {
2896 run_kernel (KERN_RUN_23, device_param, pws_cnt);
2897
2898 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2899
2900 // do something with data
2901
2902 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2903 }
2904
2905 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2906 }
2907
2908 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2909
2910 if (data.devices_status == STATUS_CRACKED) break;
2911 if (data.devices_status == STATUS_ABORTED) break;
2912 if (data.devices_status == STATUS_QUIT) break;
2913
2914 /**
2915 * result
2916 */
2917
2918 hc_thread_mutex_lock (mux_display);
2919
2920 check_cracked (device_param, salt_pos);
2921
2922 hc_thread_mutex_unlock (mux_display);
2923
2924 /**
2925 * progress
2926 */
2927
2928 uint64_t perf_sum_all = (uint64_t) pw_cnt * (uint64_t) innerloop_left;
2929
2930 hc_thread_mutex_lock (mux_counter);
2931
2932 data.words_progress_done[salt_pos] += perf_sum_all;
2933
2934 hc_thread_mutex_unlock (mux_counter);
2935
2936 /**
2937 * speed
2938 */
2939
2940 float speed_ms;
2941
2942 hc_timer_get (device_param->timer_speed, speed_ms);
2943
2944 hc_timer_set (&device_param->timer_speed);
2945
2946 hc_thread_mutex_lock (mux_display);
2947
2948 device_param->speed_cnt[speed_pos] = perf_sum_all;
2949
2950 device_param->speed_ms[speed_pos] = speed_ms;
2951
2952 device_param->speed_rec[speed_pos] = device_param->timer_speed;
2953
2954 hc_thread_mutex_unlock (mux_display);
2955
2956 speed_pos++;
2957
2958 if (speed_pos == SPEED_CACHE)
2959 {
2960 speed_pos = 0;
2961 }
2962 }
2963 }
2964
2965 device_param->speed_pos = speed_pos;
2966 }
2967
2968 static void load_segment (wl_data_t *wl_data, FILE *fd)
2969 {
2970 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
2971
2972 wl_data->pos = 0;
2973
2974 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
2975
2976 wl_data->buf[wl_data->cnt] = 0;
2977
2978 if (wl_data->cnt == 0) return;
2979
2980 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
2981
2982 while (!feof (fd))
2983 {
2984 if (wl_data->cnt == wl_data->avail)
2985 {
2986 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
2987
2988 wl_data->avail += wl_data->incr;
2989 }
2990
2991 const int c = fgetc (fd);
2992
2993 if (c == EOF) break;
2994
2995 wl_data->buf[wl_data->cnt] = (char) c;
2996
2997 wl_data->cnt++;
2998
2999 if (c == '\n') break;
3000 }
3001
3002 // ensure stream ends with a newline
3003
3004 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3005 {
3006 wl_data->cnt++;
3007
3008 wl_data->buf[wl_data->cnt - 1] = '\n';
3009 }
3010
3011 return;
3012 }
3013
3014 static void get_next_word_lm (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
3015 {
3016 char *ptr = buf;
3017
3018 for (uint32_t i = 0; i < sz; i++, ptr++)
3019 {
3020 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3021
3022 if (i == 7)
3023 {
3024 *off = i;
3025 *len = i;
3026
3027 return;
3028 }
3029
3030 if (*ptr != '\n') continue;
3031
3032 *off = i + 1;
3033
3034 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3035
3036 *len = i;
3037
3038 return;
3039 }
3040
3041 *off = sz;
3042 *len = sz;
3043 }
3044
3045 static void get_next_word_uc (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
3046 {
3047 char *ptr = buf;
3048
3049 for (uint32_t i = 0; i < sz; i++, ptr++)
3050 {
3051 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3052
3053 if (*ptr != '\n') continue;
3054
3055 *off = i + 1;
3056
3057 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3058
3059 *len = i;
3060
3061 return;
3062 }
3063
3064 *off = sz;
3065 *len = sz;
3066 }
3067
3068 static void get_next_word_std (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
3069 {
3070 char *ptr = buf;
3071
3072 for (uint32_t i = 0; i < sz; i++, ptr++)
3073 {
3074 if (*ptr != '\n') continue;
3075
3076 *off = i + 1;
3077
3078 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3079
3080 *len = i;
3081
3082 return;
3083 }
3084
3085 *off = sz;
3086 *len = sz;
3087 }
3088
3089 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3090 {
3091 while (wl_data->pos < wl_data->cnt)
3092 {
3093 uint off;
3094 uint len;
3095
3096 char *ptr = wl_data->buf + wl_data->pos;
3097
3098 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3099
3100 wl_data->pos += off;
3101
3102 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3103 {
3104 char rule_buf_out[BLOCK_SIZE];
3105
3106 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3107
3108 int rule_len_out = -1;
3109
3110 if (len < BLOCK_SIZE)
3111 {
3112 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3113 }
3114
3115 if (rule_len_out < 0)
3116 {
3117 continue;
3118 }
3119
3120 if (rule_len_out > PW_MAX)
3121 {
3122 continue;
3123 }
3124 }
3125 else
3126 {
3127 if (len > PW_MAX)
3128 {
3129 continue;
3130 }
3131 }
3132
3133 *out_buf = ptr;
3134 *out_len = len;
3135
3136 return;
3137 }
3138
3139 if (feof (fd))
3140 {
3141 fprintf (stderr, "bug!!\n");
3142
3143 return;
3144 }
3145
3146 load_segment (wl_data, fd);
3147
3148 get_next_word (wl_data, fd, out_buf, out_len);
3149 }
3150
3151 #ifdef _POSIX
3152 static uint64_t count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3153 #endif
3154
3155 #ifdef _WIN
3156 static uint64_t count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3157 #endif
3158 {
3159 hc_signal (NULL);
3160
3161 dictstat_t d;
3162
3163 d.cnt = 0;
3164
3165 #ifdef _POSIX
3166 fstat (fileno (fd), &d.stat);
3167 #endif
3168
3169 #ifdef _WIN
3170 _fstat64 (fileno (fd), &d.stat);
3171 #endif
3172
3173 d.stat.st_mode = 0;
3174 d.stat.st_nlink = 0;
3175 d.stat.st_uid = 0;
3176 d.stat.st_gid = 0;
3177 d.stat.st_rdev = 0;
3178 d.stat.st_atime = 0;
3179
3180 #ifdef _POSIX
3181 d.stat.st_blksize = 0;
3182 d.stat.st_blocks = 0;
3183 #endif
3184
3185 if (d.stat.st_size == 0) return 0;
3186
3187 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3188
3189 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3190 {
3191 if (d_cache)
3192 {
3193 uint64_t cnt = d_cache->cnt;
3194
3195 uint64_t keyspace = cnt;
3196
3197 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3198 {
3199 keyspace *= data.kernel_rules_cnt;
3200 }
3201 else if (data.attack_kern == ATTACK_KERN_COMBI)
3202 {
3203 keyspace *= data.combs_cnt;
3204 }
3205
3206 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);
3207 if (data.quiet == 0) log_info ("");
3208
3209 hc_signal (sigHandler_default);
3210
3211 return (keyspace);
3212 }
3213 }
3214
3215 time_t now = 0;
3216 time_t prev = 0;
3217
3218 uint64_t comp = 0;
3219 uint64_t cnt = 0;
3220 uint64_t cnt2 = 0;
3221
3222 while (!feof (fd))
3223 {
3224 load_segment (wl_data, fd);
3225
3226 comp += wl_data->cnt;
3227
3228 uint32_t i = 0;
3229
3230 while (i < wl_data->cnt)
3231 {
3232 uint32_t len;
3233 uint32_t off;
3234
3235 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3236
3237 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3238 {
3239 char rule_buf_out[BLOCK_SIZE];
3240
3241 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3242
3243 int rule_len_out = -1;
3244
3245 if (len < BLOCK_SIZE)
3246 {
3247 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3248 }
3249
3250 if (rule_len_out < 0)
3251 {
3252 len = PW_MAX1;
3253 }
3254 else
3255 {
3256 len = rule_len_out;
3257 }
3258 }
3259
3260 if (len < PW_MAX1)
3261 {
3262 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3263 {
3264 cnt += data.kernel_rules_cnt;
3265 }
3266 else if (data.attack_kern == ATTACK_KERN_COMBI)
3267 {
3268 cnt += data.combs_cnt;
3269 }
3270
3271 d.cnt++;
3272 }
3273
3274 i += off;
3275
3276 cnt2++;
3277 }
3278
3279 time (&now);
3280
3281 if ((now - prev) == 0) continue;
3282
3283 float percent = (float) comp / (float) d.stat.st_size;
3284
3285 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);
3286
3287 time (&prev);
3288 }
3289
3290 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);
3291 if (data.quiet == 0) log_info ("");
3292
3293 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3294
3295 hc_signal (sigHandler_default);
3296
3297 return (cnt);
3298 }
3299
3300 static void pw_transpose_to_hi1 (const pw_t *p1, pw_t *p2)
3301 {
3302 memcpy (p2->hi1, p1->hi1, 64 * sizeof (uint));
3303 }
3304
3305 static uint pw_add_to_hc1 (hc_device_param_t *device_param, const uint8_t *pw_buf, const uint pw_len)
3306 {
3307 if (data.devices_status == STATUS_BYPASS) return 0;
3308
3309 pw_cache_t *pw_cache = device_param->pw_caches + pw_len;
3310
3311 uint cache_cnt = pw_cache->cnt;
3312
3313 uint8_t *pw_hc1 = pw_cache->pw_buf.hc1[cache_cnt];
3314
3315 memcpy (pw_hc1, pw_buf, pw_len);
3316
3317 memset (pw_hc1 + pw_len, 0, 256 - pw_len);
3318
3319 uint pws_cnt = device_param->pws_cnt;
3320
3321 cache_cnt++;
3322
3323 pw_t *pw = device_param->pws_buf + pws_cnt;
3324
3325 device_param->pw_transpose (&pw_cache->pw_buf, pw);
3326
3327 pw->pw_len = pw_len;
3328
3329 pws_cnt++;
3330
3331 device_param->pws_cnt = pws_cnt;
3332 device_param->pw_cnt = pws_cnt * 1;
3333
3334 cache_cnt = 0;
3335
3336 pw_cache->cnt = cache_cnt;
3337
3338 return pws_cnt;
3339 }
3340
3341 static void *thread_monitor (void *p)
3342 {
3343 uint runtime_check = 0;
3344 uint remove_check = 0;
3345 uint status_check = 0;
3346 uint hwmon_check = 0;
3347 uint restore_check = 0;
3348
3349 uint restore_left = data.restore_timer;
3350 uint remove_left = data.remove_timer;
3351 uint status_left = data.status_timer;
3352
3353 // these variables are mainly used for fan control (AMD only)
3354
3355 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3356
3357 // temperature controller "loopback" values
3358
3359 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3360 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3361
3362 int temp_threshold = 1; // degrees celcius
3363
3364 int fan_speed_min = 15; // in percentage
3365 int fan_speed_max = 100;
3366
3367 time_t last_temp_check_time;
3368
3369 uint sleep_time = 1;
3370
3371 if (data.runtime)
3372 {
3373 runtime_check = 1;
3374 }
3375
3376 if (data.restore_timer)
3377 {
3378 restore_check = 1;
3379 }
3380
3381 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3382 {
3383 remove_check = 1;
3384 }
3385
3386 if (data.status == 1)
3387 {
3388 status_check = 1;
3389 }
3390
3391 if (data.gpu_temp_disable == 0)
3392 {
3393 time (&last_temp_check_time);
3394
3395 hwmon_check = 1;
3396 }
3397
3398 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (hwmon_check == 0) && (restore_check == 0))
3399 {
3400 return (p);
3401 }
3402
3403 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3404 {
3405 hc_sleep (sleep_time);
3406
3407 if (data.devices_status != STATUS_RUNNING) continue;
3408
3409 if (hwmon_check == 1)
3410 {
3411 hc_thread_mutex_lock (mux_adl);
3412
3413 time_t temp_check_time;
3414
3415 time (&temp_check_time);
3416
3417 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3418
3419 if (Ta == 0) Ta = 1;
3420
3421 for (uint i = 0; i < data.devices_cnt; i++)
3422 {
3423 const int temperature = hm_get_temperature_with_device_id (i);
3424
3425 if (temperature > (int) data.gpu_temp_abort)
3426 {
3427 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", i + 1);
3428
3429 if (data.devices_status != STATUS_QUIT) myabort ();
3430
3431 break;
3432 }
3433
3434 const int gpu_temp_retain = data.gpu_temp_retain;
3435
3436 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3437 {
3438 if (data.hm_device[i].fan_supported == 1)
3439 {
3440 int temp_cur = temperature;
3441
3442 int temp_diff_new = gpu_temp_retain - temp_cur;
3443
3444 temp_diff_sum[i] = temp_diff_sum[i] + temp_diff_new;
3445
3446 // calculate Ta value (time difference in seconds between the last check and this check)
3447
3448 last_temp_check_time = temp_check_time;
3449
3450 float Kp = 1.8;
3451 float Ki = 0.005;
3452 float Kd = 6;
3453
3454 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3455
3456 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);
3457
3458 if (abs (fan_diff_required) >= temp_threshold)
3459 {
3460 const int fan_speed_cur = hm_get_fanspeed_with_device_id (i);
3461
3462 int fan_speed_level = fan_speed_cur;
3463
3464 if (fan_speed_chgd[i] == 0) fan_speed_level = temp_cur;
3465
3466 int fan_speed_new = fan_speed_level - fan_diff_required;
3467
3468 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3469 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3470
3471 if (fan_speed_new != fan_speed_cur)
3472 {
3473 int freely_change_fan_speed = (fan_speed_chgd[i] == 1);
3474 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3475
3476 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3477 {
3478 hm_set_fanspeed_with_device_id_amd (i, fan_speed_new);
3479
3480 fan_speed_chgd[i] = 1;
3481 }
3482
3483 temp_diff_old[i] = temp_diff_new;
3484 }
3485 }
3486 }
3487 }
3488 }
3489
3490 hc_thread_mutex_unlock (mux_adl);
3491 }
3492
3493 if (restore_check == 1)
3494 {
3495 restore_left--;
3496
3497 if (restore_left == 0)
3498 {
3499 if (data.restore_disable == 0) cycle_restore ();
3500
3501 restore_left = data.restore_timer;
3502 }
3503 }
3504
3505 if ((runtime_check == 1) && (data.runtime_start > 0))
3506 {
3507 time_t runtime_cur;
3508
3509 time (&runtime_cur);
3510
3511 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3512
3513 if (runtime_left <= 0)
3514 {
3515 if (data.benchmark == 0)
3516 {
3517 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3518 }
3519
3520 if (data.devices_status != STATUS_QUIT) myabort ();
3521 }
3522 }
3523
3524 if (remove_check == 1)
3525 {
3526 remove_left--;
3527
3528 if (remove_left == 0)
3529 {
3530 if (data.digests_saved != data.digests_done)
3531 {
3532 data.digests_saved = data.digests_done;
3533
3534 save_hash ();
3535 }
3536
3537 remove_left = data.remove_timer;
3538 }
3539 }
3540
3541 if (status_check == 1)
3542 {
3543 status_left--;
3544
3545 if (status_left == 0)
3546 {
3547 hc_thread_mutex_lock (mux_display);
3548
3549 if (data.quiet == 0) clear_prompt ();
3550
3551 if (data.quiet == 0) log_info ("");
3552
3553 status_display ();
3554
3555 if (data.quiet == 0) log_info ("");
3556
3557 hc_thread_mutex_unlock (mux_display);
3558
3559 status_left = data.status_timer;
3560 }
3561 }
3562 }
3563
3564 myfree (fan_speed_chgd);
3565
3566 myfree (temp_diff_old);
3567 myfree (temp_diff_sum);
3568
3569 p = NULL;
3570
3571 return (p);
3572 }
3573
3574 static void *thread_outfile_remove (void *p)
3575 {
3576 // some hash-dependent constants
3577 char *outfile_dir = data.outfile_check_directory;
3578 uint dgst_size = data.dgst_size;
3579 uint isSalted = data.isSalted;
3580 uint esalt_size = data.esalt_size;
3581 uint hash_mode = data.hash_mode;
3582
3583 uint outfile_check_timer = data.outfile_check_timer;
3584
3585 char separator = data.separator;
3586
3587 // some hash-dependent functions
3588 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3589 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3590
3591 // buffers
3592 hash_t hash_buf;
3593
3594 memset (&hash_buf, 0, sizeof (hash_buf));
3595
3596 hash_buf.digest = mymalloc (dgst_size);
3597
3598 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3599
3600 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3601
3602 uint digest_buf[64];
3603
3604 outfile_data_t *out_info = NULL;
3605
3606 char **out_files = NULL;
3607
3608 time_t folder_mtime = 0;
3609
3610 int out_cnt = 0;
3611
3612 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3613
3614 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3615 {
3616 hc_sleep (1);
3617
3618 if (data.devices_status != STATUS_RUNNING) continue;
3619
3620 check_left--;
3621
3622 if (check_left == 0)
3623 {
3624 struct stat outfile_check_stat;
3625
3626 if (stat (outfile_dir, &outfile_check_stat) == 0)
3627 {
3628 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3629
3630 if (is_dir == 1)
3631 {
3632 if (outfile_check_stat.st_mtime > folder_mtime)
3633 {
3634 char **out_files_new = scan_directory (outfile_dir);
3635
3636 int out_cnt_new = count_dictionaries (out_files_new);
3637
3638 outfile_data_t *out_info_new = NULL;
3639
3640 if (out_cnt_new > 0)
3641 {
3642 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3643
3644 for (int i = 0; i < out_cnt_new; i++)
3645 {
3646 out_info_new[i].file_name = out_files_new[i];
3647
3648 // check if there are files that we have seen/checked before (and not changed)
3649
3650 for (int j = 0; j < out_cnt; j++)
3651 {
3652 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
3653 {
3654 struct stat outfile_stat;
3655
3656 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
3657 {
3658 if (outfile_stat.st_ctime == out_info[j].ctime)
3659 {
3660 out_info_new[i].ctime = out_info[j].ctime;
3661 out_info_new[i].seek = out_info[j].seek;
3662 }
3663 }
3664 }
3665 }
3666 }
3667 }
3668
3669 local_free (out_info);
3670 local_free (out_files);
3671
3672 out_files = out_files_new;
3673 out_cnt = out_cnt_new;
3674 out_info = out_info_new;
3675
3676 folder_mtime = outfile_check_stat.st_mtime;
3677 }
3678
3679 for (int j = 0; j < out_cnt; j++)
3680 {
3681 FILE *fp = fopen (out_info[j].file_name, "rb");
3682
3683 if (fp != NULL)
3684 {
3685 //hc_thread_mutex_lock (mux_display);
3686
3687 #ifdef _POSIX
3688 struct stat outfile_stat;
3689
3690 fstat (fileno (fp), &outfile_stat);
3691 #endif
3692
3693 #ifdef _WIN
3694 struct stat64 outfile_stat;
3695
3696 _fstat64 (fileno (fp), &outfile_stat);
3697 #endif
3698
3699 if (outfile_stat.st_ctime > out_info[j].ctime)
3700 {
3701 out_info[j].ctime = outfile_stat.st_ctime;
3702 out_info[j].seek = 0;
3703 }
3704
3705 fseek (fp, out_info[j].seek, SEEK_SET);
3706
3707 while (!feof (fp))
3708 {
3709 char line_buf[BUFSIZ];
3710
3711 memset (line_buf, 0, BUFSIZ);
3712
3713 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
3714
3715 if (ptr == NULL) break;
3716
3717 int line_len = strlen (line_buf);
3718
3719 if (line_len <= 0) continue;
3720
3721 int iter = MAX_CUT_TRIES;
3722
3723 for (uint i = line_len - 1; i && iter; i--, line_len--)
3724 {
3725 if (line_buf[i] != separator) continue;
3726
3727 int parser_status = PARSER_OK;
3728
3729 if ((hash_mode != 2500) && (hash_mode != 6800))
3730 {
3731 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
3732 }
3733
3734 uint found = 0;
3735
3736 if (parser_status == PARSER_OK)
3737 {
3738 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
3739 {
3740 if (data.salts_shown[salt_pos] == 1) continue;
3741
3742 salt_t *salt_buf = &data.salts_buf[salt_pos];
3743
3744 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
3745 {
3746 uint idx = salt_buf->digests_offset + digest_pos;
3747
3748 if (data.digests_shown[idx] == 1) continue;
3749
3750 uint cracked = 0;
3751
3752 if (hash_mode == 6800)
3753 {
3754 if (i == salt_buf->salt_len)
3755 {
3756 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3757 }
3758 }
3759 else if (hash_mode == 2500)
3760 {
3761 // BSSID : MAC1 : MAC2 (:plain)
3762 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
3763 {
3764 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3765
3766 if (!cracked) continue;
3767
3768 // now compare MAC1 and MAC2 too, since we have this additional info
3769 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
3770 char *mac2_pos = mac1_pos + 12 + 1;
3771
3772 wpa_t *wpas = (wpa_t *) data.esalts_buf;
3773 wpa_t *wpa = &wpas[salt_pos];
3774
3775 uint pke[25];
3776
3777 char *pke_ptr = (char *) pke;
3778
3779 for (uint i = 0; i < 25; i++)
3780 {
3781 pke[i] = byte_swap_32 (wpa->pke[i]);
3782 }
3783
3784 unsigned char mac1[6];
3785 unsigned char mac2[6];
3786
3787 memcpy (mac1, pke_ptr + 23, 6);
3788 memcpy (mac2, pke_ptr + 29, 6);
3789
3790 // compare hex string(s) vs binary MAC address(es)
3791
3792 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3793 {
3794 if (mac1[i] != (unsigned char) hex_to_char (&mac1_pos[j]))
3795 {
3796 cracked = 0;
3797 break;
3798 }
3799 }
3800
3801 // early skip ;)
3802 if (!cracked) continue;
3803
3804 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3805 {
3806 if (mac2[i] != (unsigned char) hex_to_char (&mac2_pos[j]))
3807 {
3808 cracked = 0;
3809 break;
3810 }
3811 }
3812 }
3813 }
3814 else
3815 {
3816 char *digests_buf_ptr = (char *) data.digests_buf;
3817
3818 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
3819
3820 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
3821 }
3822
3823 if (cracked == 1)
3824 {
3825 found = 1;
3826
3827 data.digests_shown[idx] = 1;
3828
3829 data.digests_done++;
3830
3831 salt_buf->digests_done++;
3832
3833 if (salt_buf->digests_done == salt_buf->digests_cnt)
3834 {
3835 data.salts_shown[salt_pos] = 1;
3836
3837 data.salts_done++;
3838
3839 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
3840 }
3841 }
3842 }
3843
3844 if (data.devices_status == STATUS_CRACKED) break;
3845 }
3846 }
3847
3848 if (found) break;
3849
3850 if (data.devices_status == STATUS_CRACKED) break;
3851
3852 iter--;
3853 }
3854
3855 if (data.devices_status == STATUS_CRACKED) break;
3856 }
3857
3858 out_info[j].seek = ftell (fp);
3859
3860 //hc_thread_mutex_unlock (mux_display);
3861
3862 fclose (fp);
3863 }
3864 }
3865 }
3866 }
3867
3868 check_left = outfile_check_timer;
3869 }
3870 }
3871
3872 if (esalt_size) local_free (hash_buf.esalt);
3873
3874 if (isSalted) local_free (hash_buf.salt);
3875
3876 local_free (hash_buf.digest);
3877
3878 local_free (out_info);
3879
3880 local_free (out_files);
3881
3882 p = NULL;
3883
3884 return (p);
3885 }
3886
3887 static uint get_work (hc_device_param_t *device_param, const uint64_t max)
3888 {
3889 hc_thread_mutex_lock (mux_dispatcher);
3890
3891 const uint64_t words_cur = data.words_cur;
3892 const uint64_t words_base = (data.limit == 0) ? data.words_base : data.limit;
3893
3894 device_param->words_off = words_cur;
3895
3896 const uint64_t words_left = words_base - words_cur;
3897
3898 if (data.kernel_blocks_all > words_left)
3899 {
3900 if (data.kernel_blocks_div == 0)
3901 {
3902 data.kernel_blocks_div = find_kernel_blocks_div (words_left, data.kernel_blocks_all);
3903 }
3904 }
3905
3906 if (data.kernel_blocks_div)
3907 {
3908 if (device_param->kernel_blocks == device_param->kernel_blocks_user)
3909 {
3910 const uint32_t kernel_blocks_new = (float) device_param->kernel_blocks * data.kernel_blocks_div;
3911 const uint32_t kernel_power_new = kernel_blocks_new;
3912
3913 if (kernel_blocks_new < device_param->kernel_blocks)
3914 {
3915 device_param->kernel_blocks = kernel_blocks_new;
3916 device_param->kernel_power = kernel_power_new;
3917 }
3918 }
3919 }
3920
3921 const uint kernel_blocks = device_param->kernel_blocks;
3922
3923 uint work = MIN (words_left, kernel_blocks);
3924
3925 work = MIN (work, max);
3926
3927 data.words_cur += work;
3928
3929 hc_thread_mutex_unlock (mux_dispatcher);
3930
3931 return work;
3932 }
3933
3934 static void *thread_calc_stdin (void *p)
3935 {
3936 hc_device_param_t *device_param = (hc_device_param_t *) p;
3937
3938 const uint attack_kern = data.attack_kern;
3939
3940 const uint kernel_blocks = device_param->kernel_blocks;
3941
3942 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3943 {
3944 hc_thread_mutex_lock (mux_dispatcher);
3945
3946 if (feof (stdin) != 0)
3947 {
3948 hc_thread_mutex_unlock (mux_dispatcher);
3949
3950 break;
3951 }
3952
3953 uint words_cur = 0;
3954
3955 while (words_cur < kernel_blocks)
3956 {
3957 char buf[BUFSIZ];
3958
3959 char *line_buf = fgets (buf, sizeof (buf), stdin);
3960
3961 if (line_buf == NULL) break;
3962
3963 uint line_len = in_superchop (line_buf);
3964
3965 line_len = convert_from_hex (line_buf, line_len);
3966
3967 // post-process rule engine
3968
3969 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3970 {
3971 char rule_buf_out[BLOCK_SIZE];
3972
3973 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3974
3975 int rule_len_out = -1;
3976
3977 if (line_len < BLOCK_SIZE)
3978 {
3979 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
3980 }
3981
3982 if (rule_len_out < 0) continue;
3983
3984 line_buf = rule_buf_out;
3985 line_len = rule_len_out;
3986 }
3987
3988 if (line_len > PW_MAX)
3989 {
3990 continue;
3991 }
3992
3993 if (attack_kern == ATTACK_KERN_STRAIGHT)
3994 {
3995 if ((line_len < data.pw_min) || (line_len > data.pw_max))
3996 {
3997 hc_thread_mutex_lock (mux_counter);
3998
3999 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4000 {
4001 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4002 }
4003
4004 hc_thread_mutex_unlock (mux_counter);
4005
4006 continue;
4007 }
4008 }
4009 else if (attack_kern == ATTACK_KERN_COMBI)
4010 {
4011 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4012 // since we still need to combine the plains
4013
4014 if (line_len > data.pw_max)
4015 {
4016 hc_thread_mutex_lock (mux_counter);
4017
4018 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4019 {
4020 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4021 }
4022
4023 hc_thread_mutex_unlock (mux_counter);
4024
4025 continue;
4026 }
4027 }
4028
4029 device_param->pw_add (device_param, (uint8_t *) line_buf, line_len);
4030
4031 words_cur++;
4032
4033 if (data.devices_status == STATUS_CRACKED) break;
4034 if (data.devices_status == STATUS_ABORTED) break;
4035 if (data.devices_status == STATUS_QUIT) break;
4036 if (data.devices_status == STATUS_BYPASS) break;
4037 }
4038
4039 hc_thread_mutex_unlock (mux_dispatcher);
4040
4041 if (data.devices_status == STATUS_CRACKED) break;
4042 if (data.devices_status == STATUS_ABORTED) break;
4043 if (data.devices_status == STATUS_QUIT) break;
4044 if (data.devices_status == STATUS_BYPASS) break;
4045
4046 // we need 2 flushing because we have two independant caches and it can occur
4047 // that one buffer is already at threshold plus for that length also exists
4048 // more data in the 2nd buffer so it would overflow
4049
4050 // flush session 1
4051
4052 {
4053 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4054 {
4055 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4056
4057 const uint pw_cache_cnt = pw_cache->cnt;
4058
4059 if (pw_cache_cnt == 0) continue;
4060
4061 pw_cache->cnt = 0;
4062
4063 uint pws_cnt = device_param->pws_cnt;
4064
4065 pw_t *pw = device_param->pws_buf + pws_cnt;
4066
4067 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4068
4069 pw->pw_len = pw_len;
4070
4071 uint pw_cnt = device_param->pw_cnt;
4072
4073 pw_cnt += pw_cache_cnt;
4074
4075 device_param->pw_cnt = pw_cnt;
4076
4077 pws_cnt++;
4078
4079 device_param->pws_cnt = pws_cnt;
4080
4081 if (pws_cnt == device_param->kernel_power_user) break;
4082 }
4083
4084 const uint pw_cnt = device_param->pw_cnt;
4085 const uint pws_cnt = device_param->pws_cnt;
4086
4087 if (pws_cnt)
4088 {
4089 run_copy (device_param, pws_cnt);
4090
4091 run_cracker (device_param, pw_cnt, pws_cnt);
4092
4093 device_param->pw_cnt = 0;
4094 device_param->pws_cnt = 0;
4095 }
4096 }
4097
4098 // flush session 2
4099
4100 {
4101 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4102 {
4103 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4104
4105 const uint pw_cache_cnt = pw_cache->cnt;
4106
4107 if (pw_cache_cnt == 0) continue;
4108
4109 pw_cache->cnt = 0;
4110
4111 uint pws_cnt = device_param->pws_cnt;
4112
4113 pw_t *pw = device_param->pws_buf + pws_cnt;
4114
4115 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4116
4117 pw->pw_len = pw_len;
4118
4119 uint pw_cnt = device_param->pw_cnt;
4120
4121 pw_cnt += pw_cache_cnt;
4122
4123 device_param->pw_cnt = pw_cnt;
4124
4125 pws_cnt++;
4126
4127 device_param->pws_cnt = pws_cnt;
4128 }
4129
4130 const uint pw_cnt = device_param->pw_cnt;
4131 const uint pws_cnt = device_param->pws_cnt;
4132
4133 if (pws_cnt)
4134 {
4135 run_copy (device_param, pws_cnt);
4136
4137 run_cracker (device_param, pw_cnt, pws_cnt);
4138
4139 device_param->pw_cnt = 0;
4140 device_param->pws_cnt = 0;
4141 }
4142 }
4143 }
4144
4145 return NULL;
4146 }
4147
4148 static void *thread_calc (void *p)
4149 {
4150 hc_device_param_t *device_param = (hc_device_param_t *) p;
4151
4152 const uint attack_mode = data.attack_mode;
4153 const uint attack_kern = data.attack_kern;
4154
4155 if (attack_mode == ATTACK_MODE_BF)
4156 {
4157 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4158 {
4159 const uint work = get_work (device_param, -1);
4160
4161 if (work == 0) break;
4162
4163 const uint64_t words_off = device_param->words_off;
4164 const uint64_t words_fin = words_off + work;
4165
4166 const uint pw_cnt = work;
4167 const uint pws_cnt = work;
4168
4169 device_param->pw_cnt = pw_cnt;
4170 device_param->pws_cnt = pws_cnt;
4171
4172 if (pws_cnt)
4173 {
4174 run_copy (device_param, pws_cnt);
4175
4176 run_cracker (device_param, pw_cnt, pws_cnt);
4177
4178 device_param->pw_cnt = 0;
4179 device_param->pws_cnt = 0;
4180 }
4181
4182 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4183
4184 if (data.devices_status == STATUS_CRACKED) break;
4185 if (data.devices_status == STATUS_ABORTED) break;
4186 if (data.devices_status == STATUS_QUIT) break;
4187 if (data.devices_status == STATUS_BYPASS) break;
4188
4189 device_param->words_done = words_fin;
4190 }
4191 }
4192 else
4193 {
4194 const uint segment_size = data.segment_size;
4195
4196 char *dictfile = data.dictfile;
4197
4198 if (attack_mode == ATTACK_MODE_COMBI)
4199 {
4200 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4201 {
4202 dictfile = data.dictfile2;
4203 }
4204 }
4205
4206 FILE *fd = fopen (dictfile, "rb");
4207
4208 if (fd == NULL)
4209 {
4210 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4211
4212 return NULL;
4213 }
4214
4215 if (attack_mode == ATTACK_MODE_COMBI)
4216 {
4217 const uint combs_mode = data.combs_mode;
4218
4219 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4220 {
4221 const char *dictfilec = data.dictfile2;
4222
4223 FILE *combs_fp = fopen (dictfilec, "rb");
4224
4225 if (combs_fp == NULL)
4226 {
4227 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4228
4229 fclose (fd);
4230
4231 return NULL;
4232 }
4233
4234 device_param->combs_fp = combs_fp;
4235 }
4236 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4237 {
4238 const char *dictfilec = data.dictfile;
4239
4240 FILE *combs_fp = fopen (dictfilec, "rb");
4241
4242 if (combs_fp == NULL)
4243 {
4244 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4245
4246 fclose (fd);
4247
4248 return NULL;
4249 }
4250
4251 device_param->combs_fp = combs_fp;
4252 }
4253 }
4254
4255 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4256
4257 wl_data->buf = (char *) mymalloc (segment_size);
4258 wl_data->avail = segment_size;
4259 wl_data->incr = segment_size;
4260 wl_data->cnt = 0;
4261 wl_data->pos = 0;
4262
4263 uint64_t words_cur = 0;
4264
4265 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4266 {
4267 uint64_t words_off = 0;
4268 uint64_t words_fin = 0;
4269
4270 uint64_t max = -1;
4271
4272 while (max)
4273 {
4274 const uint work = get_work (device_param, max);
4275
4276 if (work == 0) break;
4277
4278 words_off = device_param->words_off;
4279 words_fin = words_off + work;
4280
4281 char *line_buf;
4282 uint line_len;
4283
4284 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4285
4286 max = 0;
4287
4288 for ( ; words_cur < words_fin; words_cur++)
4289 {
4290 get_next_word (wl_data, fd, &line_buf, &line_len);
4291
4292 line_len = convert_from_hex (line_buf, line_len);
4293
4294 // post-process rule engine
4295
4296 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4297 {
4298 char rule_buf_out[BLOCK_SIZE];
4299
4300 memset (rule_buf_out, 0, sizeof (rule_buf_out));
4301
4302 int rule_len_out = -1;
4303
4304 if (line_len < BLOCK_SIZE)
4305 {
4306 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4307 }
4308
4309 if (rule_len_out < 0) continue;
4310
4311 line_buf = rule_buf_out;
4312 line_len = rule_len_out;
4313 }
4314
4315 if (attack_kern == ATTACK_KERN_STRAIGHT)
4316 {
4317 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4318 {
4319 max++;
4320
4321 hc_thread_mutex_lock (mux_counter);
4322
4323 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4324 {
4325 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4326 }
4327
4328 hc_thread_mutex_unlock (mux_counter);
4329
4330 continue;
4331 }
4332 }
4333 else if (attack_kern == ATTACK_KERN_COMBI)
4334 {
4335 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4336 // since we still need to combine the plains
4337
4338 if (line_len > data.pw_max)
4339 {
4340 max++;
4341
4342 hc_thread_mutex_lock (mux_counter);
4343
4344 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4345 {
4346 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4347 }
4348
4349 hc_thread_mutex_unlock (mux_counter);
4350
4351 continue;
4352 }
4353 }
4354
4355 device_param->pw_add (device_param, (uint8_t *) line_buf, line_len);
4356
4357 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4358
4359 if (data.devices_status == STATUS_CRACKED) break;
4360 if (data.devices_status == STATUS_ABORTED) break;
4361 if (data.devices_status == STATUS_QUIT) break;
4362 if (data.devices_status == STATUS_BYPASS) break;
4363 }
4364
4365 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4366
4367 if (data.devices_status == STATUS_CRACKED) break;
4368 if (data.devices_status == STATUS_ABORTED) break;
4369 if (data.devices_status == STATUS_QUIT) break;
4370 if (data.devices_status == STATUS_BYPASS) break;
4371 }
4372
4373 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4374
4375 if (data.devices_status == STATUS_CRACKED) break;
4376 if (data.devices_status == STATUS_ABORTED) break;
4377 if (data.devices_status == STATUS_QUIT) break;
4378 if (data.devices_status == STATUS_BYPASS) break;
4379
4380 // we need 2 flushing because we have two independant caches and it can occur
4381 // that one buffer is already at threshold plus for that length also exists
4382 // more data in the 2nd buffer so it would overflow
4383
4384 //
4385 // flush session 1
4386 //
4387
4388 {
4389 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4390 {
4391 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4392
4393 const uint pw_cache_cnt = pw_cache->cnt;
4394
4395 if (pw_cache_cnt == 0) continue;
4396
4397 pw_cache->cnt = 0;
4398
4399 uint pws_cnt = device_param->pws_cnt;
4400
4401 pw_t *pw = device_param->pws_buf + pws_cnt;
4402
4403 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4404
4405 pw->pw_len = pw_len;
4406
4407 uint pw_cnt = device_param->pw_cnt;
4408
4409 pw_cnt += pw_cache_cnt;
4410
4411 device_param->pw_cnt = pw_cnt;
4412
4413 pws_cnt++;
4414
4415 device_param->pws_cnt = pws_cnt;
4416
4417 if (pws_cnt == device_param->kernel_power_user) break;
4418 }
4419
4420 const uint pw_cnt = device_param->pw_cnt;
4421 const uint pws_cnt = device_param->pws_cnt;
4422
4423 if (pws_cnt)
4424 {
4425 run_copy (device_param, pws_cnt);
4426
4427 run_cracker (device_param, pw_cnt, pws_cnt);
4428
4429 device_param->pw_cnt = 0;
4430 device_param->pws_cnt = 0;
4431 }
4432
4433 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4434
4435 if (data.devices_status == STATUS_CRACKED) break;
4436 if (data.devices_status == STATUS_ABORTED) break;
4437 if (data.devices_status == STATUS_QUIT) break;
4438 if (data.devices_status == STATUS_BYPASS) break;
4439 }
4440
4441 //
4442 // flush session 2
4443 //
4444
4445 {
4446 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4447 {
4448 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4449
4450 const uint pw_cache_cnt = pw_cache->cnt;
4451
4452 if (pw_cache_cnt == 0) continue;
4453
4454 pw_cache->cnt = 0;
4455
4456 uint pws_cnt = device_param->pws_cnt;
4457
4458 pw_t *pw = device_param->pws_buf + pws_cnt;
4459
4460 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4461
4462 pw->pw_len = pw_len;
4463
4464 uint pw_cnt = device_param->pw_cnt;
4465
4466 pw_cnt += pw_cache_cnt;
4467
4468 device_param->pw_cnt = pw_cnt;
4469
4470 pws_cnt++;
4471
4472 device_param->pws_cnt = pws_cnt;
4473 }
4474
4475 const uint pw_cnt = device_param->pw_cnt;
4476 const uint pws_cnt = device_param->pws_cnt;
4477
4478 if (pws_cnt)
4479 {
4480 run_copy (device_param, pws_cnt);
4481
4482 run_cracker (device_param, pw_cnt, pws_cnt);
4483
4484 device_param->pw_cnt = 0;
4485 device_param->pws_cnt = 0;
4486 }
4487
4488 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4489
4490 if (data.devices_status == STATUS_CRACKED) break;
4491 if (data.devices_status == STATUS_ABORTED) break;
4492 if (data.devices_status == STATUS_QUIT) break;
4493 if (data.devices_status == STATUS_BYPASS) break;
4494 }
4495
4496 if (words_fin == 0) break;
4497
4498 device_param->words_done = words_fin;
4499 }
4500
4501 if (attack_mode == ATTACK_MODE_COMBI)
4502 {
4503 fclose (device_param->combs_fp);
4504 }
4505
4506 free (wl_data->buf);
4507 free (wl_data);
4508
4509 fclose (fd);
4510 }
4511
4512 return NULL;
4513 }
4514
4515 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos, const uint kernel_loops)
4516 {
4517 salt_t *salt_buf = &data.salts_buf[salt_pos];
4518
4519 device_param->kernel_params_buf32[24] = salt_pos;
4520 device_param->kernel_params_buf32[27] = 1;
4521 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4522 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4523 device_param->kernel_params_buf32[30] = 0;
4524 device_param->kernel_params_buf32[31] = 1;
4525
4526 char *dictfile_old = data.dictfile;
4527 char *dictfile2_old = data.dictfile2;
4528 char *mask_old = data.mask;
4529
4530 const char *weak_hash_check = "weak-hash-check";
4531
4532 data.dictfile = (char *) weak_hash_check;
4533 data.dictfile2 = (char *) weak_hash_check;
4534 data.mask = (char *) weak_hash_check;
4535
4536 /**
4537 * run the kernel
4538 */
4539
4540 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4541 {
4542 run_kernel (KERN_RUN_WEAK, device_param, 1);
4543 }
4544 else
4545 {
4546 run_kernel (KERN_RUN_1, device_param, 1);
4547
4548 const uint iter = salt_buf->salt_iter;
4549
4550 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
4551 {
4552 uint loop_left = iter - loop_pos;
4553
4554 loop_left = MIN (loop_left, kernel_loops);
4555
4556 device_param->kernel_params_buf32[25] = loop_pos;
4557 device_param->kernel_params_buf32[26] = loop_left;
4558
4559 run_kernel (KERN_RUN_2, device_param, 1);
4560 }
4561
4562 run_kernel (KERN_RUN_3, device_param, 1);
4563 }
4564
4565 /**
4566 * result
4567 */
4568
4569 check_cracked (device_param, salt_pos);
4570
4571 /**
4572 * cleanup
4573 */
4574
4575 device_param->kernel_params_buf32[24] = 0;
4576 device_param->kernel_params_buf32[25] = 0;
4577 device_param->kernel_params_buf32[26] = 0;
4578 device_param->kernel_params_buf32[27] = 0;
4579 device_param->kernel_params_buf32[28] = 0;
4580 device_param->kernel_params_buf32[29] = 0;
4581 device_param->kernel_params_buf32[30] = 0;
4582 device_param->kernel_params_buf32[31] = 0;
4583
4584 data.dictfile = dictfile_old;
4585 data.dictfile2 = dictfile2_old;
4586 data.mask = mask_old;
4587 }
4588
4589 // hlfmt hashcat
4590
4591 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4592 {
4593 if (data.username == 0)
4594 {
4595 *hashbuf_pos = line_buf;
4596 *hashbuf_len = line_len;
4597 }
4598 else
4599 {
4600 char *pos = line_buf;
4601 int len = line_len;
4602
4603 for (int i = 0; i < line_len; i++, pos++, len--)
4604 {
4605 if (line_buf[i] == data.separator)
4606 {
4607 pos++;
4608
4609 len--;
4610
4611 break;
4612 }
4613 }
4614
4615 *hashbuf_pos = pos;
4616 *hashbuf_len = len;
4617 }
4618 }
4619
4620 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4621 {
4622 char *pos = NULL;
4623 int len = 0;
4624
4625 int sep_cnt = 0;
4626
4627 for (int i = 0; i < line_len; i++)
4628 {
4629 if (line_buf[i] == data.separator)
4630 {
4631 sep_cnt++;
4632
4633 continue;
4634 }
4635
4636 if (sep_cnt == 0)
4637 {
4638 if (pos == NULL) pos = line_buf + i;
4639
4640 len++;
4641 }
4642 }
4643
4644 *userbuf_pos = pos;
4645 *userbuf_len = len;
4646 }
4647
4648 // hlfmt pwdump
4649
4650 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
4651 {
4652 int sep_cnt = 0;
4653
4654 int sep2_len = 0;
4655 int sep3_len = 0;
4656
4657 for (int i = 0; i < line_len; i++)
4658 {
4659 if (line_buf[i] == ':')
4660 {
4661 sep_cnt++;
4662
4663 continue;
4664 }
4665
4666 if (sep_cnt == 2) sep2_len++;
4667 if (sep_cnt == 3) sep3_len++;
4668 }
4669
4670 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4671
4672 return 0;
4673 }
4674
4675 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4676 {
4677 char *pos = NULL;
4678 int len = 0;
4679
4680 int sep_cnt = 0;
4681
4682 for (int i = 0; i < line_len; i++)
4683 {
4684 if (line_buf[i] == ':')
4685 {
4686 sep_cnt++;
4687
4688 continue;
4689 }
4690
4691 if (data.hash_mode == 1000)
4692 {
4693 if (sep_cnt == 3)
4694 {
4695 if (pos == NULL) pos = line_buf + i;
4696
4697 len++;
4698 }
4699 }
4700 else if (data.hash_mode == 3000)
4701 {
4702 if (sep_cnt == 2)
4703 {
4704 if (pos == NULL) pos = line_buf + i;
4705
4706 len++;
4707 }
4708 }
4709 }
4710
4711 *hashbuf_pos = pos;
4712 *hashbuf_len = len;
4713 }
4714
4715 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4716 {
4717 char *pos = NULL;
4718 int len = 0;
4719
4720 int sep_cnt = 0;
4721
4722 for (int i = 0; i < line_len; i++)
4723 {
4724 if (line_buf[i] == ':')
4725 {
4726 sep_cnt++;
4727
4728 continue;
4729 }
4730
4731 if (sep_cnt == 0)
4732 {
4733 if (pos == NULL) pos = line_buf + i;
4734
4735 len++;
4736 }
4737 }
4738
4739 *userbuf_pos = pos;
4740 *userbuf_len = len;
4741 }
4742
4743 // hlfmt passwd
4744
4745 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
4746 {
4747 int sep_cnt = 0;
4748
4749 char sep5_first = 0;
4750 char sep6_first = 0;
4751
4752 for (int i = 0; i < line_len; i++)
4753 {
4754 if (line_buf[i] == ':')
4755 {
4756 sep_cnt++;
4757
4758 continue;
4759 }
4760
4761 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
4762 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
4763 }
4764
4765 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
4766
4767 return 0;
4768 }
4769
4770 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4771 {
4772 char *pos = NULL;
4773 int len = 0;
4774
4775 int sep_cnt = 0;
4776
4777 for (int i = 0; i < line_len; i++)
4778 {
4779 if (line_buf[i] == ':')
4780 {
4781 sep_cnt++;
4782
4783 continue;
4784 }
4785
4786 if (sep_cnt == 1)
4787 {
4788 if (pos == NULL) pos = line_buf + i;
4789
4790 len++;
4791 }
4792 }
4793
4794 *hashbuf_pos = pos;
4795 *hashbuf_len = len;
4796 }
4797
4798 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4799 {
4800 char *pos = NULL;
4801 int len = 0;
4802
4803 int sep_cnt = 0;
4804
4805 for (int i = 0; i < line_len; i++)
4806 {
4807 if (line_buf[i] == ':')
4808 {
4809 sep_cnt++;
4810
4811 continue;
4812 }
4813
4814 if (sep_cnt == 0)
4815 {
4816 if (pos == NULL) pos = line_buf + i;
4817
4818 len++;
4819 }
4820 }
4821
4822 *userbuf_pos = pos;
4823 *userbuf_len = len;
4824 }
4825
4826 // hlfmt shadow
4827
4828 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
4829 {
4830 int sep_cnt = 0;
4831
4832 for (int i = 0; i < line_len; i++)
4833 {
4834 if (line_buf[i] == ':') sep_cnt++;
4835 }
4836
4837 if (sep_cnt == 8) return 1;
4838
4839 return 0;
4840 }
4841
4842 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4843 {
4844 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
4845 }
4846
4847 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4848 {
4849 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
4850 }
4851
4852 // hlfmt main
4853
4854 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4855 {
4856 switch (hashfile_format)
4857 {
4858 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4859 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4860 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4861 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4862 }
4863 }
4864
4865 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4866 {
4867 switch (hashfile_format)
4868 {
4869 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
4870 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
4871 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
4872 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
4873 }
4874 }
4875
4876 static uint hlfmt_detect (FILE *fp, uint max_check)
4877 {
4878 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
4879
4880 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
4881 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
4882
4883 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
4884
4885 uint num_check = 0;
4886
4887 while (!feof (fp))
4888 {
4889 char line_buf[BUFSIZ];
4890
4891 int line_len = fgetl (fp, line_buf);
4892
4893 if (line_len == 0) continue;
4894
4895 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
4896 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
4897 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
4898
4899 if (num_check == max_check) break;
4900
4901 num_check++;
4902 }
4903
4904 uint hashlist_format = HLFMT_HASHCAT;
4905
4906 for (int i = 1; i < HLFMTS_CNT; i++)
4907 {
4908 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
4909
4910 hashlist_format = i;
4911 }
4912
4913 free (formats_cnt);
4914
4915 return hashlist_format;
4916 }
4917
4918 /**
4919 * some further helper function
4920 */
4921
4922 // wrapper around mymalloc for ADL
4923
4924 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
4925 {
4926 return mymalloc (iSize);
4927 }
4928
4929 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)
4930 {
4931 uint64_t collisions = 0;
4932
4933 const uint dgst_pos0 = data.dgst_pos0;
4934 const uint dgst_pos1 = data.dgst_pos1;
4935 const uint dgst_pos2 = data.dgst_pos2;
4936 const uint dgst_pos3 = data.dgst_pos3;
4937
4938 memset (bitmap_a, 0, bitmap_size);
4939 memset (bitmap_b, 0, bitmap_size);
4940 memset (bitmap_c, 0, bitmap_size);
4941 memset (bitmap_d, 0, bitmap_size);
4942
4943 for (uint i = 0; i < digests_cnt; i++)
4944 {
4945 uint *digest_ptr = (uint *) digests_buf_ptr;
4946
4947 digests_buf_ptr += dgst_size;
4948
4949 const uint val0 = 1 << (digest_ptr[dgst_pos0] & 0x1f);
4950 const uint val1 = 1 << (digest_ptr[dgst_pos1] & 0x1f);
4951 const uint val2 = 1 << (digest_ptr[dgst_pos2] & 0x1f);
4952 const uint val3 = 1 << (digest_ptr[dgst_pos3] & 0x1f);
4953
4954 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
4955 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
4956 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
4957 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
4958
4959 if (bitmap_a[idx0] & val0) collisions++;
4960 if (bitmap_b[idx1] & val1) collisions++;
4961 if (bitmap_c[idx2] & val2) collisions++;
4962 if (bitmap_d[idx3] & val3) collisions++;
4963
4964 bitmap_a[idx0] |= val0;
4965 bitmap_b[idx1] |= val1;
4966 bitmap_c[idx2] |= val2;
4967 bitmap_d[idx3] |= val3;
4968
4969 if (collisions >= collisions_max) return 0x7fffffff;
4970 }
4971
4972 return collisions;
4973 }
4974
4975 /**
4976 * main
4977 */
4978
4979 int main (int argc, char **argv)
4980 {
4981 /**
4982 * To help users a bit
4983 */
4984
4985 char *compute = getenv ("COMPUTE");
4986
4987 if (compute)
4988 {
4989 char display[100];
4990
4991 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
4992
4993 putenv (display);
4994 }
4995 else
4996 {
4997 if (getenv ("DISPLAY") == NULL)
4998 putenv ((char *) "DISPLAY=:0");
4999 }
5000
5001 /*
5002 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5003 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5004
5005 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5006 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5007 */
5008
5009 /**
5010 * Real init
5011 */
5012
5013 memset (&data, 0, sizeof (hc_global_data_t));
5014
5015 time_t proc_start;
5016
5017 time (&proc_start);
5018
5019 data.proc_start = proc_start;
5020
5021 int myargc = argc;
5022 char **myargv = argv;
5023
5024 hc_thread_mutex_init (mux_dispatcher);
5025 hc_thread_mutex_init (mux_counter);
5026 hc_thread_mutex_init (mux_display);
5027 hc_thread_mutex_init (mux_adl);
5028
5029 /**
5030 * commandline parameters
5031 */
5032
5033 uint usage = USAGE;
5034 uint version = VERSION;
5035 uint quiet = QUIET;
5036 uint benchmark = BENCHMARK;
5037 uint benchmark_mode = BENCHMARK_MODE;
5038 uint show = SHOW;
5039 uint left = LEFT;
5040 uint username = USERNAME;
5041 uint remove = REMOVE;
5042 uint remove_timer = REMOVE_TIMER;
5043 uint64_t skip = SKIP;
5044 uint64_t limit = LIMIT;
5045 uint keyspace = KEYSPACE;
5046 uint potfile_disable = POTFILE_DISABLE;
5047 uint debug_mode = DEBUG_MODE;
5048 char *debug_file = NULL;
5049 char *induction_dir = NULL;
5050 char *outfile_check_dir = NULL;
5051 uint force = FORCE;
5052 uint runtime = RUNTIME;
5053 uint hash_mode = HASH_MODE;
5054 uint attack_mode = ATTACK_MODE;
5055 uint markov_disable = MARKOV_DISABLE;
5056 uint markov_classic = MARKOV_CLASSIC;
5057 uint markov_threshold = MARKOV_THRESHOLD;
5058 char *markov_hcstat = NULL;
5059 char *outfile = NULL;
5060 uint outfile_format = OUTFILE_FORMAT;
5061 uint outfile_autohex = OUTFILE_AUTOHEX;
5062 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5063 uint restore = RESTORE;
5064 uint restore_timer = RESTORE_TIMER;
5065 uint restore_disable = RESTORE_DISABLE;
5066 uint status = STATUS;
5067 uint status_timer = STATUS_TIMER;
5068 uint status_automat = STATUS_AUTOMAT;
5069 uint loopback = LOOPBACK;
5070 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5071 char *session = NULL;
5072 uint hex_charset = HEX_CHARSET;
5073 uint hex_salt = HEX_SALT;
5074 uint hex_wordlist = HEX_WORDLIST;
5075 uint rp_gen = RP_GEN;
5076 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5077 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5078 uint rp_gen_seed = RP_GEN_SEED;
5079 char *rule_buf_l = (char *) RULE_BUF_L;
5080 char *rule_buf_r = (char *) RULE_BUF_R;
5081 uint increment = INCREMENT;
5082 uint increment_min = INCREMENT_MIN;
5083 uint increment_max = INCREMENT_MAX;
5084 char *cpu_affinity = NULL;
5085 char *opencl_devices = NULL;
5086 char *opencl_platform = NULL;
5087 char *truecrypt_keyfiles = NULL;
5088 uint workload_profile = WORKLOAD_PROFILE;
5089 uint kernel_accel = KERNEL_ACCEL;
5090 uint kernel_loops = KERNEL_LOOPS;
5091 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5092 uint gpu_temp_abort = GPU_TEMP_ABORT;
5093 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5094 uint powertune_enable = POWERTUNE_ENABLE;
5095 uint logfile_disable = LOGFILE_DISABLE;
5096 uint segment_size = SEGMENT_SIZE;
5097 uint scrypt_tmto = SCRYPT_TMTO;
5098 char separator = SEPARATOR;
5099 uint bitmap_min = BITMAP_MIN;
5100 uint bitmap_max = BITMAP_MAX;
5101 char *custom_charset_1 = NULL;
5102 char *custom_charset_2 = NULL;
5103 char *custom_charset_3 = NULL;
5104 char *custom_charset_4 = NULL;
5105
5106 #define IDX_HELP 'h'
5107 #define IDX_VERSION 'V'
5108 #define IDX_VERSION_LOWER 'v'
5109 #define IDX_QUIET 0xff02
5110 #define IDX_SHOW 0xff03
5111 #define IDX_LEFT 0xff04
5112 #define IDX_REMOVE 0xff05
5113 #define IDX_REMOVE_TIMER 0xff37
5114 #define IDX_SKIP 's'
5115 #define IDX_LIMIT 'l'
5116 #define IDX_KEYSPACE 0xff35
5117 #define IDX_POTFILE_DISABLE 0xff06
5118 #define IDX_DEBUG_MODE 0xff43
5119 #define IDX_DEBUG_FILE 0xff44
5120 #define IDX_INDUCTION_DIR 0xff46
5121 #define IDX_OUTFILE_CHECK_DIR 0xff47
5122 #define IDX_USERNAME 0xff07
5123 #define IDX_FORCE 0xff08
5124 #define IDX_RUNTIME 0xff09
5125 #define IDX_BENCHMARK 'b'
5126 #define IDX_BENCHMARK_MODE 0xff32
5127 #define IDX_HASH_MODE 'm'
5128 #define IDX_ATTACK_MODE 'a'
5129 #define IDX_RP_FILE 'r'
5130 #define IDX_RP_GEN 'g'
5131 #define IDX_RP_GEN_FUNC_MIN 0xff10
5132 #define IDX_RP_GEN_FUNC_MAX 0xff11
5133 #define IDX_RP_GEN_SEED 0xff34
5134 #define IDX_RULE_BUF_L 'j'
5135 #define IDX_RULE_BUF_R 'k'
5136 #define IDX_INCREMENT 'i'
5137 #define IDX_INCREMENT_MIN 0xff12
5138 #define IDX_INCREMENT_MAX 0xff13
5139 #define IDX_OUTFILE 'o'
5140 #define IDX_OUTFILE_FORMAT 0xff14
5141 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5142 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5143 #define IDX_RESTORE 0xff15
5144 #define IDX_RESTORE_DISABLE 0xff27
5145 #define IDX_STATUS 0xff17
5146 #define IDX_STATUS_TIMER 0xff18
5147 #define IDX_STATUS_AUTOMAT 0xff50
5148 #define IDX_LOOPBACK 0xff38
5149 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5150 #define IDX_SESSION 0xff19
5151 #define IDX_HEX_CHARSET 0xff20
5152 #define IDX_HEX_SALT 0xff21
5153 #define IDX_HEX_WORDLIST 0xff40
5154 #define IDX_MARKOV_DISABLE 0xff22
5155 #define IDX_MARKOV_CLASSIC 0xff23
5156 #define IDX_MARKOV_THRESHOLD 't'
5157 #define IDX_MARKOV_HCSTAT 0xff24
5158 #define IDX_CPU_AFFINITY 0xff25
5159 #define IDX_OPENCL_DEVICES 'd'
5160 #define IDX_OPENCL_PLATFORM 0xff72
5161 #define IDX_WORKLOAD_PROFILE 'w'
5162 #define IDX_KERNEL_ACCEL 'n'
5163 #define IDX_KERNEL_LOOPS 'u'
5164 #define IDX_GPU_TEMP_DISABLE 0xff29
5165 #define IDX_GPU_TEMP_ABORT 0xff30
5166 #define IDX_GPU_TEMP_RETAIN 0xff31
5167 #define IDX_POWERTUNE_ENABLE 0xff41
5168 #define IDX_LOGFILE_DISABLE 0xff51
5169 #define IDX_TRUECRYPT_KEYFILES 0xff52
5170 #define IDX_SCRYPT_TMTO 0xff61
5171 #define IDX_SEGMENT_SIZE 'c'
5172 #define IDX_SEPARATOR 'p'
5173 #define IDX_BITMAP_MIN 0xff70
5174 #define IDX_BITMAP_MAX 0xff71
5175 #define IDX_CUSTOM_CHARSET_1 '1'
5176 #define IDX_CUSTOM_CHARSET_2 '2'
5177 #define IDX_CUSTOM_CHARSET_3 '3'
5178 #define IDX_CUSTOM_CHARSET_4 '4'
5179
5180 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5181
5182 struct option long_options[] =
5183 {
5184 {"help", no_argument, 0, IDX_HELP},
5185 {"version", no_argument, 0, IDX_VERSION},
5186 {"quiet", no_argument, 0, IDX_QUIET},
5187 {"show", no_argument, 0, IDX_SHOW},
5188 {"left", no_argument, 0, IDX_LEFT},
5189 {"username", no_argument, 0, IDX_USERNAME},
5190 {"remove", no_argument, 0, IDX_REMOVE},
5191 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5192 {"skip", required_argument, 0, IDX_SKIP},
5193 {"limit", required_argument, 0, IDX_LIMIT},
5194 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5195 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5196 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5197 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5198 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5199 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5200 {"force", no_argument, 0, IDX_FORCE},
5201 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5202 {"benchmark-mode", required_argument, 0, IDX_BENCHMARK_MODE},
5203 {"restore", no_argument, 0, IDX_RESTORE},
5204 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5205 {"status", no_argument, 0, IDX_STATUS},
5206 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5207 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5208 {"loopback", no_argument, 0, IDX_LOOPBACK},
5209 {"weak-hash-threshold",
5210 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5211 {"session", required_argument, 0, IDX_SESSION},
5212 {"runtime", required_argument, 0, IDX_RUNTIME},
5213 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5214 {"generate-rules-func-min",
5215 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5216 {"generate-rules-func-max",
5217 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5218 {"generate-rules-seed",
5219 required_argument, 0, IDX_RP_GEN_SEED},
5220 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5221 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5222 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5223 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5224 {"rules-file", required_argument, 0, IDX_RP_FILE},
5225 {"outfile", required_argument, 0, IDX_OUTFILE},
5226 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5227 {"outfile-autohex-disable",
5228 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5229 {"outfile-check-timer",
5230 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5231 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5232 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5233 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5234 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5235 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5236 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5237 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5238 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5239 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5240 {"opencl-platform", required_argument, 0, IDX_OPENCL_PLATFORM},
5241 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5242 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5243 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5244 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5245 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5246 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5247 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5248 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5249 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5250 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5251 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5252 // deprecated
5253 {"seperator", required_argument, 0, IDX_SEPARATOR},
5254 {"separator", required_argument, 0, IDX_SEPARATOR},
5255 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5256 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5257 {"increment", no_argument, 0, IDX_INCREMENT},
5258 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5259 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5260 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5261 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5262 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5263 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5264
5265 {0, 0, 0, 0}
5266 };
5267
5268 uint rp_files_cnt = 0;
5269
5270 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5271
5272 int option_index;
5273 int c;
5274
5275 optind = 1;
5276 optopt = 0;
5277 option_index = 0;
5278
5279 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5280 {
5281 switch (c)
5282 {
5283 case IDX_HELP: usage = 1; break;
5284 case IDX_VERSION:
5285 case IDX_VERSION_LOWER: version = 1; break;
5286 case IDX_RESTORE: restore = 1; break;
5287 case IDX_SESSION: session = optarg; break;
5288 case IDX_SHOW: show = 1; break;
5289 case IDX_LEFT: left = 1; break;
5290 case '?': return (-1);
5291 }
5292 }
5293
5294 if (optopt != 0)
5295 {
5296 log_error ("ERROR: Invalid argument specified");
5297
5298 return (-1);
5299 }
5300
5301 /**
5302 * exit functions
5303 */
5304
5305 if (version)
5306 {
5307 log_info (VERSION_TXT);
5308
5309 return (0);
5310 }
5311
5312 if (usage)
5313 {
5314 usage_big_print (PROGNAME);
5315
5316 return (0);
5317 }
5318
5319 /**
5320 * session needs to be set, always!
5321 */
5322
5323 if (session == NULL) session = (char *) PROGNAME;
5324
5325 /**
5326 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5327 */
5328
5329 char *exec_path = get_exec_path ();
5330
5331 #ifdef LINUX
5332
5333 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5334 char *resolved_exec_path = realpath (exec_path, NULL);
5335
5336 char *install_dir = get_install_dir (resolved_exec_path);
5337 char *profile_dir = NULL;
5338 char *session_dir = NULL;
5339 char *shared_dir = NULL;
5340
5341 if (strcmp (install_dir, resolved_install_folder) == 0)
5342 {
5343 struct passwd *pw = getpwuid (getuid ());
5344
5345 const char *homedir = pw->pw_dir;
5346
5347 profile_dir = get_profile_dir (homedir);
5348 session_dir = get_session_dir (profile_dir);
5349 shared_dir = strdup (SHARED_FOLDER);
5350
5351 mkdir (profile_dir, 0700);
5352 mkdir (session_dir, 0700);
5353 }
5354 else
5355 {
5356 profile_dir = install_dir;
5357 session_dir = install_dir;
5358 shared_dir = install_dir;
5359 }
5360
5361 myfree (resolved_install_folder);
5362 myfree (resolved_exec_path);
5363
5364 #else
5365
5366 char *install_dir = get_install_dir (exec_path);
5367 char *profile_dir = install_dir;
5368 char *session_dir = install_dir;
5369 char *shared_dir = install_dir;
5370
5371 #endif
5372
5373 data.install_dir = install_dir;
5374 data.profile_dir = profile_dir;
5375 data.session_dir = session_dir;
5376 data.shared_dir = shared_dir;
5377
5378 myfree (exec_path);
5379
5380 /**
5381 * session
5382 */
5383
5384 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5385
5386 data.session = session;
5387
5388 char *eff_restore_file = (char *) mymalloc (session_size);
5389 char *new_restore_file = (char *) mymalloc (session_size);
5390
5391 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5392 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5393
5394 data.eff_restore_file = eff_restore_file;
5395 data.new_restore_file = new_restore_file;
5396
5397 if (((show == 1) || (left == 1)) && (restore == 1))
5398 {
5399 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5400 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5401
5402 return (-1);
5403 }
5404
5405 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5406 if ((show == 1) || (left == 1))
5407 {
5408 restore_disable = 1;
5409
5410 restore = 0;
5411 }
5412
5413 data.restore_disable = restore_disable;
5414
5415 restore_data_t *rd = init_restore (argc, argv);
5416
5417 data.rd = rd;
5418
5419 /**
5420 * restore file
5421 */
5422
5423 if (restore == 1)
5424 {
5425 read_restore (eff_restore_file, rd);
5426
5427 if (rd->version_bin < RESTORE_MIN)
5428 {
5429 log_error ("ERROR: Incompatible restore-file version");
5430
5431 return (-1);
5432 }
5433
5434 myargc = rd->argc;
5435 myargv = rd->argv;
5436
5437 #ifdef _POSIX
5438 rd->pid = getpid ();
5439 #elif _WIN
5440 rd->pid = GetCurrentProcessId ();
5441 #endif
5442 }
5443
5444 uint hash_mode_chgd = 0;
5445 uint runtime_chgd = 0;
5446 uint kernel_loops_chgd = 0;
5447 uint kernel_accel_chgd = 0;
5448 uint attack_mode_chgd = 0;
5449 uint outfile_format_chgd = 0;
5450 uint rp_gen_seed_chgd = 0;
5451 uint remove_timer_chgd = 0;
5452 uint increment_min_chgd = 0;
5453 uint increment_max_chgd = 0;
5454 uint gpu_temp_abort_chgd = 0;
5455 uint gpu_temp_retain_chgd = 0;
5456
5457 optind = 1;
5458 optopt = 0;
5459 option_index = 0;
5460
5461 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5462 {
5463 switch (c)
5464 {
5465 //case IDX_HELP: usage = 1; break;
5466 //case IDX_VERSION: version = 1; break;
5467 //case IDX_RESTORE: restore = 1; break;
5468 case IDX_QUIET: quiet = 1; break;
5469 //case IDX_SHOW: show = 1; break;
5470 case IDX_SHOW: break;
5471 //case IDX_LEFT: left = 1; break;
5472 case IDX_LEFT: break;
5473 case IDX_USERNAME: username = 1; break;
5474 case IDX_REMOVE: remove = 1; break;
5475 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5476 remove_timer_chgd = 1; break;
5477 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5478 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5479 case IDX_DEBUG_FILE: debug_file = optarg; break;
5480 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5481 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5482 case IDX_FORCE: force = 1; break;
5483 case IDX_SKIP: skip = atoll (optarg); break;
5484 case IDX_LIMIT: limit = atoll (optarg); break;
5485 case IDX_KEYSPACE: keyspace = 1; break;
5486 case IDX_BENCHMARK: benchmark = 1; break;
5487 case IDX_BENCHMARK_MODE: benchmark_mode = atoi (optarg); break;
5488 case IDX_RESTORE: break;
5489 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5490 case IDX_STATUS: status = 1; break;
5491 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5492 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5493 case IDX_LOOPBACK: loopback = 1; break;
5494 case IDX_WEAK_HASH_THRESHOLD:
5495 weak_hash_threshold = atoi (optarg); break;
5496 //case IDX_SESSION: session = optarg; break;
5497 case IDX_SESSION: break;
5498 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5499 hash_mode_chgd = 1; break;
5500 case IDX_RUNTIME: runtime = atoi (optarg);
5501 runtime_chgd = 1; break;
5502 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5503 attack_mode_chgd = 1; break;
5504 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5505 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5506 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5507 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5508 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5509 rp_gen_seed_chgd = 1; break;
5510 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5511 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5512 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5513 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5514 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5515 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5516 case IDX_OUTFILE: outfile = optarg; break;
5517 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5518 outfile_format_chgd = 1; break;
5519 case IDX_OUTFILE_AUTOHEX_DISABLE:
5520 outfile_autohex = 0; break;
5521 case IDX_OUTFILE_CHECK_TIMER:
5522 outfile_check_timer = atoi (optarg); break;
5523 case IDX_HEX_CHARSET: hex_charset = 1; break;
5524 case IDX_HEX_SALT: hex_salt = 1; break;
5525 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5526 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5527 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5528 case IDX_OPENCL_PLATFORM: opencl_platform = optarg; break;
5529 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg); break;
5530 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5531 kernel_accel_chgd = 1; break;
5532 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5533 kernel_loops_chgd = 1; break;
5534 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5535 case IDX_GPU_TEMP_ABORT: gpu_temp_abort_chgd = 1;
5536 gpu_temp_abort = atoi (optarg); break;
5537 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain_chgd = 1;
5538 gpu_temp_retain = atoi (optarg); break;
5539 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5540 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5541 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5542 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5543 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5544 case IDX_SEPARATOR: separator = optarg[0]; break;
5545 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5546 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5547 case IDX_INCREMENT: increment = 1; break;
5548 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5549 increment_min_chgd = 1; break;
5550 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5551 increment_max_chgd = 1; break;
5552 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5553 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5554 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5555 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5556
5557 default:
5558 log_error ("ERROR: Invalid argument specified");
5559 return (-1);
5560 }
5561 }
5562
5563 if (optopt != 0)
5564 {
5565 log_error ("ERROR: Invalid argument specified");
5566
5567 return (-1);
5568 }
5569
5570 /**
5571 * Inform user things getting started,
5572 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5573 * - we do not need to check algorithm_pos
5574 */
5575
5576 if (quiet == 0)
5577 {
5578 if (benchmark == 1)
5579 {
5580 log_info ("%s v%.2f starting in benchmark-mode...", PROGNAME, (float) VERSION_BIN / 100);
5581
5582 log_info ("");
5583 }
5584 else if (restore == 1)
5585 {
5586 log_info ("%s v%.2f starting in restore-mode...", PROGNAME, (float) VERSION_BIN / 100);
5587
5588 log_info ("");
5589 }
5590 else
5591 {
5592 log_info ("%s v%.2f starting...", PROGNAME, (float) VERSION_BIN / 100);
5593
5594 log_info ("");
5595 }
5596 }
5597
5598 /**
5599 * sanity check
5600 */
5601
5602 if (attack_mode > 7)
5603 {
5604 log_error ("ERROR: Invalid attack-mode specified");
5605
5606 return (-1);
5607 }
5608
5609 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5610 {
5611 log_error ("ERROR: Invalid runtime specified");
5612
5613 return (-1);
5614 }
5615
5616 if (hash_mode_chgd && hash_mode > 13000) // just added to remove compiler warnings for hash_mode_chgd
5617 {
5618 log_error ("ERROR: Invalid hash-type specified");
5619
5620 return (-1);
5621 }
5622
5623 // renamed hash modes
5624
5625 if (hash_mode_chgd)
5626 {
5627 int n = -1;
5628
5629 switch (hash_mode)
5630 {
5631 case 123: n = 124;
5632 break;
5633 }
5634
5635 if (n >= 0)
5636 {
5637 log_error ("Old -m specified, use -m %d instead", n);
5638
5639 return (-1);
5640 }
5641 }
5642
5643 if (username == 1)
5644 {
5645 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5646 {
5647 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5648
5649 return (-1);
5650 }
5651 }
5652
5653 if (outfile_format > 16)
5654 {
5655 log_error ("ERROR: Invalid outfile-format specified");
5656
5657 return (-1);
5658 }
5659
5660 if (left == 1)
5661 {
5662 if (outfile_format_chgd == 1)
5663 {
5664 if (outfile_format > 1)
5665 {
5666 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5667
5668 return (-1);
5669 }
5670 }
5671 else
5672 {
5673 outfile_format = OUTFILE_FMT_HASH;
5674 }
5675 }
5676
5677 if (show == 1)
5678 {
5679 if (outfile_format_chgd == 1)
5680 {
5681 if ((outfile_format > 7) && (outfile_format < 16))
5682 {
5683 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
5684
5685 return (-1);
5686 }
5687 }
5688 }
5689
5690 if (increment_min < INCREMENT_MIN)
5691 {
5692 log_error ("ERROR: Invalid increment-min specified");
5693
5694 return (-1);
5695 }
5696
5697 if (increment_max > INCREMENT_MAX)
5698 {
5699 log_error ("ERROR: Invalid increment-max specified");
5700
5701 return (-1);
5702 }
5703
5704 if (increment_min > increment_max)
5705 {
5706 log_error ("ERROR: Invalid increment-min specified");
5707
5708 return (-1);
5709 }
5710
5711 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
5712 {
5713 log_error ("ERROR: increment is not allowed in attack-mode 0");
5714
5715 return (-1);
5716 }
5717
5718 if ((increment == 0) && (increment_min_chgd == 1))
5719 {
5720 log_error ("ERROR: increment-min is only supported together with increment switch");
5721
5722 return (-1);
5723 }
5724
5725 if ((increment == 0) && (increment_max_chgd == 1))
5726 {
5727 log_error ("ERROR: increment-max is only supported together with increment switch");
5728
5729 return (-1);
5730 }
5731
5732 if (rp_files_cnt && rp_gen)
5733 {
5734 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
5735
5736 return (-1);
5737 }
5738
5739 if (rp_files_cnt || rp_gen)
5740 {
5741 if (attack_mode != ATTACK_MODE_STRAIGHT)
5742 {
5743 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
5744
5745 return (-1);
5746 }
5747 }
5748
5749 if (rp_gen_func_min > rp_gen_func_max)
5750 {
5751 log_error ("ERROR: Invalid rp-gen-func-min specified");
5752
5753 return (-1);
5754 }
5755
5756 if (kernel_accel_chgd == 1)
5757 {
5758 if (workload_profile != WORKLOAD_PROFILE)
5759 {
5760 log_error ("ERROR: kernel-accel parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5761
5762 return (-1);
5763 }
5764
5765 if (kernel_accel < 1)
5766 {
5767 log_error ("ERROR: Invalid kernel-accel specified");
5768
5769 return (-1);
5770 }
5771
5772 if (kernel_accel > 800)
5773 {
5774 log_error ("ERROR: Invalid kernel-accel specified");
5775
5776 return (-1);
5777 }
5778 }
5779
5780 if (kernel_loops_chgd == 1)
5781 {
5782 if (workload_profile != WORKLOAD_PROFILE)
5783 {
5784 log_error ("ERROR: kernel-loops parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5785
5786 return (-1);
5787 }
5788
5789 if (kernel_loops < 1)
5790 {
5791 log_error ("ERROR: Invalid kernel-loops specified");
5792
5793 return (-1);
5794 }
5795
5796 if (kernel_loops > 1024)
5797 {
5798 log_error ("ERROR: Invalid kernel-loops specified");
5799
5800 return (-1);
5801 }
5802 }
5803
5804 if (benchmark == 1)
5805 {
5806 if (workload_profile != WORKLOAD_PROFILE)
5807 {
5808 log_error ("ERROR: Using the workload-profile in benchmark mode is not allowed");
5809
5810 return (-1);
5811 }
5812 }
5813
5814 if ((workload_profile < 1) || (workload_profile > 3))
5815 {
5816 log_error ("ERROR: workload-profile %i not available", workload_profile);
5817
5818 return (-1);
5819 }
5820
5821 if (show == 1 || left == 1)
5822 {
5823 attack_mode = ATTACK_MODE_NONE;
5824
5825 if (remove == 1)
5826 {
5827 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
5828
5829 return (-1);
5830 }
5831
5832 if (potfile_disable == 1)
5833 {
5834 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
5835
5836 return (-1);
5837 }
5838 }
5839
5840 uint attack_kern = ATTACK_KERN_NONE;
5841
5842 switch (attack_mode)
5843 {
5844 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
5845 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
5846 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
5847 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
5848 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
5849 }
5850
5851 if (benchmark == 0)
5852 {
5853 if (keyspace == 1)
5854 {
5855 int num_additional_params = 1;
5856
5857 if (attack_kern == ATTACK_KERN_COMBI)
5858 {
5859 num_additional_params = 2;
5860 }
5861
5862 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
5863
5864 if (keyspace_wordlist_specified == 0) optind--;
5865 }
5866
5867 if (attack_kern == ATTACK_KERN_NONE)
5868 {
5869 if ((optind + 1) != myargc)
5870 {
5871 usage_mini_print (myargv[0]);
5872
5873 return (-1);
5874 }
5875 }
5876 else if (attack_kern == ATTACK_KERN_STRAIGHT)
5877 {
5878 if ((optind + 1) > myargc)
5879 {
5880 usage_mini_print (myargv[0]);
5881
5882 return (-1);
5883 }
5884 }
5885 else if (attack_kern == ATTACK_KERN_COMBI)
5886 {
5887 if ((optind + 3) != myargc)
5888 {
5889 usage_mini_print (myargv[0]);
5890
5891 return (-1);
5892 }
5893 }
5894 else if (attack_kern == ATTACK_KERN_BF)
5895 {
5896 if ((optind + 1) > myargc)
5897 {
5898 usage_mini_print (myargv[0]);
5899
5900 return (-1);
5901 }
5902 }
5903 else
5904 {
5905 usage_mini_print (myargv[0]);
5906
5907 return (-1);
5908 }
5909 }
5910 else
5911 {
5912 if (myargv[optind] != 0)
5913 {
5914 log_error ("ERROR: Invalid argument for benchmark mode specified");
5915
5916 return (-1);
5917 }
5918
5919 if (attack_mode_chgd == 1)
5920 {
5921 if (attack_mode != ATTACK_MODE_BF)
5922 {
5923 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
5924
5925 return (-1);
5926 }
5927 }
5928
5929 if (benchmark_mode == 0)
5930 {
5931 // nothing to do
5932 }
5933 else if (benchmark_mode == 1)
5934 {
5935 if (kernel_accel_chgd == 1 || kernel_loops_chgd == 1)
5936 {
5937 log_error ("ERROR: Benchmark-mode 1 does not allow kernel-accel or kernel-loops changed");
5938
5939 return (-1);
5940 }
5941 }
5942 else
5943 {
5944 log_error ("ERROR: Benchmark-mode must be 0 or 1");
5945
5946 return (-1);
5947 }
5948 }
5949
5950 if (skip != 0 && limit != 0)
5951 {
5952 limit += skip;
5953 }
5954
5955 if (keyspace == 1)
5956 {
5957 if (show == 1)
5958 {
5959 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
5960
5961 return (-1);
5962 }
5963 else if (left == 1)
5964 {
5965 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
5966
5967 return (-1);
5968 }
5969
5970 potfile_disable = 1;
5971
5972 restore_disable = 1;
5973
5974 restore = 0;
5975
5976 weak_hash_threshold = 0;
5977
5978 quiet = 1;
5979 }
5980
5981 if (remove_timer_chgd == 1)
5982 {
5983 if (remove == 0)
5984 {
5985 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
5986
5987 return (-1);
5988 }
5989
5990 if (remove_timer < 1)
5991 {
5992 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
5993
5994 return (-1);
5995 }
5996 }
5997
5998 if (loopback == 1)
5999 {
6000 if (attack_mode == ATTACK_MODE_BF)
6001 {
6002 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6003
6004 return (-1);
6005 }
6006 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6007 {
6008 if ((rp_files_cnt == 0) && (rp_gen == 0))
6009 {
6010 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6011
6012 return (-1);
6013 }
6014 }
6015 }
6016
6017 if (debug_mode > 0)
6018 {
6019 if (attack_mode != ATTACK_MODE_STRAIGHT)
6020 {
6021 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6022
6023 return (-1);
6024 }
6025
6026 if ((rp_files_cnt == 0) && (rp_gen == 0))
6027 {
6028 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6029
6030 return (-1);
6031 }
6032 }
6033
6034 if (debug_mode > 4)
6035 {
6036 log_error ("ERROR: Invalid debug-mode specified");
6037
6038 return (-1);
6039 }
6040
6041 if (debug_file != NULL)
6042 {
6043 if (debug_mode < 1)
6044 {
6045 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6046
6047 return (-1);
6048 }
6049 }
6050
6051 if (induction_dir != NULL)
6052 {
6053 if (attack_mode == ATTACK_MODE_BF)
6054 {
6055 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6056
6057 return (-1);
6058 }
6059 }
6060
6061 /**
6062 * induction directory
6063 */
6064
6065 char *induction_directory = NULL;
6066
6067 if (attack_mode != ATTACK_MODE_BF)
6068 {
6069 if (induction_dir == NULL)
6070 {
6071 induction_directory = (char *) mymalloc (session_size);
6072
6073 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6074
6075 // create induction folder if it does not already exist
6076
6077 if (keyspace == 0)
6078 {
6079 if (rmdir (induction_directory) == -1)
6080 {
6081 if (errno == ENOENT)
6082 {
6083 // good, we can ignore
6084 }
6085 else if (errno == ENOTEMPTY)
6086 {
6087 char *induction_directory_mv = (char *) mymalloc (session_size);
6088
6089 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6090
6091 if (rename (induction_directory, induction_directory_mv) != 0)
6092 {
6093 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6094
6095 return (-1);
6096 }
6097 }
6098 else
6099 {
6100 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6101
6102 return (-1);
6103 }
6104 }
6105
6106 if (mkdir (induction_directory, 0700) == -1)
6107 {
6108 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6109
6110 return (-1);
6111 }
6112 }
6113 }
6114 else
6115 {
6116 induction_directory = induction_dir;
6117 }
6118 }
6119
6120 data.induction_directory = induction_directory;
6121
6122 /**
6123 * loopback
6124 */
6125
6126 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6127
6128 char *loopback_file = (char *) mymalloc (loopback_size);
6129
6130 /**
6131 * outfile-check directory
6132 */
6133
6134 char *outfile_check_directory = NULL;
6135
6136 if (outfile_check_dir == NULL)
6137 {
6138 outfile_check_directory = (char *) mymalloc (session_size);
6139
6140 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6141 }
6142 else
6143 {
6144 outfile_check_directory = outfile_check_dir;
6145 }
6146
6147 data.outfile_check_directory = outfile_check_directory;
6148
6149 if (keyspace == 0)
6150 {
6151 struct stat outfile_check_stat;
6152
6153 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6154 {
6155 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6156
6157 if (is_dir == 0)
6158 {
6159 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6160
6161 return (-1);
6162 }
6163 }
6164 else if (outfile_check_dir == NULL)
6165 {
6166 if (mkdir (outfile_check_directory, 0700) == -1)
6167 {
6168 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6169
6170 return (-1);
6171 }
6172 }
6173 }
6174
6175 /**
6176 * special other stuff
6177 */
6178
6179 if (hash_mode == 9710)
6180 {
6181 outfile_format = 5;
6182 outfile_format_chgd = 1;
6183 }
6184
6185 if (hash_mode == 9810)
6186 {
6187 outfile_format = 5;
6188 outfile_format_chgd = 1;
6189 }
6190
6191 if (hash_mode == 10410)
6192 {
6193 outfile_format = 5;
6194 outfile_format_chgd = 1;
6195 }
6196
6197 /**
6198 * store stuff
6199 */
6200
6201 data.hash_mode = hash_mode;
6202 data.restore = restore;
6203 data.restore_timer = restore_timer;
6204 data.restore_disable = restore_disable;
6205 data.status = status;
6206 data.status_timer = status_timer;
6207 data.status_automat = status_automat;
6208 data.loopback = loopback;
6209 data.runtime = runtime;
6210 data.remove = remove;
6211 data.remove_timer = remove_timer;
6212 data.debug_mode = debug_mode;
6213 data.debug_file = debug_file;
6214 data.username = username;
6215 data.quiet = quiet;
6216 data.outfile = outfile;
6217 data.outfile_format = outfile_format;
6218 data.outfile_autohex = outfile_autohex;
6219 data.hex_charset = hex_charset;
6220 data.hex_salt = hex_salt;
6221 data.hex_wordlist = hex_wordlist;
6222 data.separator = separator;
6223 data.rp_files = rp_files;
6224 data.rp_files_cnt = rp_files_cnt;
6225 data.rp_gen = rp_gen;
6226 data.rp_gen_seed = rp_gen_seed;
6227 data.force = force;
6228 data.benchmark = benchmark;
6229 data.skip = skip;
6230 data.limit = limit;
6231 data.powertune_enable = powertune_enable;
6232 data.logfile_disable = logfile_disable;
6233 data.truecrypt_keyfiles = truecrypt_keyfiles;
6234 data.scrypt_tmto = scrypt_tmto;
6235
6236 /**
6237 * cpu affinity
6238 */
6239
6240 if (cpu_affinity)
6241 {
6242 set_cpu_affinity (cpu_affinity);
6243 }
6244
6245 if (rp_gen_seed_chgd == 0)
6246 {
6247 srand (proc_start);
6248 }
6249 else
6250 {
6251 srand (rp_gen_seed);
6252 }
6253
6254 /**
6255 * logfile init
6256 */
6257
6258 if (logfile_disable == 0)
6259 {
6260 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6261
6262 char *logfile = (char *) mymalloc (logfile_size);
6263
6264 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6265
6266 data.logfile = logfile;
6267
6268 char *topid = logfile_generate_topid ();
6269
6270 data.topid = topid;
6271 }
6272
6273 // logfile_append() checks for logfile_disable internally to make it easier from here
6274
6275 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6276 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6277 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6278 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6279 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6280 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6281 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6282 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6283 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6284 #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));
6285
6286 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6287 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6288 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6289 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6290 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6291 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6292 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6293 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6294
6295 logfile_top_msg ("START");
6296
6297 logfile_top_uint (attack_mode);
6298 logfile_top_uint (attack_kern);
6299 logfile_top_uint (benchmark);
6300 logfile_top_uint (benchmark_mode);
6301 logfile_top_uint (bitmap_min);
6302 logfile_top_uint (bitmap_max);
6303 logfile_top_uint (debug_mode);
6304 logfile_top_uint (force);
6305 logfile_top_uint (kernel_accel);
6306 logfile_top_uint (kernel_loops);
6307 logfile_top_uint (gpu_temp_abort);
6308 logfile_top_uint (gpu_temp_disable);
6309 logfile_top_uint (gpu_temp_retain);
6310 logfile_top_uint (hash_mode);
6311 logfile_top_uint (hex_charset);
6312 logfile_top_uint (hex_salt);
6313 logfile_top_uint (hex_wordlist);
6314 logfile_top_uint (increment);
6315 logfile_top_uint (increment_max);
6316 logfile_top_uint (increment_min);
6317 logfile_top_uint (keyspace);
6318 logfile_top_uint (left);
6319 logfile_top_uint (logfile_disable);
6320 logfile_top_uint (loopback);
6321 logfile_top_uint (markov_classic);
6322 logfile_top_uint (markov_disable);
6323 logfile_top_uint (markov_threshold);
6324 logfile_top_uint (outfile_autohex);
6325 logfile_top_uint (outfile_check_timer);
6326 logfile_top_uint (outfile_format);
6327 logfile_top_uint (potfile_disable);
6328 logfile_top_uint (powertune_enable);
6329 logfile_top_uint (scrypt_tmto);
6330 logfile_top_uint (quiet);
6331 logfile_top_uint (remove);
6332 logfile_top_uint (remove_timer);
6333 logfile_top_uint (restore);
6334 logfile_top_uint (restore_disable);
6335 logfile_top_uint (restore_timer);
6336 logfile_top_uint (rp_gen);
6337 logfile_top_uint (rp_gen_func_max);
6338 logfile_top_uint (rp_gen_func_min);
6339 logfile_top_uint (rp_gen_seed);
6340 logfile_top_uint (runtime);
6341 logfile_top_uint (segment_size);
6342 logfile_top_uint (show);
6343 logfile_top_uint (status);
6344 logfile_top_uint (status_automat);
6345 logfile_top_uint (status_timer);
6346 logfile_top_uint (usage);
6347 logfile_top_uint (username);
6348 logfile_top_uint (version);
6349 logfile_top_uint (weak_hash_threshold);
6350 logfile_top_uint (workload_profile);
6351 logfile_top_uint64 (limit);
6352 logfile_top_uint64 (skip);
6353 logfile_top_char (separator);
6354 logfile_top_string (cpu_affinity);
6355 logfile_top_string (custom_charset_1);
6356 logfile_top_string (custom_charset_2);
6357 logfile_top_string (custom_charset_3);
6358 logfile_top_string (custom_charset_4);
6359 logfile_top_string (debug_file);
6360 logfile_top_string (opencl_devices);
6361 logfile_top_string (opencl_platform);
6362 logfile_top_string (induction_dir);
6363 logfile_top_string (markov_hcstat);
6364 logfile_top_string (outfile);
6365 logfile_top_string (outfile_check_dir);
6366 logfile_top_string (rule_buf_l);
6367 logfile_top_string (rule_buf_r);
6368 logfile_top_string (session);
6369 logfile_top_string (truecrypt_keyfiles);
6370
6371 /**
6372 * devices
6373 */
6374
6375 uint opencl_devicemask = devices_to_devicemask (opencl_devices);
6376
6377 /**
6378 * benchmark
6379 */
6380
6381 if (benchmark == 1)
6382 {
6383 /**
6384 * disable useless stuff for benchmark
6385 */
6386
6387 restore_timer = 0;
6388 status_timer = 0;
6389 restore_disable = 1;
6390 potfile_disable = 1;
6391 weak_hash_threshold = 0;
6392
6393 data.restore_timer = restore_timer;
6394 data.status_timer = status_timer;
6395 data.restore_disable = restore_disable;
6396
6397 if (benchmark_mode == 1)
6398 {
6399 markov_disable = 1;
6400 }
6401
6402 /**
6403 * force attack mode to be bruteforce
6404 */
6405
6406 attack_mode = ATTACK_MODE_BF;
6407 attack_kern = ATTACK_KERN_BF;
6408
6409 if (runtime_chgd == 0)
6410 {
6411 runtime = 4;
6412
6413 if (benchmark_mode == 1) runtime = 17;
6414
6415 data.runtime = runtime;
6416 }
6417 }
6418
6419 /**
6420 * config
6421 */
6422
6423 uint hash_type = 0;
6424 uint salt_type = 0;
6425 uint attack_exec = 0;
6426 uint opts_type = 0;
6427 uint kern_type = 0;
6428 uint dgst_size = 0;
6429 uint esalt_size = 0;
6430 uint opti_type = 0;
6431 uint dgst_pos0 = -1;
6432 uint dgst_pos1 = -1;
6433 uint dgst_pos2 = -1;
6434 uint dgst_pos3 = -1;
6435
6436 int (*parse_func) (char *, uint, hash_t *);
6437 int (*sort_by_digest) (const void *, const void *);
6438
6439 uint algorithm_pos = 0;
6440 uint algorithm_max = 1;
6441
6442 uint *algorithms = default_benchmark_algorithms;
6443
6444 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6445
6446 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6447 {
6448 /*
6449 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6450 * the following algos are skipped entirely
6451 */
6452
6453 if (algorithm_pos > 0)
6454 {
6455 local_free (rd);
6456
6457 rd = init_restore (argc, argv);
6458
6459 data.rd = rd;
6460 }
6461
6462 /**
6463 * update hash_mode in case of multihash benchmark
6464 */
6465
6466 if (benchmark == 1)
6467 {
6468 if (hash_mode_chgd == 0)
6469 {
6470 hash_mode = algorithms[algorithm_pos];
6471
6472 data.hash_mode = hash_mode;
6473 }
6474
6475 quiet = 1;
6476
6477 data.quiet = quiet;
6478 }
6479
6480 switch (hash_mode)
6481 {
6482 case 0: hash_type = HASH_TYPE_MD5;
6483 salt_type = SALT_TYPE_NONE;
6484 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6485 opts_type = OPTS_TYPE_PT_GENERATE_LE
6486 | OPTS_TYPE_PT_ADD80
6487 | OPTS_TYPE_PT_ADDBITS14;
6488 kern_type = KERN_TYPE_MD5;
6489 dgst_size = DGST_SIZE_4_4;
6490 parse_func = md5_parse_hash;
6491 sort_by_digest = sort_by_digest_4_4;
6492 opti_type = OPTI_TYPE_ZERO_BYTE
6493 | OPTI_TYPE_PRECOMPUTE_INIT
6494 | OPTI_TYPE_PRECOMPUTE_MERKLE
6495 | OPTI_TYPE_MEET_IN_MIDDLE
6496 | OPTI_TYPE_EARLY_SKIP
6497 | OPTI_TYPE_NOT_ITERATED
6498 | OPTI_TYPE_NOT_SALTED
6499 | OPTI_TYPE_RAW_HASH;
6500 dgst_pos0 = 0;
6501 dgst_pos1 = 3;
6502 dgst_pos2 = 2;
6503 dgst_pos3 = 1;
6504 break;
6505
6506 case 10: hash_type = HASH_TYPE_MD5;
6507 salt_type = SALT_TYPE_INTERN;
6508 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6509 opts_type = OPTS_TYPE_PT_GENERATE_LE
6510 | OPTS_TYPE_ST_ADD80
6511 | OPTS_TYPE_ST_ADDBITS14;
6512 kern_type = KERN_TYPE_MD5_PWSLT;
6513 dgst_size = DGST_SIZE_4_4;
6514 parse_func = md5s_parse_hash;
6515 sort_by_digest = sort_by_digest_4_4;
6516 opti_type = OPTI_TYPE_ZERO_BYTE
6517 | OPTI_TYPE_PRECOMPUTE_INIT
6518 | OPTI_TYPE_PRECOMPUTE_MERKLE
6519 | OPTI_TYPE_MEET_IN_MIDDLE
6520 | OPTI_TYPE_EARLY_SKIP
6521 | OPTI_TYPE_NOT_ITERATED
6522 | OPTI_TYPE_APPENDED_SALT
6523 | OPTI_TYPE_RAW_HASH;
6524 dgst_pos0 = 0;
6525 dgst_pos1 = 3;
6526 dgst_pos2 = 2;
6527 dgst_pos3 = 1;
6528 break;
6529
6530 case 11: hash_type = HASH_TYPE_MD5;
6531 salt_type = SALT_TYPE_INTERN;
6532 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6533 opts_type = OPTS_TYPE_PT_GENERATE_LE
6534 | OPTS_TYPE_ST_ADD80
6535 | OPTS_TYPE_ST_ADDBITS14;
6536 kern_type = KERN_TYPE_MD5_PWSLT;
6537 dgst_size = DGST_SIZE_4_4;
6538 parse_func = joomla_parse_hash;
6539 sort_by_digest = sort_by_digest_4_4;
6540 opti_type = OPTI_TYPE_ZERO_BYTE
6541 | OPTI_TYPE_PRECOMPUTE_INIT
6542 | OPTI_TYPE_PRECOMPUTE_MERKLE
6543 | OPTI_TYPE_MEET_IN_MIDDLE
6544 | OPTI_TYPE_EARLY_SKIP
6545 | OPTI_TYPE_NOT_ITERATED
6546 | OPTI_TYPE_APPENDED_SALT
6547 | OPTI_TYPE_RAW_HASH;
6548 dgst_pos0 = 0;
6549 dgst_pos1 = 3;
6550 dgst_pos2 = 2;
6551 dgst_pos3 = 1;
6552 break;
6553
6554 case 12: hash_type = HASH_TYPE_MD5;
6555 salt_type = SALT_TYPE_INTERN;
6556 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6557 opts_type = OPTS_TYPE_PT_GENERATE_LE
6558 | OPTS_TYPE_ST_ADD80
6559 | OPTS_TYPE_ST_ADDBITS14;
6560 kern_type = KERN_TYPE_MD5_PWSLT;
6561 dgst_size = DGST_SIZE_4_4;
6562 parse_func = postgresql_parse_hash;
6563 sort_by_digest = sort_by_digest_4_4;
6564 opti_type = OPTI_TYPE_ZERO_BYTE
6565 | OPTI_TYPE_PRECOMPUTE_INIT
6566 | OPTI_TYPE_PRECOMPUTE_MERKLE
6567 | OPTI_TYPE_MEET_IN_MIDDLE
6568 | OPTI_TYPE_EARLY_SKIP
6569 | OPTI_TYPE_NOT_ITERATED
6570 | OPTI_TYPE_APPENDED_SALT
6571 | OPTI_TYPE_RAW_HASH;
6572 dgst_pos0 = 0;
6573 dgst_pos1 = 3;
6574 dgst_pos2 = 2;
6575 dgst_pos3 = 1;
6576 break;
6577
6578 case 20: hash_type = HASH_TYPE_MD5;
6579 salt_type = SALT_TYPE_INTERN;
6580 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6581 opts_type = OPTS_TYPE_PT_GENERATE_LE
6582 | OPTS_TYPE_PT_ADD80
6583 | OPTS_TYPE_PT_ADDBITS14;
6584 kern_type = KERN_TYPE_MD5_SLTPW;
6585 dgst_size = DGST_SIZE_4_4;
6586 parse_func = md5s_parse_hash;
6587 sort_by_digest = sort_by_digest_4_4;
6588 opti_type = OPTI_TYPE_ZERO_BYTE
6589 | OPTI_TYPE_PRECOMPUTE_INIT
6590 | OPTI_TYPE_PRECOMPUTE_MERKLE
6591 | OPTI_TYPE_EARLY_SKIP
6592 | OPTI_TYPE_NOT_ITERATED
6593 | OPTI_TYPE_PREPENDED_SALT
6594 | OPTI_TYPE_RAW_HASH;
6595 dgst_pos0 = 0;
6596 dgst_pos1 = 3;
6597 dgst_pos2 = 2;
6598 dgst_pos3 = 1;
6599 break;
6600
6601 case 21: hash_type = HASH_TYPE_MD5;
6602 salt_type = SALT_TYPE_INTERN;
6603 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6604 opts_type = OPTS_TYPE_PT_GENERATE_LE
6605 | OPTS_TYPE_PT_ADD80
6606 | OPTS_TYPE_PT_ADDBITS14;
6607 kern_type = KERN_TYPE_MD5_SLTPW;
6608 dgst_size = DGST_SIZE_4_4;
6609 parse_func = osc_parse_hash;
6610 sort_by_digest = sort_by_digest_4_4;
6611 opti_type = OPTI_TYPE_ZERO_BYTE
6612 | OPTI_TYPE_PRECOMPUTE_INIT
6613 | OPTI_TYPE_PRECOMPUTE_MERKLE
6614 | OPTI_TYPE_EARLY_SKIP
6615 | OPTI_TYPE_NOT_ITERATED
6616 | OPTI_TYPE_PREPENDED_SALT
6617 | OPTI_TYPE_RAW_HASH;
6618 dgst_pos0 = 0;
6619 dgst_pos1 = 3;
6620 dgst_pos2 = 2;
6621 dgst_pos3 = 1;
6622 break;
6623
6624 case 22: hash_type = HASH_TYPE_MD5;
6625 salt_type = SALT_TYPE_EMBEDDED;
6626 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6627 opts_type = OPTS_TYPE_PT_GENERATE_LE
6628 | OPTS_TYPE_PT_ADD80
6629 | OPTS_TYPE_PT_ADDBITS14;
6630 kern_type = KERN_TYPE_MD5_SLTPW;
6631 dgst_size = DGST_SIZE_4_4;
6632 parse_func = netscreen_parse_hash;
6633 sort_by_digest = sort_by_digest_4_4;
6634 opti_type = OPTI_TYPE_ZERO_BYTE
6635 | OPTI_TYPE_PRECOMPUTE_INIT
6636 | OPTI_TYPE_PRECOMPUTE_MERKLE
6637 | OPTI_TYPE_EARLY_SKIP
6638 | OPTI_TYPE_NOT_ITERATED
6639 | OPTI_TYPE_PREPENDED_SALT
6640 | OPTI_TYPE_RAW_HASH;
6641 dgst_pos0 = 0;
6642 dgst_pos1 = 3;
6643 dgst_pos2 = 2;
6644 dgst_pos3 = 1;
6645 break;
6646
6647 case 23: hash_type = HASH_TYPE_MD5;
6648 salt_type = SALT_TYPE_EMBEDDED;
6649 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6650 opts_type = OPTS_TYPE_PT_GENERATE_LE
6651 | OPTS_TYPE_PT_ADD80
6652 | OPTS_TYPE_PT_ADDBITS14;
6653 kern_type = KERN_TYPE_MD5_SLTPW;
6654 dgst_size = DGST_SIZE_4_4;
6655 parse_func = skype_parse_hash;
6656 sort_by_digest = sort_by_digest_4_4;
6657 opti_type = OPTI_TYPE_ZERO_BYTE
6658 | OPTI_TYPE_PRECOMPUTE_INIT
6659 | OPTI_TYPE_PRECOMPUTE_MERKLE
6660 | OPTI_TYPE_EARLY_SKIP
6661 | OPTI_TYPE_NOT_ITERATED
6662 | OPTI_TYPE_PREPENDED_SALT
6663 | OPTI_TYPE_RAW_HASH;
6664 dgst_pos0 = 0;
6665 dgst_pos1 = 3;
6666 dgst_pos2 = 2;
6667 dgst_pos3 = 1;
6668 break;
6669
6670 case 30: hash_type = HASH_TYPE_MD5;
6671 salt_type = SALT_TYPE_INTERN;
6672 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6673 opts_type = OPTS_TYPE_PT_GENERATE_LE
6674 | OPTS_TYPE_PT_UNICODE
6675 | OPTS_TYPE_ST_ADD80
6676 | OPTS_TYPE_ST_ADDBITS14;
6677 kern_type = KERN_TYPE_MD5_PWUSLT;
6678 dgst_size = DGST_SIZE_4_4;
6679 parse_func = md5s_parse_hash;
6680 sort_by_digest = sort_by_digest_4_4;
6681 opti_type = OPTI_TYPE_ZERO_BYTE
6682 | OPTI_TYPE_PRECOMPUTE_INIT
6683 | OPTI_TYPE_PRECOMPUTE_MERKLE
6684 | OPTI_TYPE_MEET_IN_MIDDLE
6685 | OPTI_TYPE_EARLY_SKIP
6686 | OPTI_TYPE_NOT_ITERATED
6687 | OPTI_TYPE_APPENDED_SALT
6688 | OPTI_TYPE_RAW_HASH;
6689 dgst_pos0 = 0;
6690 dgst_pos1 = 3;
6691 dgst_pos2 = 2;
6692 dgst_pos3 = 1;
6693 break;
6694
6695 case 40: hash_type = HASH_TYPE_MD5;
6696 salt_type = SALT_TYPE_INTERN;
6697 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6698 opts_type = OPTS_TYPE_PT_GENERATE_LE
6699 | OPTS_TYPE_PT_ADD80
6700 | OPTS_TYPE_PT_ADDBITS14
6701 | OPTS_TYPE_PT_UNICODE;
6702 kern_type = KERN_TYPE_MD5_SLTPWU;
6703 dgst_size = DGST_SIZE_4_4;
6704 parse_func = md5s_parse_hash;
6705 sort_by_digest = sort_by_digest_4_4;
6706 opti_type = OPTI_TYPE_ZERO_BYTE
6707 | OPTI_TYPE_PRECOMPUTE_INIT
6708 | OPTI_TYPE_PRECOMPUTE_MERKLE
6709 | OPTI_TYPE_EARLY_SKIP
6710 | OPTI_TYPE_NOT_ITERATED
6711 | OPTI_TYPE_PREPENDED_SALT
6712 | OPTI_TYPE_RAW_HASH;
6713 dgst_pos0 = 0;
6714 dgst_pos1 = 3;
6715 dgst_pos2 = 2;
6716 dgst_pos3 = 1;
6717 break;
6718
6719 case 50: hash_type = HASH_TYPE_MD5;
6720 salt_type = SALT_TYPE_INTERN;
6721 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6722 opts_type = OPTS_TYPE_PT_GENERATE_LE
6723 | OPTS_TYPE_ST_ADD80
6724 | OPTS_TYPE_ST_ADDBITS14;
6725 kern_type = KERN_TYPE_HMACMD5_PW;
6726 dgst_size = DGST_SIZE_4_4;
6727 parse_func = hmacmd5_parse_hash;
6728 sort_by_digest = sort_by_digest_4_4;
6729 opti_type = OPTI_TYPE_ZERO_BYTE
6730 | OPTI_TYPE_NOT_ITERATED;
6731 dgst_pos0 = 0;
6732 dgst_pos1 = 3;
6733 dgst_pos2 = 2;
6734 dgst_pos3 = 1;
6735 break;
6736
6737 case 60: hash_type = HASH_TYPE_MD5;
6738 salt_type = SALT_TYPE_INTERN;
6739 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6740 opts_type = OPTS_TYPE_PT_GENERATE_LE
6741 | OPTS_TYPE_PT_ADD80
6742 | OPTS_TYPE_PT_ADDBITS14;
6743 kern_type = KERN_TYPE_HMACMD5_SLT;
6744 dgst_size = DGST_SIZE_4_4;
6745 parse_func = hmacmd5_parse_hash;
6746 sort_by_digest = sort_by_digest_4_4;
6747 opti_type = OPTI_TYPE_ZERO_BYTE
6748 | OPTI_TYPE_NOT_ITERATED;
6749 dgst_pos0 = 0;
6750 dgst_pos1 = 3;
6751 dgst_pos2 = 2;
6752 dgst_pos3 = 1;
6753 break;
6754
6755 case 100: hash_type = HASH_TYPE_SHA1;
6756 salt_type = SALT_TYPE_NONE;
6757 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6758 opts_type = OPTS_TYPE_PT_GENERATE_BE
6759 | OPTS_TYPE_PT_ADD80
6760 | OPTS_TYPE_PT_ADDBITS15;
6761 kern_type = KERN_TYPE_SHA1;
6762 dgst_size = DGST_SIZE_4_5;
6763 parse_func = sha1_parse_hash;
6764 sort_by_digest = sort_by_digest_4_5;
6765 opti_type = OPTI_TYPE_ZERO_BYTE
6766 | OPTI_TYPE_PRECOMPUTE_INIT
6767 | OPTI_TYPE_PRECOMPUTE_MERKLE
6768 | OPTI_TYPE_EARLY_SKIP
6769 | OPTI_TYPE_NOT_ITERATED
6770 | OPTI_TYPE_NOT_SALTED
6771 | OPTI_TYPE_RAW_HASH;
6772 dgst_pos0 = 3;
6773 dgst_pos1 = 4;
6774 dgst_pos2 = 2;
6775 dgst_pos3 = 1;
6776 break;
6777
6778 case 101: hash_type = HASH_TYPE_SHA1;
6779 salt_type = SALT_TYPE_NONE;
6780 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6781 opts_type = OPTS_TYPE_PT_GENERATE_BE
6782 | OPTS_TYPE_PT_ADD80
6783 | OPTS_TYPE_PT_ADDBITS15;
6784 kern_type = KERN_TYPE_SHA1;
6785 dgst_size = DGST_SIZE_4_5;
6786 parse_func = sha1b64_parse_hash;
6787 sort_by_digest = sort_by_digest_4_5;
6788 opti_type = OPTI_TYPE_ZERO_BYTE
6789 | OPTI_TYPE_PRECOMPUTE_INIT
6790 | OPTI_TYPE_PRECOMPUTE_MERKLE
6791 | OPTI_TYPE_EARLY_SKIP
6792 | OPTI_TYPE_NOT_ITERATED
6793 | OPTI_TYPE_NOT_SALTED
6794 | OPTI_TYPE_RAW_HASH;
6795 dgst_pos0 = 3;
6796 dgst_pos1 = 4;
6797 dgst_pos2 = 2;
6798 dgst_pos3 = 1;
6799 break;
6800
6801 case 110: hash_type = HASH_TYPE_SHA1;
6802 salt_type = SALT_TYPE_INTERN;
6803 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6804 opts_type = OPTS_TYPE_PT_GENERATE_BE
6805 | OPTS_TYPE_ST_ADD80
6806 | OPTS_TYPE_ST_ADDBITS15;
6807 kern_type = KERN_TYPE_SHA1_PWSLT;
6808 dgst_size = DGST_SIZE_4_5;
6809 parse_func = sha1s_parse_hash;
6810 sort_by_digest = sort_by_digest_4_5;
6811 opti_type = OPTI_TYPE_ZERO_BYTE
6812 | OPTI_TYPE_PRECOMPUTE_INIT
6813 | OPTI_TYPE_PRECOMPUTE_MERKLE
6814 | OPTI_TYPE_EARLY_SKIP
6815 | OPTI_TYPE_NOT_ITERATED
6816 | OPTI_TYPE_APPENDED_SALT
6817 | OPTI_TYPE_RAW_HASH;
6818 dgst_pos0 = 3;
6819 dgst_pos1 = 4;
6820 dgst_pos2 = 2;
6821 dgst_pos3 = 1;
6822 break;
6823
6824 case 111: hash_type = HASH_TYPE_SHA1;
6825 salt_type = SALT_TYPE_EMBEDDED;
6826 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6827 opts_type = OPTS_TYPE_PT_GENERATE_BE
6828 | OPTS_TYPE_ST_ADD80
6829 | OPTS_TYPE_ST_ADDBITS15;
6830 kern_type = KERN_TYPE_SHA1_PWSLT;
6831 dgst_size = DGST_SIZE_4_5;
6832 parse_func = sha1b64s_parse_hash;
6833 sort_by_digest = sort_by_digest_4_5;
6834 opti_type = OPTI_TYPE_ZERO_BYTE
6835 | OPTI_TYPE_PRECOMPUTE_INIT
6836 | OPTI_TYPE_PRECOMPUTE_MERKLE
6837 | OPTI_TYPE_EARLY_SKIP
6838 | OPTI_TYPE_NOT_ITERATED
6839 | OPTI_TYPE_APPENDED_SALT
6840 | OPTI_TYPE_RAW_HASH;
6841 dgst_pos0 = 3;
6842 dgst_pos1 = 4;
6843 dgst_pos2 = 2;
6844 dgst_pos3 = 1;
6845 break;
6846
6847 case 112: hash_type = HASH_TYPE_SHA1;
6848 salt_type = SALT_TYPE_INTERN;
6849 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6850 opts_type = OPTS_TYPE_PT_GENERATE_BE
6851 | OPTS_TYPE_ST_ADD80
6852 | OPTS_TYPE_ST_ADDBITS15
6853 | OPTS_TYPE_ST_HEX;
6854 kern_type = KERN_TYPE_SHA1_PWSLT;
6855 dgst_size = DGST_SIZE_4_5;
6856 parse_func = oracles_parse_hash;
6857 sort_by_digest = sort_by_digest_4_5;
6858 opti_type = OPTI_TYPE_ZERO_BYTE
6859 | OPTI_TYPE_PRECOMPUTE_INIT
6860 | OPTI_TYPE_PRECOMPUTE_MERKLE
6861 | OPTI_TYPE_EARLY_SKIP
6862 | OPTI_TYPE_NOT_ITERATED
6863 | OPTI_TYPE_APPENDED_SALT
6864 | OPTI_TYPE_RAW_HASH;
6865 dgst_pos0 = 3;
6866 dgst_pos1 = 4;
6867 dgst_pos2 = 2;
6868 dgst_pos3 = 1;
6869 break;
6870
6871 case 120: hash_type = HASH_TYPE_SHA1;
6872 salt_type = SALT_TYPE_INTERN;
6873 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6874 opts_type = OPTS_TYPE_PT_GENERATE_BE
6875 | OPTS_TYPE_PT_ADD80
6876 | OPTS_TYPE_PT_ADDBITS15;
6877 kern_type = KERN_TYPE_SHA1_SLTPW;
6878 dgst_size = DGST_SIZE_4_5;
6879 parse_func = sha1s_parse_hash;
6880 sort_by_digest = sort_by_digest_4_5;
6881 opti_type = OPTI_TYPE_ZERO_BYTE
6882 | OPTI_TYPE_PRECOMPUTE_INIT
6883 | OPTI_TYPE_PRECOMPUTE_MERKLE
6884 | OPTI_TYPE_EARLY_SKIP
6885 | OPTI_TYPE_NOT_ITERATED
6886 | OPTI_TYPE_PREPENDED_SALT
6887 | OPTI_TYPE_RAW_HASH;
6888 dgst_pos0 = 3;
6889 dgst_pos1 = 4;
6890 dgst_pos2 = 2;
6891 dgst_pos3 = 1;
6892 break;
6893
6894 case 121: hash_type = HASH_TYPE_SHA1;
6895 salt_type = SALT_TYPE_INTERN;
6896 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6897 opts_type = OPTS_TYPE_PT_GENERATE_BE
6898 | OPTS_TYPE_PT_ADD80
6899 | OPTS_TYPE_PT_ADDBITS15
6900 | OPTS_TYPE_ST_LOWER;
6901 kern_type = KERN_TYPE_SHA1_SLTPW;
6902 dgst_size = DGST_SIZE_4_5;
6903 parse_func = smf_parse_hash;
6904 sort_by_digest = sort_by_digest_4_5;
6905 opti_type = OPTI_TYPE_ZERO_BYTE
6906 | OPTI_TYPE_PRECOMPUTE_INIT
6907 | OPTI_TYPE_PRECOMPUTE_MERKLE
6908 | OPTI_TYPE_EARLY_SKIP
6909 | OPTI_TYPE_NOT_ITERATED
6910 | OPTI_TYPE_PREPENDED_SALT
6911 | OPTI_TYPE_RAW_HASH;
6912 dgst_pos0 = 3;
6913 dgst_pos1 = 4;
6914 dgst_pos2 = 2;
6915 dgst_pos3 = 1;
6916 break;
6917
6918 case 122: hash_type = HASH_TYPE_SHA1;
6919 salt_type = SALT_TYPE_EMBEDDED;
6920 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6921 opts_type = OPTS_TYPE_PT_GENERATE_BE
6922 | OPTS_TYPE_PT_ADD80
6923 | OPTS_TYPE_PT_ADDBITS15
6924 | OPTS_TYPE_ST_HEX;
6925 kern_type = KERN_TYPE_SHA1_SLTPW;
6926 dgst_size = DGST_SIZE_4_5;
6927 parse_func = osx1_parse_hash;
6928 sort_by_digest = sort_by_digest_4_5;
6929 opti_type = OPTI_TYPE_ZERO_BYTE
6930 | OPTI_TYPE_PRECOMPUTE_INIT
6931 | OPTI_TYPE_PRECOMPUTE_MERKLE
6932 | OPTI_TYPE_EARLY_SKIP
6933 | OPTI_TYPE_NOT_ITERATED
6934 | OPTI_TYPE_PREPENDED_SALT
6935 | OPTI_TYPE_RAW_HASH;
6936 dgst_pos0 = 3;
6937 dgst_pos1 = 4;
6938 dgst_pos2 = 2;
6939 dgst_pos3 = 1;
6940 break;
6941
6942 case 124: hash_type = HASH_TYPE_SHA1;
6943 salt_type = SALT_TYPE_EMBEDDED;
6944 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6945 opts_type = OPTS_TYPE_PT_GENERATE_BE
6946 | OPTS_TYPE_PT_ADD80
6947 | OPTS_TYPE_PT_ADDBITS15;
6948 kern_type = KERN_TYPE_SHA1_SLTPW;
6949 dgst_size = DGST_SIZE_4_5;
6950 parse_func = djangosha1_parse_hash;
6951 sort_by_digest = sort_by_digest_4_5;
6952 opti_type = OPTI_TYPE_ZERO_BYTE
6953 | OPTI_TYPE_PRECOMPUTE_INIT
6954 | OPTI_TYPE_PRECOMPUTE_MERKLE
6955 | OPTI_TYPE_EARLY_SKIP
6956 | OPTI_TYPE_NOT_ITERATED
6957 | OPTI_TYPE_PREPENDED_SALT
6958 | OPTI_TYPE_RAW_HASH;
6959 dgst_pos0 = 3;
6960 dgst_pos1 = 4;
6961 dgst_pos2 = 2;
6962 dgst_pos3 = 1;
6963 break;
6964
6965 case 130: hash_type = HASH_TYPE_SHA1;
6966 salt_type = SALT_TYPE_INTERN;
6967 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6968 opts_type = OPTS_TYPE_PT_GENERATE_BE
6969 | OPTS_TYPE_PT_UNICODE
6970 | OPTS_TYPE_ST_ADD80
6971 | OPTS_TYPE_ST_ADDBITS15;
6972 kern_type = KERN_TYPE_SHA1_PWUSLT;
6973 dgst_size = DGST_SIZE_4_5;
6974 parse_func = sha1s_parse_hash;
6975 sort_by_digest = sort_by_digest_4_5;
6976 opti_type = OPTI_TYPE_ZERO_BYTE
6977 | OPTI_TYPE_PRECOMPUTE_INIT
6978 | OPTI_TYPE_PRECOMPUTE_MERKLE
6979 | OPTI_TYPE_EARLY_SKIP
6980 | OPTI_TYPE_NOT_ITERATED
6981 | OPTI_TYPE_APPENDED_SALT
6982 | OPTI_TYPE_RAW_HASH;
6983 dgst_pos0 = 3;
6984 dgst_pos1 = 4;
6985 dgst_pos2 = 2;
6986 dgst_pos3 = 1;
6987 break;
6988
6989 case 131: hash_type = HASH_TYPE_SHA1;
6990 salt_type = SALT_TYPE_EMBEDDED;
6991 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6992 opts_type = OPTS_TYPE_PT_GENERATE_BE
6993 | OPTS_TYPE_PT_UNICODE
6994 | OPTS_TYPE_PT_UPPER
6995 | OPTS_TYPE_ST_ADD80
6996 | OPTS_TYPE_ST_ADDBITS15
6997 | OPTS_TYPE_ST_HEX;
6998 kern_type = KERN_TYPE_SHA1_PWUSLT;
6999 dgst_size = DGST_SIZE_4_5;
7000 parse_func = mssql2000_parse_hash;
7001 sort_by_digest = sort_by_digest_4_5;
7002 opti_type = OPTI_TYPE_ZERO_BYTE
7003 | OPTI_TYPE_PRECOMPUTE_INIT
7004 | OPTI_TYPE_PRECOMPUTE_MERKLE
7005 | OPTI_TYPE_EARLY_SKIP
7006 | OPTI_TYPE_NOT_ITERATED
7007 | OPTI_TYPE_APPENDED_SALT
7008 | OPTI_TYPE_RAW_HASH;
7009 dgst_pos0 = 3;
7010 dgst_pos1 = 4;
7011 dgst_pos2 = 2;
7012 dgst_pos3 = 1;
7013 break;
7014
7015 case 132: hash_type = HASH_TYPE_SHA1;
7016 salt_type = SALT_TYPE_EMBEDDED;
7017 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7018 opts_type = OPTS_TYPE_PT_GENERATE_BE
7019 | OPTS_TYPE_PT_UNICODE
7020 | OPTS_TYPE_ST_ADD80
7021 | OPTS_TYPE_ST_ADDBITS15
7022 | OPTS_TYPE_ST_HEX;
7023 kern_type = KERN_TYPE_SHA1_PWUSLT;
7024 dgst_size = DGST_SIZE_4_5;
7025 parse_func = mssql2005_parse_hash;
7026 sort_by_digest = sort_by_digest_4_5;
7027 opti_type = OPTI_TYPE_ZERO_BYTE
7028 | OPTI_TYPE_PRECOMPUTE_INIT
7029 | OPTI_TYPE_PRECOMPUTE_MERKLE
7030 | OPTI_TYPE_EARLY_SKIP
7031 | OPTI_TYPE_NOT_ITERATED
7032 | OPTI_TYPE_APPENDED_SALT
7033 | OPTI_TYPE_RAW_HASH;
7034 dgst_pos0 = 3;
7035 dgst_pos1 = 4;
7036 dgst_pos2 = 2;
7037 dgst_pos3 = 1;
7038 break;
7039
7040 case 133: hash_type = HASH_TYPE_SHA1;
7041 salt_type = SALT_TYPE_EMBEDDED;
7042 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7043 opts_type = OPTS_TYPE_PT_GENERATE_BE
7044 | OPTS_TYPE_PT_UNICODE
7045 | OPTS_TYPE_ST_ADD80
7046 | OPTS_TYPE_ST_ADDBITS15;
7047 kern_type = KERN_TYPE_SHA1_PWUSLT;
7048 dgst_size = DGST_SIZE_4_5;
7049 parse_func = peoplesoft_parse_hash;
7050 sort_by_digest = sort_by_digest_4_5;
7051 opti_type = OPTI_TYPE_ZERO_BYTE
7052 | OPTI_TYPE_PRECOMPUTE_INIT
7053 | OPTI_TYPE_PRECOMPUTE_MERKLE
7054 | OPTI_TYPE_EARLY_SKIP
7055 | OPTI_TYPE_NOT_ITERATED
7056 | OPTI_TYPE_APPENDED_SALT
7057 | OPTI_TYPE_RAW_HASH;
7058 dgst_pos0 = 3;
7059 dgst_pos1 = 4;
7060 dgst_pos2 = 2;
7061 dgst_pos3 = 1;
7062 break;
7063
7064 case 140: hash_type = HASH_TYPE_SHA1;
7065 salt_type = SALT_TYPE_INTERN;
7066 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7067 opts_type = OPTS_TYPE_PT_GENERATE_BE
7068 | OPTS_TYPE_PT_ADD80
7069 | OPTS_TYPE_PT_ADDBITS15
7070 | OPTS_TYPE_PT_UNICODE;
7071 kern_type = KERN_TYPE_SHA1_SLTPWU;
7072 dgst_size = DGST_SIZE_4_5;
7073 parse_func = sha1s_parse_hash;
7074 sort_by_digest = sort_by_digest_4_5;
7075 opti_type = OPTI_TYPE_ZERO_BYTE
7076 | OPTI_TYPE_PRECOMPUTE_INIT
7077 | OPTI_TYPE_PRECOMPUTE_MERKLE
7078 | OPTI_TYPE_EARLY_SKIP
7079 | OPTI_TYPE_NOT_ITERATED
7080 | OPTI_TYPE_PREPENDED_SALT
7081 | OPTI_TYPE_RAW_HASH;
7082 dgst_pos0 = 3;
7083 dgst_pos1 = 4;
7084 dgst_pos2 = 2;
7085 dgst_pos3 = 1;
7086 break;
7087
7088 case 141: hash_type = HASH_TYPE_SHA1;
7089 salt_type = SALT_TYPE_EMBEDDED;
7090 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7091 opts_type = OPTS_TYPE_PT_GENERATE_BE
7092 | OPTS_TYPE_PT_ADD80
7093 | OPTS_TYPE_PT_ADDBITS15
7094 | OPTS_TYPE_PT_UNICODE
7095 | OPTS_TYPE_ST_BASE64;
7096 kern_type = KERN_TYPE_SHA1_SLTPWU;
7097 dgst_size = DGST_SIZE_4_5;
7098 parse_func = episerver_parse_hash;
7099 sort_by_digest = sort_by_digest_4_5;
7100 opti_type = OPTI_TYPE_ZERO_BYTE
7101 | OPTI_TYPE_PRECOMPUTE_INIT
7102 | OPTI_TYPE_PRECOMPUTE_MERKLE
7103 | OPTI_TYPE_EARLY_SKIP
7104 | OPTI_TYPE_NOT_ITERATED
7105 | OPTI_TYPE_PREPENDED_SALT
7106 | OPTI_TYPE_RAW_HASH;
7107 dgst_pos0 = 3;
7108 dgst_pos1 = 4;
7109 dgst_pos2 = 2;
7110 dgst_pos3 = 1;
7111 break;
7112
7113 case 150: hash_type = HASH_TYPE_SHA1;
7114 salt_type = SALT_TYPE_INTERN;
7115 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7116 opts_type = OPTS_TYPE_PT_GENERATE_BE
7117 | OPTS_TYPE_ST_ADD80
7118 | OPTS_TYPE_ST_ADDBITS15;
7119 kern_type = KERN_TYPE_HMACSHA1_PW;
7120 dgst_size = DGST_SIZE_4_5;
7121 parse_func = hmacsha1_parse_hash;
7122 sort_by_digest = sort_by_digest_4_5;
7123 opti_type = OPTI_TYPE_ZERO_BYTE
7124 | OPTI_TYPE_NOT_ITERATED;
7125 dgst_pos0 = 3;
7126 dgst_pos1 = 4;
7127 dgst_pos2 = 2;
7128 dgst_pos3 = 1;
7129 break;
7130
7131 case 160: hash_type = HASH_TYPE_SHA1;
7132 salt_type = SALT_TYPE_INTERN;
7133 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7134 opts_type = OPTS_TYPE_PT_GENERATE_BE
7135 | OPTS_TYPE_PT_ADD80
7136 | OPTS_TYPE_PT_ADDBITS15;
7137 kern_type = KERN_TYPE_HMACSHA1_SLT;
7138 dgst_size = DGST_SIZE_4_5;
7139 parse_func = hmacsha1_parse_hash;
7140 sort_by_digest = sort_by_digest_4_5;
7141 opti_type = OPTI_TYPE_ZERO_BYTE
7142 | OPTI_TYPE_NOT_ITERATED;
7143 dgst_pos0 = 3;
7144 dgst_pos1 = 4;
7145 dgst_pos2 = 2;
7146 dgst_pos3 = 1;
7147 break;
7148
7149 case 190: hash_type = HASH_TYPE_SHA1;
7150 salt_type = SALT_TYPE_NONE;
7151 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7152 opts_type = OPTS_TYPE_PT_GENERATE_BE
7153 | OPTS_TYPE_PT_ADD80
7154 | OPTS_TYPE_PT_ADDBITS15;
7155 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7156 dgst_size = DGST_SIZE_4_5;
7157 parse_func = sha1linkedin_parse_hash;
7158 sort_by_digest = sort_by_digest_4_5;
7159 opti_type = OPTI_TYPE_ZERO_BYTE
7160 | OPTI_TYPE_PRECOMPUTE_INIT
7161 | OPTI_TYPE_EARLY_SKIP
7162 | OPTI_TYPE_NOT_ITERATED
7163 | OPTI_TYPE_NOT_SALTED;
7164 dgst_pos0 = 0;
7165 dgst_pos1 = 4;
7166 dgst_pos2 = 3;
7167 dgst_pos3 = 2;
7168 break;
7169
7170 case 200: hash_type = HASH_TYPE_MYSQL;
7171 salt_type = SALT_TYPE_NONE;
7172 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7173 opts_type = 0;
7174 kern_type = KERN_TYPE_MYSQL;
7175 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7176 parse_func = mysql323_parse_hash;
7177 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7178 opti_type = OPTI_TYPE_ZERO_BYTE;
7179 dgst_pos0 = 0;
7180 dgst_pos1 = 1;
7181 dgst_pos2 = 2;
7182 dgst_pos3 = 3;
7183 break;
7184
7185 case 300: hash_type = HASH_TYPE_SHA1;
7186 salt_type = SALT_TYPE_NONE;
7187 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7188 opts_type = OPTS_TYPE_PT_GENERATE_BE
7189 | OPTS_TYPE_PT_ADD80
7190 | OPTS_TYPE_PT_ADDBITS15;
7191 kern_type = KERN_TYPE_MYSQL41;
7192 dgst_size = DGST_SIZE_4_5;
7193 parse_func = sha1_parse_hash;
7194 sort_by_digest = sort_by_digest_4_5;
7195 opti_type = OPTI_TYPE_ZERO_BYTE
7196 | OPTI_TYPE_PRECOMPUTE_INIT
7197 | OPTI_TYPE_PRECOMPUTE_MERKLE
7198 | OPTI_TYPE_EARLY_SKIP
7199 | OPTI_TYPE_NOT_ITERATED
7200 | OPTI_TYPE_NOT_SALTED;
7201 dgst_pos0 = 3;
7202 dgst_pos1 = 4;
7203 dgst_pos2 = 2;
7204 dgst_pos3 = 1;
7205 break;
7206
7207 case 400: hash_type = HASH_TYPE_MD5;
7208 salt_type = SALT_TYPE_EMBEDDED;
7209 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7210 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7211 kern_type = KERN_TYPE_PHPASS;
7212 dgst_size = DGST_SIZE_4_4;
7213 parse_func = phpass_parse_hash;
7214 sort_by_digest = sort_by_digest_4_4;
7215 opti_type = OPTI_TYPE_ZERO_BYTE;
7216 dgst_pos0 = 0;
7217 dgst_pos1 = 1;
7218 dgst_pos2 = 2;
7219 dgst_pos3 = 3;
7220 break;
7221
7222 case 500: hash_type = HASH_TYPE_MD5;
7223 salt_type = SALT_TYPE_EMBEDDED;
7224 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7225 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7226 kern_type = KERN_TYPE_MD5CRYPT;
7227 dgst_size = DGST_SIZE_4_4;
7228 parse_func = md5crypt_parse_hash;
7229 sort_by_digest = sort_by_digest_4_4;
7230 opti_type = OPTI_TYPE_ZERO_BYTE;
7231 dgst_pos0 = 0;
7232 dgst_pos1 = 1;
7233 dgst_pos2 = 2;
7234 dgst_pos3 = 3;
7235 break;
7236
7237 case 501: hash_type = HASH_TYPE_MD5;
7238 salt_type = SALT_TYPE_EMBEDDED;
7239 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7240 opts_type = OPTS_TYPE_PT_GENERATE_LE
7241 | OPTS_TYPE_HASH_COPY;
7242 kern_type = KERN_TYPE_MD5CRYPT;
7243 dgst_size = DGST_SIZE_4_4;
7244 parse_func = juniper_parse_hash;
7245 sort_by_digest = sort_by_digest_4_4;
7246 opti_type = OPTI_TYPE_ZERO_BYTE;
7247 dgst_pos0 = 0;
7248 dgst_pos1 = 1;
7249 dgst_pos2 = 2;
7250 dgst_pos3 = 3;
7251 break;
7252
7253 case 900: hash_type = HASH_TYPE_MD4;
7254 salt_type = SALT_TYPE_NONE;
7255 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7256 opts_type = OPTS_TYPE_PT_GENERATE_LE
7257 | OPTS_TYPE_PT_ADD80
7258 | OPTS_TYPE_PT_ADDBITS14;
7259 kern_type = KERN_TYPE_MD4;
7260 dgst_size = DGST_SIZE_4_4;
7261 parse_func = md4_parse_hash;
7262 sort_by_digest = sort_by_digest_4_4;
7263 opti_type = OPTI_TYPE_ZERO_BYTE
7264 | OPTI_TYPE_PRECOMPUTE_INIT
7265 | OPTI_TYPE_PRECOMPUTE_MERKLE
7266 | OPTI_TYPE_MEET_IN_MIDDLE
7267 | OPTI_TYPE_EARLY_SKIP
7268 | OPTI_TYPE_NOT_ITERATED
7269 | OPTI_TYPE_NOT_SALTED
7270 | OPTI_TYPE_RAW_HASH;
7271 dgst_pos0 = 0;
7272 dgst_pos1 = 3;
7273 dgst_pos2 = 2;
7274 dgst_pos3 = 1;
7275 break;
7276
7277 case 1000: hash_type = HASH_TYPE_MD4;
7278 salt_type = SALT_TYPE_NONE;
7279 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7280 opts_type = OPTS_TYPE_PT_GENERATE_LE
7281 | OPTS_TYPE_PT_ADD80
7282 | OPTS_TYPE_PT_ADDBITS14
7283 | OPTS_TYPE_PT_UNICODE;
7284 kern_type = KERN_TYPE_MD4_PWU;
7285 dgst_size = DGST_SIZE_4_4;
7286 parse_func = md4_parse_hash;
7287 sort_by_digest = sort_by_digest_4_4;
7288 opti_type = OPTI_TYPE_ZERO_BYTE
7289 | OPTI_TYPE_PRECOMPUTE_INIT
7290 | OPTI_TYPE_PRECOMPUTE_MERKLE
7291 | OPTI_TYPE_MEET_IN_MIDDLE
7292 | OPTI_TYPE_EARLY_SKIP
7293 | OPTI_TYPE_NOT_ITERATED
7294 | OPTI_TYPE_NOT_SALTED
7295 | OPTI_TYPE_RAW_HASH;
7296 dgst_pos0 = 0;
7297 dgst_pos1 = 3;
7298 dgst_pos2 = 2;
7299 dgst_pos3 = 1;
7300 break;
7301
7302 case 1100: hash_type = HASH_TYPE_MD4;
7303 salt_type = SALT_TYPE_INTERN;
7304 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7305 opts_type = OPTS_TYPE_PT_GENERATE_LE
7306 | OPTS_TYPE_PT_ADD80
7307 | OPTS_TYPE_PT_ADDBITS14
7308 | OPTS_TYPE_PT_UNICODE
7309 | OPTS_TYPE_ST_ADD80
7310 | OPTS_TYPE_ST_UNICODE
7311 | OPTS_TYPE_ST_LOWER;
7312 kern_type = KERN_TYPE_MD44_PWUSLT;
7313 dgst_size = DGST_SIZE_4_4;
7314 parse_func = dcc_parse_hash;
7315 sort_by_digest = sort_by_digest_4_4;
7316 opti_type = OPTI_TYPE_ZERO_BYTE
7317 | OPTI_TYPE_PRECOMPUTE_INIT
7318 | OPTI_TYPE_PRECOMPUTE_MERKLE
7319 | OPTI_TYPE_EARLY_SKIP
7320 | OPTI_TYPE_NOT_ITERATED;
7321 dgst_pos0 = 0;
7322 dgst_pos1 = 3;
7323 dgst_pos2 = 2;
7324 dgst_pos3 = 1;
7325 break;
7326
7327 case 1400: hash_type = HASH_TYPE_SHA256;
7328 salt_type = SALT_TYPE_NONE;
7329 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7330 opts_type = OPTS_TYPE_PT_GENERATE_BE
7331 | OPTS_TYPE_PT_ADD80
7332 | OPTS_TYPE_PT_ADDBITS15;
7333 kern_type = KERN_TYPE_SHA256;
7334 dgst_size = DGST_SIZE_4_8;
7335 parse_func = sha256_parse_hash;
7336 sort_by_digest = sort_by_digest_4_8;
7337 opti_type = OPTI_TYPE_ZERO_BYTE
7338 | OPTI_TYPE_PRECOMPUTE_INIT
7339 | OPTI_TYPE_PRECOMPUTE_MERKLE
7340 | OPTI_TYPE_EARLY_SKIP
7341 | OPTI_TYPE_NOT_ITERATED
7342 | OPTI_TYPE_NOT_SALTED
7343 | OPTI_TYPE_RAW_HASH;
7344 dgst_pos0 = 3;
7345 dgst_pos1 = 7;
7346 dgst_pos2 = 2;
7347 dgst_pos3 = 6;
7348 break;
7349
7350 case 1410: hash_type = HASH_TYPE_SHA256;
7351 salt_type = SALT_TYPE_INTERN;
7352 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7353 opts_type = OPTS_TYPE_PT_GENERATE_BE
7354 | OPTS_TYPE_ST_ADD80
7355 | OPTS_TYPE_ST_ADDBITS15;
7356 kern_type = KERN_TYPE_SHA256_PWSLT;
7357 dgst_size = DGST_SIZE_4_8;
7358 parse_func = sha256s_parse_hash;
7359 sort_by_digest = sort_by_digest_4_8;
7360 opti_type = OPTI_TYPE_ZERO_BYTE
7361 | OPTI_TYPE_PRECOMPUTE_INIT
7362 | OPTI_TYPE_PRECOMPUTE_MERKLE
7363 | OPTI_TYPE_EARLY_SKIP
7364 | OPTI_TYPE_NOT_ITERATED
7365 | OPTI_TYPE_APPENDED_SALT
7366 | OPTI_TYPE_RAW_HASH;
7367 dgst_pos0 = 3;
7368 dgst_pos1 = 7;
7369 dgst_pos2 = 2;
7370 dgst_pos3 = 6;
7371 break;
7372
7373 case 1420: hash_type = HASH_TYPE_SHA256;
7374 salt_type = SALT_TYPE_INTERN;
7375 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7376 opts_type = OPTS_TYPE_PT_GENERATE_BE
7377 | OPTS_TYPE_PT_ADD80
7378 | OPTS_TYPE_PT_ADDBITS15;
7379 kern_type = KERN_TYPE_SHA256_SLTPW;
7380 dgst_size = DGST_SIZE_4_8;
7381 parse_func = sha256s_parse_hash;
7382 sort_by_digest = sort_by_digest_4_8;
7383 opti_type = OPTI_TYPE_ZERO_BYTE
7384 | OPTI_TYPE_PRECOMPUTE_INIT
7385 | OPTI_TYPE_PRECOMPUTE_MERKLE
7386 | OPTI_TYPE_EARLY_SKIP
7387 | OPTI_TYPE_NOT_ITERATED
7388 | OPTI_TYPE_PREPENDED_SALT
7389 | OPTI_TYPE_RAW_HASH;
7390 dgst_pos0 = 3;
7391 dgst_pos1 = 7;
7392 dgst_pos2 = 2;
7393 dgst_pos3 = 6;
7394 break;
7395
7396 case 1421: hash_type = HASH_TYPE_SHA256;
7397 salt_type = SALT_TYPE_EMBEDDED;
7398 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7399 opts_type = OPTS_TYPE_PT_GENERATE_BE
7400 | OPTS_TYPE_PT_ADD80
7401 | OPTS_TYPE_PT_ADDBITS15;
7402 kern_type = KERN_TYPE_SHA256_SLTPW;
7403 dgst_size = DGST_SIZE_4_8;
7404 parse_func = hmailserver_parse_hash;
7405 sort_by_digest = sort_by_digest_4_8;
7406 opti_type = OPTI_TYPE_ZERO_BYTE
7407 | OPTI_TYPE_PRECOMPUTE_INIT
7408 | OPTI_TYPE_PRECOMPUTE_MERKLE
7409 | OPTI_TYPE_EARLY_SKIP
7410 | OPTI_TYPE_NOT_ITERATED
7411 | OPTI_TYPE_PREPENDED_SALT
7412 | OPTI_TYPE_RAW_HASH;
7413 dgst_pos0 = 3;
7414 dgst_pos1 = 7;
7415 dgst_pos2 = 2;
7416 dgst_pos3 = 6;
7417 break;
7418
7419 case 1430: hash_type = HASH_TYPE_SHA256;
7420 salt_type = SALT_TYPE_INTERN;
7421 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7422 opts_type = OPTS_TYPE_PT_GENERATE_BE
7423 | OPTS_TYPE_PT_UNICODE
7424 | OPTS_TYPE_ST_ADD80
7425 | OPTS_TYPE_ST_ADDBITS15;
7426 kern_type = KERN_TYPE_SHA256_PWUSLT;
7427 dgst_size = DGST_SIZE_4_8;
7428 parse_func = sha256s_parse_hash;
7429 sort_by_digest = sort_by_digest_4_8;
7430 opti_type = OPTI_TYPE_ZERO_BYTE
7431 | OPTI_TYPE_PRECOMPUTE_INIT
7432 | OPTI_TYPE_PRECOMPUTE_MERKLE
7433 | OPTI_TYPE_EARLY_SKIP
7434 | OPTI_TYPE_NOT_ITERATED
7435 | OPTI_TYPE_APPENDED_SALT
7436 | OPTI_TYPE_RAW_HASH;
7437 dgst_pos0 = 3;
7438 dgst_pos1 = 7;
7439 dgst_pos2 = 2;
7440 dgst_pos3 = 6;
7441 break;
7442
7443 case 1440: hash_type = HASH_TYPE_SHA256;
7444 salt_type = SALT_TYPE_INTERN;
7445 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7446 opts_type = OPTS_TYPE_PT_GENERATE_BE
7447 | OPTS_TYPE_PT_ADD80
7448 | OPTS_TYPE_PT_ADDBITS15
7449 | OPTS_TYPE_PT_UNICODE;
7450 kern_type = KERN_TYPE_SHA256_SLTPWU;
7451 dgst_size = DGST_SIZE_4_8;
7452 parse_func = sha256s_parse_hash;
7453 sort_by_digest = sort_by_digest_4_8;
7454 opti_type = OPTI_TYPE_ZERO_BYTE
7455 | OPTI_TYPE_PRECOMPUTE_INIT
7456 | OPTI_TYPE_PRECOMPUTE_MERKLE
7457 | OPTI_TYPE_EARLY_SKIP
7458 | OPTI_TYPE_NOT_ITERATED
7459 | OPTI_TYPE_PREPENDED_SALT
7460 | OPTI_TYPE_RAW_HASH;
7461 dgst_pos0 = 3;
7462 dgst_pos1 = 7;
7463 dgst_pos2 = 2;
7464 dgst_pos3 = 6;
7465 break;
7466
7467 case 1441: hash_type = HASH_TYPE_SHA256;
7468 salt_type = SALT_TYPE_EMBEDDED;
7469 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7470 opts_type = OPTS_TYPE_PT_GENERATE_BE
7471 | OPTS_TYPE_PT_ADD80
7472 | OPTS_TYPE_PT_ADDBITS15
7473 | OPTS_TYPE_PT_UNICODE
7474 | OPTS_TYPE_ST_BASE64;
7475 kern_type = KERN_TYPE_SHA256_SLTPWU;
7476 dgst_size = DGST_SIZE_4_8;
7477 parse_func = episerver4_parse_hash;
7478 sort_by_digest = sort_by_digest_4_8;
7479 opti_type = OPTI_TYPE_ZERO_BYTE
7480 | OPTI_TYPE_PRECOMPUTE_INIT
7481 | OPTI_TYPE_PRECOMPUTE_MERKLE
7482 | OPTI_TYPE_EARLY_SKIP
7483 | OPTI_TYPE_NOT_ITERATED
7484 | OPTI_TYPE_PREPENDED_SALT
7485 | OPTI_TYPE_RAW_HASH;
7486 dgst_pos0 = 3;
7487 dgst_pos1 = 7;
7488 dgst_pos2 = 2;
7489 dgst_pos3 = 6;
7490 break;
7491
7492 case 1450: hash_type = HASH_TYPE_SHA256;
7493 salt_type = SALT_TYPE_INTERN;
7494 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7495 opts_type = OPTS_TYPE_PT_GENERATE_BE
7496 | OPTS_TYPE_ST_ADD80;
7497 kern_type = KERN_TYPE_HMACSHA256_PW;
7498 dgst_size = DGST_SIZE_4_8;
7499 parse_func = hmacsha256_parse_hash;
7500 sort_by_digest = sort_by_digest_4_8;
7501 opti_type = OPTI_TYPE_ZERO_BYTE
7502 | OPTI_TYPE_NOT_ITERATED;
7503 dgst_pos0 = 3;
7504 dgst_pos1 = 7;
7505 dgst_pos2 = 2;
7506 dgst_pos3 = 6;
7507 break;
7508
7509 case 1460: hash_type = HASH_TYPE_SHA256;
7510 salt_type = SALT_TYPE_INTERN;
7511 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7512 opts_type = OPTS_TYPE_PT_GENERATE_BE
7513 | OPTS_TYPE_PT_ADD80
7514 | OPTS_TYPE_PT_ADDBITS15;
7515 kern_type = KERN_TYPE_HMACSHA256_SLT;
7516 dgst_size = DGST_SIZE_4_8;
7517 parse_func = hmacsha256_parse_hash;
7518 sort_by_digest = sort_by_digest_4_8;
7519 opti_type = OPTI_TYPE_ZERO_BYTE
7520 | OPTI_TYPE_NOT_ITERATED;
7521 dgst_pos0 = 3;
7522 dgst_pos1 = 7;
7523 dgst_pos2 = 2;
7524 dgst_pos3 = 6;
7525 break;
7526
7527 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7528 salt_type = SALT_TYPE_EMBEDDED;
7529 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7530 opts_type = OPTS_TYPE_PT_GENERATE_LE
7531 | OPTS_TYPE_PT_BITSLICE;
7532 kern_type = KERN_TYPE_DESCRYPT;
7533 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7534 parse_func = descrypt_parse_hash;
7535 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7536 opti_type = OPTI_TYPE_ZERO_BYTE
7537 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7538 dgst_pos0 = 0;
7539 dgst_pos1 = 1;
7540 dgst_pos2 = 2;
7541 dgst_pos3 = 3;
7542 break;
7543
7544 case 1600: hash_type = HASH_TYPE_MD5;
7545 salt_type = SALT_TYPE_EMBEDDED;
7546 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7547 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7548 kern_type = KERN_TYPE_APR1CRYPT;
7549 dgst_size = DGST_SIZE_4_4;
7550 parse_func = md5apr1_parse_hash;
7551 sort_by_digest = sort_by_digest_4_4;
7552 opti_type = OPTI_TYPE_ZERO_BYTE;
7553 dgst_pos0 = 0;
7554 dgst_pos1 = 1;
7555 dgst_pos2 = 2;
7556 dgst_pos3 = 3;
7557 break;
7558
7559 case 1700: hash_type = HASH_TYPE_SHA512;
7560 salt_type = SALT_TYPE_NONE;
7561 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7562 opts_type = OPTS_TYPE_PT_GENERATE_BE
7563 | OPTS_TYPE_PT_ADD80
7564 | OPTS_TYPE_PT_ADDBITS15;
7565 kern_type = KERN_TYPE_SHA512;
7566 dgst_size = DGST_SIZE_8_8;
7567 parse_func = sha512_parse_hash;
7568 sort_by_digest = sort_by_digest_8_8;
7569 opti_type = OPTI_TYPE_ZERO_BYTE
7570 | OPTI_TYPE_PRECOMPUTE_INIT
7571 | OPTI_TYPE_PRECOMPUTE_MERKLE
7572 | OPTI_TYPE_EARLY_SKIP
7573 | OPTI_TYPE_NOT_ITERATED
7574 | OPTI_TYPE_NOT_SALTED
7575 | OPTI_TYPE_RAW_HASH;
7576 dgst_pos0 = 14;
7577 dgst_pos1 = 15;
7578 dgst_pos2 = 6;
7579 dgst_pos3 = 7;
7580 break;
7581
7582 case 1710: hash_type = HASH_TYPE_SHA512;
7583 salt_type = SALT_TYPE_INTERN;
7584 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7585 opts_type = OPTS_TYPE_PT_GENERATE_BE
7586 | OPTS_TYPE_ST_ADD80
7587 | OPTS_TYPE_ST_ADDBITS15;
7588 kern_type = KERN_TYPE_SHA512_PWSLT;
7589 dgst_size = DGST_SIZE_8_8;
7590 parse_func = sha512s_parse_hash;
7591 sort_by_digest = sort_by_digest_8_8;
7592 opti_type = OPTI_TYPE_ZERO_BYTE
7593 | OPTI_TYPE_PRECOMPUTE_INIT
7594 | OPTI_TYPE_PRECOMPUTE_MERKLE
7595 | OPTI_TYPE_EARLY_SKIP
7596 | OPTI_TYPE_NOT_ITERATED
7597 | OPTI_TYPE_APPENDED_SALT
7598 | OPTI_TYPE_RAW_HASH;
7599 dgst_pos0 = 14;
7600 dgst_pos1 = 15;
7601 dgst_pos2 = 6;
7602 dgst_pos3 = 7;
7603 break;
7604
7605 case 1711: hash_type = HASH_TYPE_SHA512;
7606 salt_type = SALT_TYPE_EMBEDDED;
7607 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7608 opts_type = OPTS_TYPE_PT_GENERATE_BE
7609 | OPTS_TYPE_ST_ADD80
7610 | OPTS_TYPE_ST_ADDBITS15;
7611 kern_type = KERN_TYPE_SHA512_PWSLT;
7612 dgst_size = DGST_SIZE_8_8;
7613 parse_func = sha512b64s_parse_hash;
7614 sort_by_digest = sort_by_digest_8_8;
7615 opti_type = OPTI_TYPE_ZERO_BYTE
7616 | OPTI_TYPE_PRECOMPUTE_INIT
7617 | OPTI_TYPE_PRECOMPUTE_MERKLE
7618 | OPTI_TYPE_EARLY_SKIP
7619 | OPTI_TYPE_NOT_ITERATED
7620 | OPTI_TYPE_APPENDED_SALT
7621 | OPTI_TYPE_RAW_HASH;
7622 dgst_pos0 = 14;
7623 dgst_pos1 = 15;
7624 dgst_pos2 = 6;
7625 dgst_pos3 = 7;
7626 break;
7627
7628 case 1720: hash_type = HASH_TYPE_SHA512;
7629 salt_type = SALT_TYPE_INTERN;
7630 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7631 opts_type = OPTS_TYPE_PT_GENERATE_BE
7632 | OPTS_TYPE_PT_ADD80
7633 | OPTS_TYPE_PT_ADDBITS15;
7634 kern_type = KERN_TYPE_SHA512_SLTPW;
7635 dgst_size = DGST_SIZE_8_8;
7636 parse_func = sha512s_parse_hash;
7637 sort_by_digest = sort_by_digest_8_8;
7638 opti_type = OPTI_TYPE_ZERO_BYTE
7639 | OPTI_TYPE_PRECOMPUTE_INIT
7640 | OPTI_TYPE_PRECOMPUTE_MERKLE
7641 | OPTI_TYPE_EARLY_SKIP
7642 | OPTI_TYPE_NOT_ITERATED
7643 | OPTI_TYPE_PREPENDED_SALT
7644 | OPTI_TYPE_RAW_HASH;
7645 dgst_pos0 = 14;
7646 dgst_pos1 = 15;
7647 dgst_pos2 = 6;
7648 dgst_pos3 = 7;
7649 break;
7650
7651 case 1722: hash_type = HASH_TYPE_SHA512;
7652 salt_type = SALT_TYPE_EMBEDDED;
7653 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7654 opts_type = OPTS_TYPE_PT_GENERATE_BE
7655 | OPTS_TYPE_PT_ADD80
7656 | OPTS_TYPE_PT_ADDBITS15
7657 | OPTS_TYPE_ST_HEX;
7658 kern_type = KERN_TYPE_SHA512_SLTPW;
7659 dgst_size = DGST_SIZE_8_8;
7660 parse_func = osx512_parse_hash;
7661 sort_by_digest = sort_by_digest_8_8;
7662 opti_type = OPTI_TYPE_ZERO_BYTE
7663 | OPTI_TYPE_PRECOMPUTE_INIT
7664 | OPTI_TYPE_PRECOMPUTE_MERKLE
7665 | OPTI_TYPE_EARLY_SKIP
7666 | OPTI_TYPE_NOT_ITERATED
7667 | OPTI_TYPE_PREPENDED_SALT
7668 | OPTI_TYPE_RAW_HASH;
7669 dgst_pos0 = 14;
7670 dgst_pos1 = 15;
7671 dgst_pos2 = 6;
7672 dgst_pos3 = 7;
7673 break;
7674
7675 case 1730: hash_type = HASH_TYPE_SHA512;
7676 salt_type = SALT_TYPE_INTERN;
7677 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7678 opts_type = OPTS_TYPE_PT_GENERATE_BE
7679 | OPTS_TYPE_PT_UNICODE
7680 | OPTS_TYPE_ST_ADD80
7681 | OPTS_TYPE_ST_ADDBITS15;
7682 kern_type = KERN_TYPE_SHA512_PWSLTU;
7683 dgst_size = DGST_SIZE_8_8;
7684 parse_func = sha512s_parse_hash;
7685 sort_by_digest = sort_by_digest_8_8;
7686 opti_type = OPTI_TYPE_ZERO_BYTE
7687 | OPTI_TYPE_PRECOMPUTE_INIT
7688 | OPTI_TYPE_PRECOMPUTE_MERKLE
7689 | OPTI_TYPE_EARLY_SKIP
7690 | OPTI_TYPE_NOT_ITERATED
7691 | OPTI_TYPE_APPENDED_SALT
7692 | OPTI_TYPE_RAW_HASH;
7693 dgst_pos0 = 14;
7694 dgst_pos1 = 15;
7695 dgst_pos2 = 6;
7696 dgst_pos3 = 7;
7697 break;
7698
7699 case 1731: hash_type = HASH_TYPE_SHA512;
7700 salt_type = SALT_TYPE_EMBEDDED;
7701 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7702 opts_type = OPTS_TYPE_PT_GENERATE_BE
7703 | OPTS_TYPE_PT_UNICODE
7704 | OPTS_TYPE_ST_ADD80
7705 | OPTS_TYPE_ST_ADDBITS15
7706 | OPTS_TYPE_ST_HEX;
7707 kern_type = KERN_TYPE_SHA512_PWSLTU;
7708 dgst_size = DGST_SIZE_8_8;
7709 parse_func = mssql2012_parse_hash;
7710 sort_by_digest = sort_by_digest_8_8;
7711 opti_type = OPTI_TYPE_ZERO_BYTE
7712 | OPTI_TYPE_PRECOMPUTE_INIT
7713 | OPTI_TYPE_PRECOMPUTE_MERKLE
7714 | OPTI_TYPE_EARLY_SKIP
7715 | OPTI_TYPE_NOT_ITERATED
7716 | OPTI_TYPE_APPENDED_SALT
7717 | OPTI_TYPE_RAW_HASH;
7718 dgst_pos0 = 14;
7719 dgst_pos1 = 15;
7720 dgst_pos2 = 6;
7721 dgst_pos3 = 7;
7722 break;
7723
7724 case 1740: hash_type = HASH_TYPE_SHA512;
7725 salt_type = SALT_TYPE_INTERN;
7726 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7727 opts_type = OPTS_TYPE_PT_GENERATE_BE
7728 | OPTS_TYPE_PT_ADD80
7729 | OPTS_TYPE_PT_ADDBITS15
7730 | OPTS_TYPE_PT_UNICODE;
7731 kern_type = KERN_TYPE_SHA512_SLTPWU;
7732 dgst_size = DGST_SIZE_8_8;
7733 parse_func = sha512s_parse_hash;
7734 sort_by_digest = sort_by_digest_8_8;
7735 opti_type = OPTI_TYPE_ZERO_BYTE
7736 | OPTI_TYPE_PRECOMPUTE_INIT
7737 | OPTI_TYPE_PRECOMPUTE_MERKLE
7738 | OPTI_TYPE_EARLY_SKIP
7739 | OPTI_TYPE_NOT_ITERATED
7740 | OPTI_TYPE_PREPENDED_SALT
7741 | OPTI_TYPE_RAW_HASH;
7742 dgst_pos0 = 14;
7743 dgst_pos1 = 15;
7744 dgst_pos2 = 6;
7745 dgst_pos3 = 7;
7746 break;
7747
7748 case 1750: hash_type = HASH_TYPE_SHA512;
7749 salt_type = SALT_TYPE_INTERN;
7750 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7751 opts_type = OPTS_TYPE_PT_GENERATE_BE
7752 | OPTS_TYPE_ST_ADD80;
7753 kern_type = KERN_TYPE_HMACSHA512_PW;
7754 dgst_size = DGST_SIZE_8_8;
7755 parse_func = hmacsha512_parse_hash;
7756 sort_by_digest = sort_by_digest_8_8;
7757 opti_type = OPTI_TYPE_ZERO_BYTE
7758 | OPTI_TYPE_NOT_ITERATED;
7759 dgst_pos0 = 14;
7760 dgst_pos1 = 15;
7761 dgst_pos2 = 6;
7762 dgst_pos3 = 7;
7763 break;
7764
7765 case 1760: hash_type = HASH_TYPE_SHA512;
7766 salt_type = SALT_TYPE_INTERN;
7767 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7768 opts_type = OPTS_TYPE_PT_GENERATE_BE
7769 | OPTS_TYPE_PT_ADD80
7770 | OPTS_TYPE_PT_ADDBITS15;
7771 kern_type = KERN_TYPE_HMACSHA512_SLT;
7772 dgst_size = DGST_SIZE_8_8;
7773 parse_func = hmacsha512_parse_hash;
7774 sort_by_digest = sort_by_digest_8_8;
7775 opti_type = OPTI_TYPE_ZERO_BYTE
7776 | OPTI_TYPE_NOT_ITERATED;
7777 dgst_pos0 = 14;
7778 dgst_pos1 = 15;
7779 dgst_pos2 = 6;
7780 dgst_pos3 = 7;
7781 break;
7782
7783 case 1800: hash_type = HASH_TYPE_SHA512;
7784 salt_type = SALT_TYPE_EMBEDDED;
7785 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7786 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7787 kern_type = KERN_TYPE_SHA512CRYPT;
7788 dgst_size = DGST_SIZE_8_8;
7789 parse_func = sha512crypt_parse_hash;
7790 sort_by_digest = sort_by_digest_8_8;
7791 opti_type = OPTI_TYPE_ZERO_BYTE;
7792 dgst_pos0 = 0;
7793 dgst_pos1 = 1;
7794 dgst_pos2 = 2;
7795 dgst_pos3 = 3;
7796 break;
7797
7798 case 2100: hash_type = HASH_TYPE_DCC2;
7799 salt_type = SALT_TYPE_EMBEDDED;
7800 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7801 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
7802 | OPTS_TYPE_ST_LOWER
7803 | OPTS_TYPE_ST_UNICODE;
7804 kern_type = KERN_TYPE_DCC2;
7805 dgst_size = DGST_SIZE_4_4;
7806 parse_func = dcc2_parse_hash;
7807 sort_by_digest = sort_by_digest_4_4;
7808 opti_type = OPTI_TYPE_ZERO_BYTE;
7809 dgst_pos0 = 0;
7810 dgst_pos1 = 1;
7811 dgst_pos2 = 2;
7812 dgst_pos3 = 3;
7813 break;
7814
7815 case 2400: hash_type = HASH_TYPE_MD5;
7816 salt_type = SALT_TYPE_NONE;
7817 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7818 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7819 kern_type = KERN_TYPE_MD5PIX;
7820 dgst_size = DGST_SIZE_4_4;
7821 parse_func = md5pix_parse_hash;
7822 sort_by_digest = sort_by_digest_4_4;
7823 opti_type = OPTI_TYPE_ZERO_BYTE
7824 | OPTI_TYPE_PRECOMPUTE_INIT
7825 | OPTI_TYPE_PRECOMPUTE_MERKLE
7826 | OPTI_TYPE_EARLY_SKIP
7827 | OPTI_TYPE_NOT_ITERATED
7828 | OPTI_TYPE_NOT_SALTED;
7829 dgst_pos0 = 0;
7830 dgst_pos1 = 3;
7831 dgst_pos2 = 2;
7832 dgst_pos3 = 1;
7833 break;
7834
7835 case 2410: hash_type = HASH_TYPE_MD5;
7836 salt_type = SALT_TYPE_INTERN;
7837 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7838 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7839 kern_type = KERN_TYPE_MD5ASA;
7840 dgst_size = DGST_SIZE_4_4;
7841 parse_func = md5asa_parse_hash;
7842 sort_by_digest = sort_by_digest_4_4;
7843 opti_type = OPTI_TYPE_ZERO_BYTE
7844 | OPTI_TYPE_PRECOMPUTE_INIT
7845 | OPTI_TYPE_PRECOMPUTE_MERKLE
7846 | OPTI_TYPE_EARLY_SKIP
7847 | OPTI_TYPE_NOT_ITERATED;
7848 dgst_pos0 = 0;
7849 dgst_pos1 = 3;
7850 dgst_pos2 = 2;
7851 dgst_pos3 = 1;
7852 break;
7853
7854 case 2500: hash_type = HASH_TYPE_WPA;
7855 salt_type = SALT_TYPE_EMBEDDED;
7856 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7857 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7858 kern_type = KERN_TYPE_WPA;
7859 dgst_size = DGST_SIZE_4_4;
7860 parse_func = wpa_parse_hash;
7861 sort_by_digest = sort_by_digest_4_4;
7862 opti_type = OPTI_TYPE_ZERO_BYTE;
7863 dgst_pos0 = 0;
7864 dgst_pos1 = 1;
7865 dgst_pos2 = 2;
7866 dgst_pos3 = 3;
7867 break;
7868
7869 case 2600: hash_type = HASH_TYPE_MD5;
7870 salt_type = SALT_TYPE_VIRTUAL;
7871 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7872 opts_type = OPTS_TYPE_PT_GENERATE_LE
7873 | OPTS_TYPE_PT_ADD80
7874 | OPTS_TYPE_PT_ADDBITS14
7875 | OPTS_TYPE_ST_ADD80;
7876 kern_type = KERN_TYPE_MD55_PWSLT1;
7877 dgst_size = DGST_SIZE_4_4;
7878 parse_func = md5md5_parse_hash;
7879 sort_by_digest = sort_by_digest_4_4;
7880 opti_type = OPTI_TYPE_ZERO_BYTE
7881 | OPTI_TYPE_PRECOMPUTE_INIT
7882 | OPTI_TYPE_PRECOMPUTE_MERKLE
7883 | OPTI_TYPE_EARLY_SKIP;
7884 dgst_pos0 = 0;
7885 dgst_pos1 = 3;
7886 dgst_pos2 = 2;
7887 dgst_pos3 = 1;
7888 break;
7889
7890 case 2611: hash_type = HASH_TYPE_MD5;
7891 salt_type = SALT_TYPE_INTERN;
7892 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7893 opts_type = OPTS_TYPE_PT_GENERATE_LE
7894 | OPTS_TYPE_PT_ADD80
7895 | OPTS_TYPE_PT_ADDBITS14
7896 | OPTS_TYPE_ST_ADD80;
7897 kern_type = KERN_TYPE_MD55_PWSLT1;
7898 dgst_size = DGST_SIZE_4_4;
7899 parse_func = vb3_parse_hash;
7900 sort_by_digest = sort_by_digest_4_4;
7901 opti_type = OPTI_TYPE_ZERO_BYTE
7902 | OPTI_TYPE_PRECOMPUTE_INIT
7903 | OPTI_TYPE_PRECOMPUTE_MERKLE
7904 | OPTI_TYPE_EARLY_SKIP;
7905 dgst_pos0 = 0;
7906 dgst_pos1 = 3;
7907 dgst_pos2 = 2;
7908 dgst_pos3 = 1;
7909 break;
7910
7911 case 2612: hash_type = HASH_TYPE_MD5;
7912 salt_type = SALT_TYPE_EMBEDDED;
7913 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7914 opts_type = OPTS_TYPE_PT_GENERATE_LE
7915 | OPTS_TYPE_PT_ADD80
7916 | OPTS_TYPE_PT_ADDBITS14
7917 | OPTS_TYPE_ST_ADD80
7918 | OPTS_TYPE_ST_HEX;
7919 kern_type = KERN_TYPE_MD55_PWSLT1;
7920 dgst_size = DGST_SIZE_4_4;
7921 parse_func = phps_parse_hash;
7922 sort_by_digest = sort_by_digest_4_4;
7923 opti_type = OPTI_TYPE_ZERO_BYTE
7924 | OPTI_TYPE_PRECOMPUTE_INIT
7925 | OPTI_TYPE_PRECOMPUTE_MERKLE
7926 | OPTI_TYPE_EARLY_SKIP;
7927 dgst_pos0 = 0;
7928 dgst_pos1 = 3;
7929 dgst_pos2 = 2;
7930 dgst_pos3 = 1;
7931 break;
7932
7933 case 2711: hash_type = HASH_TYPE_MD5;
7934 salt_type = SALT_TYPE_INTERN;
7935 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7936 opts_type = OPTS_TYPE_PT_GENERATE_LE
7937 | OPTS_TYPE_PT_ADD80
7938 | OPTS_TYPE_PT_ADDBITS14
7939 | OPTS_TYPE_ST_ADD80;
7940 kern_type = KERN_TYPE_MD55_PWSLT2;
7941 dgst_size = DGST_SIZE_4_4;
7942 parse_func = vb30_parse_hash;
7943 sort_by_digest = sort_by_digest_4_4;
7944 opti_type = OPTI_TYPE_ZERO_BYTE
7945 | OPTI_TYPE_PRECOMPUTE_INIT
7946 | OPTI_TYPE_EARLY_SKIP;
7947 dgst_pos0 = 0;
7948 dgst_pos1 = 3;
7949 dgst_pos2 = 2;
7950 dgst_pos3 = 1;
7951 break;
7952
7953 case 2811: hash_type = HASH_TYPE_MD5;
7954 salt_type = SALT_TYPE_INTERN;
7955 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7956 opts_type = OPTS_TYPE_PT_GENERATE_LE
7957 | OPTS_TYPE_PT_ADD80
7958 | OPTS_TYPE_PT_ADDBITS14;
7959 kern_type = KERN_TYPE_MD55_SLTPW;
7960 dgst_size = DGST_SIZE_4_4;
7961 parse_func = ipb2_parse_hash;
7962 sort_by_digest = sort_by_digest_4_4;
7963 opti_type = OPTI_TYPE_ZERO_BYTE
7964 | OPTI_TYPE_PRECOMPUTE_INIT
7965 | OPTI_TYPE_EARLY_SKIP;
7966 dgst_pos0 = 0;
7967 dgst_pos1 = 3;
7968 dgst_pos2 = 2;
7969 dgst_pos3 = 1;
7970 break;
7971
7972 case 3000: hash_type = HASH_TYPE_LM;
7973 salt_type = SALT_TYPE_NONE;
7974 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7975 opts_type = OPTS_TYPE_PT_GENERATE_LE
7976 | OPTS_TYPE_PT_UPPER
7977 | OPTS_TYPE_PT_BITSLICE;
7978 kern_type = KERN_TYPE_LM;
7979 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7980 parse_func = lm_parse_hash;
7981 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7982 opti_type = OPTI_TYPE_ZERO_BYTE
7983 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7984 dgst_pos0 = 0;
7985 dgst_pos1 = 1;
7986 dgst_pos2 = 2;
7987 dgst_pos3 = 3;
7988 break;
7989
7990 case 3100: hash_type = HASH_TYPE_ORACLEH;
7991 salt_type = SALT_TYPE_INTERN;
7992 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7993 opts_type = OPTS_TYPE_PT_GENERATE_LE
7994 | OPTS_TYPE_PT_UPPER
7995 | OPTS_TYPE_ST_UPPER;
7996 kern_type = KERN_TYPE_ORACLEH;
7997 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7998 parse_func = oracleh_parse_hash;
7999 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8000 opti_type = OPTI_TYPE_ZERO_BYTE;
8001 dgst_pos0 = 0;
8002 dgst_pos1 = 1;
8003 dgst_pos2 = 2;
8004 dgst_pos3 = 3;
8005 break;
8006
8007 case 3200: hash_type = HASH_TYPE_BCRYPT;
8008 salt_type = SALT_TYPE_EMBEDDED;
8009 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8010 opts_type = OPTS_TYPE_PT_GENERATE_LE
8011 | OPTS_TYPE_ST_GENERATE_LE;
8012 kern_type = KERN_TYPE_BCRYPT;
8013 dgst_size = DGST_SIZE_4_6;
8014 parse_func = bcrypt_parse_hash;
8015 sort_by_digest = sort_by_digest_4_6;
8016 opti_type = OPTI_TYPE_ZERO_BYTE;
8017 dgst_pos0 = 0;
8018 dgst_pos1 = 1;
8019 dgst_pos2 = 2;
8020 dgst_pos3 = 3;
8021 break;
8022
8023 case 3710: hash_type = HASH_TYPE_MD5;
8024 salt_type = SALT_TYPE_INTERN;
8025 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8026 opts_type = OPTS_TYPE_PT_GENERATE_LE
8027 | OPTS_TYPE_PT_ADD80
8028 | OPTS_TYPE_PT_ADDBITS14;
8029 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8030 dgst_size = DGST_SIZE_4_4;
8031 parse_func = md5s_parse_hash;
8032 sort_by_digest = sort_by_digest_4_4;
8033 opti_type = OPTI_TYPE_ZERO_BYTE
8034 | OPTI_TYPE_PRECOMPUTE_INIT
8035 | OPTI_TYPE_PRECOMPUTE_MERKLE
8036 | OPTI_TYPE_EARLY_SKIP;
8037 dgst_pos0 = 0;
8038 dgst_pos1 = 3;
8039 dgst_pos2 = 2;
8040 dgst_pos3 = 1;
8041 break;
8042
8043 case 3711: hash_type = HASH_TYPE_MD5;
8044 salt_type = SALT_TYPE_EMBEDDED;
8045 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8046 opts_type = OPTS_TYPE_PT_GENERATE_LE
8047 | OPTS_TYPE_PT_ADD80
8048 | OPTS_TYPE_PT_ADDBITS14;
8049 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8050 dgst_size = DGST_SIZE_4_4;
8051 parse_func = mediawiki_b_parse_hash;
8052 sort_by_digest = sort_by_digest_4_4;
8053 opti_type = OPTI_TYPE_ZERO_BYTE
8054 | OPTI_TYPE_PRECOMPUTE_INIT
8055 | OPTI_TYPE_PRECOMPUTE_MERKLE
8056 | OPTI_TYPE_EARLY_SKIP;
8057 dgst_pos0 = 0;
8058 dgst_pos1 = 3;
8059 dgst_pos2 = 2;
8060 dgst_pos3 = 1;
8061 break;
8062
8063 case 3800: hash_type = HASH_TYPE_MD5;
8064 salt_type = SALT_TYPE_INTERN;
8065 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8066 opts_type = OPTS_TYPE_PT_GENERATE_LE
8067 | OPTS_TYPE_ST_ADDBITS14;
8068 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8069 dgst_size = DGST_SIZE_4_4;
8070 parse_func = md5s_parse_hash;
8071 sort_by_digest = sort_by_digest_4_4;
8072 opti_type = OPTI_TYPE_ZERO_BYTE
8073 | OPTI_TYPE_PRECOMPUTE_INIT
8074 | OPTI_TYPE_PRECOMPUTE_MERKLE
8075 | OPTI_TYPE_EARLY_SKIP
8076 | OPTI_TYPE_NOT_ITERATED
8077 | OPTI_TYPE_RAW_HASH;
8078 dgst_pos0 = 0;
8079 dgst_pos1 = 3;
8080 dgst_pos2 = 2;
8081 dgst_pos3 = 1;
8082 break;
8083
8084 case 4300: hash_type = HASH_TYPE_MD5;
8085 salt_type = SALT_TYPE_VIRTUAL;
8086 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8087 opts_type = OPTS_TYPE_PT_GENERATE_LE
8088 | OPTS_TYPE_PT_ADD80
8089 | OPTS_TYPE_PT_ADDBITS14
8090 | OPTS_TYPE_ST_ADD80;
8091 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8092 dgst_size = DGST_SIZE_4_4;
8093 parse_func = md5md5_parse_hash;
8094 sort_by_digest = sort_by_digest_4_4;
8095 opti_type = OPTI_TYPE_ZERO_BYTE
8096 | OPTI_TYPE_PRECOMPUTE_INIT
8097 | OPTI_TYPE_PRECOMPUTE_MERKLE
8098 | OPTI_TYPE_EARLY_SKIP;
8099 dgst_pos0 = 0;
8100 dgst_pos1 = 3;
8101 dgst_pos2 = 2;
8102 dgst_pos3 = 1;
8103 break;
8104
8105
8106 case 4400: hash_type = HASH_TYPE_MD5;
8107 salt_type = SALT_TYPE_NONE;
8108 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8109 opts_type = OPTS_TYPE_PT_GENERATE_BE
8110 | OPTS_TYPE_PT_ADD80
8111 | OPTS_TYPE_PT_ADDBITS15;
8112 kern_type = KERN_TYPE_MD5_SHA1;
8113 dgst_size = DGST_SIZE_4_4;
8114 parse_func = md5_parse_hash;
8115 sort_by_digest = sort_by_digest_4_4;
8116 opti_type = OPTI_TYPE_ZERO_BYTE
8117 | OPTI_TYPE_PRECOMPUTE_INIT
8118 | OPTI_TYPE_PRECOMPUTE_MERKLE
8119 | OPTI_TYPE_EARLY_SKIP
8120 | OPTI_TYPE_NOT_ITERATED
8121 | OPTI_TYPE_NOT_SALTED
8122 | OPTI_TYPE_RAW_HASH;
8123 dgst_pos0 = 0;
8124 dgst_pos1 = 3;
8125 dgst_pos2 = 2;
8126 dgst_pos3 = 1;
8127 break;
8128
8129 case 4500: hash_type = HASH_TYPE_SHA1;
8130 salt_type = SALT_TYPE_NONE;
8131 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8132 opts_type = OPTS_TYPE_PT_GENERATE_BE
8133 | OPTS_TYPE_PT_ADD80
8134 | OPTS_TYPE_PT_ADDBITS15;
8135 kern_type = KERN_TYPE_SHA11;
8136 dgst_size = DGST_SIZE_4_5;
8137 parse_func = sha1_parse_hash;
8138 sort_by_digest = sort_by_digest_4_5;
8139 opti_type = OPTI_TYPE_ZERO_BYTE
8140 | OPTI_TYPE_PRECOMPUTE_INIT
8141 | OPTI_TYPE_PRECOMPUTE_MERKLE
8142 | OPTI_TYPE_EARLY_SKIP
8143 | OPTI_TYPE_NOT_SALTED;
8144 dgst_pos0 = 3;
8145 dgst_pos1 = 4;
8146 dgst_pos2 = 2;
8147 dgst_pos3 = 1;
8148 break;
8149
8150 case 4700: hash_type = HASH_TYPE_SHA1;
8151 salt_type = SALT_TYPE_NONE;
8152 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8153 opts_type = OPTS_TYPE_PT_GENERATE_LE
8154 | OPTS_TYPE_PT_ADD80
8155 | OPTS_TYPE_PT_ADDBITS14;
8156 kern_type = KERN_TYPE_SHA1_MD5;
8157 dgst_size = DGST_SIZE_4_5;
8158 parse_func = sha1_parse_hash;
8159 sort_by_digest = sort_by_digest_4_5;
8160 opti_type = OPTI_TYPE_ZERO_BYTE
8161 | OPTI_TYPE_PRECOMPUTE_INIT
8162 | OPTI_TYPE_PRECOMPUTE_MERKLE
8163 | OPTI_TYPE_EARLY_SKIP
8164 | OPTI_TYPE_NOT_ITERATED
8165 | OPTI_TYPE_NOT_SALTED
8166 | OPTI_TYPE_RAW_HASH;
8167 dgst_pos0 = 3;
8168 dgst_pos1 = 4;
8169 dgst_pos2 = 2;
8170 dgst_pos3 = 1;
8171 break;
8172
8173 case 4800: hash_type = HASH_TYPE_MD5;
8174 salt_type = SALT_TYPE_EMBEDDED;
8175 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8176 opts_type = OPTS_TYPE_PT_GENERATE_LE
8177 | OPTS_TYPE_PT_ADDBITS14;
8178 kern_type = KERN_TYPE_MD5_CHAP;
8179 dgst_size = DGST_SIZE_4_4;
8180 parse_func = chap_parse_hash;
8181 sort_by_digest = sort_by_digest_4_4;
8182 opti_type = OPTI_TYPE_ZERO_BYTE
8183 | OPTI_TYPE_PRECOMPUTE_INIT
8184 | OPTI_TYPE_PRECOMPUTE_MERKLE
8185 | OPTI_TYPE_MEET_IN_MIDDLE
8186 | OPTI_TYPE_EARLY_SKIP
8187 | OPTI_TYPE_NOT_ITERATED
8188 | OPTI_TYPE_RAW_HASH;
8189 dgst_pos0 = 0;
8190 dgst_pos1 = 3;
8191 dgst_pos2 = 2;
8192 dgst_pos3 = 1;
8193 break;
8194
8195 case 4900: hash_type = HASH_TYPE_SHA1;
8196 salt_type = SALT_TYPE_INTERN;
8197 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8198 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8199 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8200 dgst_size = DGST_SIZE_4_5;
8201 parse_func = sha1s_parse_hash;
8202 sort_by_digest = sort_by_digest_4_5;
8203 opti_type = OPTI_TYPE_ZERO_BYTE
8204 | OPTI_TYPE_PRECOMPUTE_INIT
8205 | OPTI_TYPE_PRECOMPUTE_MERKLE
8206 | OPTI_TYPE_EARLY_SKIP;
8207 dgst_pos0 = 3;
8208 dgst_pos1 = 4;
8209 dgst_pos2 = 2;
8210 dgst_pos3 = 1;
8211 break;
8212
8213 case 5000: hash_type = HASH_TYPE_KECCAK;
8214 salt_type = SALT_TYPE_EMBEDDED;
8215 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8216 opts_type = OPTS_TYPE_PT_GENERATE_LE
8217 | OPTS_TYPE_PT_ADD01;
8218 kern_type = KERN_TYPE_KECCAK;
8219 dgst_size = DGST_SIZE_8_25;
8220 parse_func = keccak_parse_hash;
8221 sort_by_digest = sort_by_digest_8_25;
8222 opti_type = OPTI_TYPE_ZERO_BYTE
8223 | OPTI_TYPE_RAW_HASH;
8224 dgst_pos0 = 2;
8225 dgst_pos1 = 3;
8226 dgst_pos2 = 4;
8227 dgst_pos3 = 5;
8228 break;
8229
8230 case 5100: hash_type = HASH_TYPE_MD5H;
8231 salt_type = SALT_TYPE_NONE;
8232 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8233 opts_type = OPTS_TYPE_PT_GENERATE_LE
8234 | OPTS_TYPE_PT_ADD80
8235 | OPTS_TYPE_PT_ADDBITS14;
8236 kern_type = KERN_TYPE_MD5H;
8237 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8238 parse_func = md5half_parse_hash;
8239 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8240 opti_type = OPTI_TYPE_ZERO_BYTE
8241 | OPTI_TYPE_RAW_HASH;
8242 dgst_pos0 = 0;
8243 dgst_pos1 = 1;
8244 dgst_pos2 = 2;
8245 dgst_pos3 = 3;
8246 break;
8247
8248 case 5200: hash_type = HASH_TYPE_SHA256;
8249 salt_type = SALT_TYPE_EMBEDDED;
8250 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8251 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8252 kern_type = KERN_TYPE_PSAFE3;
8253 dgst_size = DGST_SIZE_4_8;
8254 parse_func = psafe3_parse_hash;
8255 sort_by_digest = sort_by_digest_4_8;
8256 opti_type = OPTI_TYPE_ZERO_BYTE;
8257 dgst_pos0 = 0;
8258 dgst_pos1 = 1;
8259 dgst_pos2 = 2;
8260 dgst_pos3 = 3;
8261 break;
8262
8263 case 5300: hash_type = HASH_TYPE_MD5;
8264 salt_type = SALT_TYPE_EMBEDDED;
8265 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8266 opts_type = OPTS_TYPE_PT_GENERATE_LE
8267 | OPTS_TYPE_ST_ADD80;
8268 kern_type = KERN_TYPE_IKEPSK_MD5;
8269 dgst_size = DGST_SIZE_4_4;
8270 parse_func = ikepsk_md5_parse_hash;
8271 sort_by_digest = sort_by_digest_4_4;
8272 opti_type = OPTI_TYPE_ZERO_BYTE;
8273 dgst_pos0 = 0;
8274 dgst_pos1 = 3;
8275 dgst_pos2 = 2;
8276 dgst_pos3 = 1;
8277 break;
8278
8279 case 5400: hash_type = HASH_TYPE_SHA1;
8280 salt_type = SALT_TYPE_EMBEDDED;
8281 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8282 opts_type = OPTS_TYPE_PT_GENERATE_BE
8283 | OPTS_TYPE_ST_ADD80;
8284 kern_type = KERN_TYPE_IKEPSK_SHA1;
8285 dgst_size = DGST_SIZE_4_5;
8286 parse_func = ikepsk_sha1_parse_hash;
8287 sort_by_digest = sort_by_digest_4_5;
8288 opti_type = OPTI_TYPE_ZERO_BYTE;
8289 dgst_pos0 = 3;
8290 dgst_pos1 = 4;
8291 dgst_pos2 = 2;
8292 dgst_pos3 = 1;
8293 break;
8294
8295 case 5500: hash_type = HASH_TYPE_NETNTLM;
8296 salt_type = SALT_TYPE_EMBEDDED;
8297 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8298 opts_type = OPTS_TYPE_PT_GENERATE_LE
8299 | OPTS_TYPE_PT_ADD80
8300 | OPTS_TYPE_PT_ADDBITS14
8301 | OPTS_TYPE_PT_UNICODE
8302 | OPTS_TYPE_ST_HEX;
8303 kern_type = KERN_TYPE_NETNTLMv1;
8304 dgst_size = DGST_SIZE_4_4;
8305 parse_func = netntlmv1_parse_hash;
8306 sort_by_digest = sort_by_digest_4_4;
8307 opti_type = OPTI_TYPE_ZERO_BYTE
8308 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8309 dgst_pos0 = 0;
8310 dgst_pos1 = 1;
8311 dgst_pos2 = 2;
8312 dgst_pos3 = 3;
8313 break;
8314
8315 case 5600: hash_type = HASH_TYPE_MD5;
8316 salt_type = SALT_TYPE_EMBEDDED;
8317 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8318 opts_type = OPTS_TYPE_PT_GENERATE_LE
8319 | OPTS_TYPE_PT_ADD80
8320 | OPTS_TYPE_PT_ADDBITS14
8321 | OPTS_TYPE_PT_UNICODE;
8322 kern_type = KERN_TYPE_NETNTLMv2;
8323 dgst_size = DGST_SIZE_4_4;
8324 parse_func = netntlmv2_parse_hash;
8325 sort_by_digest = sort_by_digest_4_4;
8326 opti_type = OPTI_TYPE_ZERO_BYTE;
8327 dgst_pos0 = 0;
8328 dgst_pos1 = 3;
8329 dgst_pos2 = 2;
8330 dgst_pos3 = 1;
8331 break;
8332
8333 case 5700: hash_type = HASH_TYPE_SHA256;
8334 salt_type = SALT_TYPE_NONE;
8335 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8336 opts_type = OPTS_TYPE_PT_GENERATE_BE
8337 | OPTS_TYPE_PT_ADD80
8338 | OPTS_TYPE_PT_ADDBITS15;
8339 kern_type = KERN_TYPE_SHA256;
8340 dgst_size = DGST_SIZE_4_8;
8341 parse_func = cisco4_parse_hash;
8342 sort_by_digest = sort_by_digest_4_8;
8343 opti_type = OPTI_TYPE_ZERO_BYTE
8344 | OPTI_TYPE_PRECOMPUTE_INIT
8345 | OPTI_TYPE_PRECOMPUTE_MERKLE
8346 | OPTI_TYPE_EARLY_SKIP
8347 | OPTI_TYPE_NOT_ITERATED
8348 | OPTI_TYPE_NOT_SALTED
8349 | OPTI_TYPE_RAW_HASH;
8350 dgst_pos0 = 3;
8351 dgst_pos1 = 7;
8352 dgst_pos2 = 2;
8353 dgst_pos3 = 6;
8354 break;
8355
8356 case 5800: hash_type = HASH_TYPE_SHA1;
8357 salt_type = SALT_TYPE_INTERN;
8358 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8359 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8360 | OPTS_TYPE_ST_ADD80;
8361 kern_type = KERN_TYPE_ANDROIDPIN;
8362 dgst_size = DGST_SIZE_4_5;
8363 parse_func = androidpin_parse_hash;
8364 sort_by_digest = sort_by_digest_4_5;
8365 opti_type = OPTI_TYPE_ZERO_BYTE;
8366 dgst_pos0 = 0;
8367 dgst_pos1 = 1;
8368 dgst_pos2 = 2;
8369 dgst_pos3 = 3;
8370 break;
8371
8372 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8373 salt_type = SALT_TYPE_NONE;
8374 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8375 opts_type = OPTS_TYPE_PT_GENERATE_LE
8376 | OPTS_TYPE_PT_ADD80;
8377 kern_type = KERN_TYPE_RIPEMD160;
8378 dgst_size = DGST_SIZE_4_5;
8379 parse_func = ripemd160_parse_hash;
8380 sort_by_digest = sort_by_digest_4_5;
8381 opti_type = OPTI_TYPE_ZERO_BYTE;
8382 dgst_pos0 = 0;
8383 dgst_pos1 = 1;
8384 dgst_pos2 = 2;
8385 dgst_pos3 = 3;
8386 break;
8387
8388 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8389 salt_type = SALT_TYPE_NONE;
8390 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8391 opts_type = OPTS_TYPE_PT_GENERATE_BE
8392 | OPTS_TYPE_PT_ADD80;
8393 kern_type = KERN_TYPE_WHIRLPOOL;
8394 dgst_size = DGST_SIZE_4_16;
8395 parse_func = whirlpool_parse_hash;
8396 sort_by_digest = sort_by_digest_4_16;
8397 opti_type = OPTI_TYPE_ZERO_BYTE;
8398 dgst_pos0 = 0;
8399 dgst_pos1 = 1;
8400 dgst_pos2 = 2;
8401 dgst_pos3 = 3;
8402 break;
8403
8404 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8405 salt_type = SALT_TYPE_EMBEDDED;
8406 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8407 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8408 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8409 dgst_size = DGST_SIZE_4_5;
8410 parse_func = truecrypt_parse_hash_2k;
8411 sort_by_digest = sort_by_digest_4_5;
8412 opti_type = OPTI_TYPE_ZERO_BYTE;
8413 dgst_pos0 = 0;
8414 dgst_pos1 = 1;
8415 dgst_pos2 = 2;
8416 dgst_pos3 = 3;
8417 break;
8418
8419 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8420 salt_type = SALT_TYPE_EMBEDDED;
8421 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8422 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8423 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8424 dgst_size = DGST_SIZE_4_5;
8425 parse_func = truecrypt_parse_hash_2k;
8426 sort_by_digest = sort_by_digest_4_5;
8427 opti_type = OPTI_TYPE_ZERO_BYTE;
8428 dgst_pos0 = 0;
8429 dgst_pos1 = 1;
8430 dgst_pos2 = 2;
8431 dgst_pos3 = 3;
8432 break;
8433
8434 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8435 salt_type = SALT_TYPE_EMBEDDED;
8436 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8437 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8438 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8439 dgst_size = DGST_SIZE_4_5;
8440 parse_func = truecrypt_parse_hash_2k;
8441 sort_by_digest = sort_by_digest_4_5;
8442 opti_type = OPTI_TYPE_ZERO_BYTE;
8443 dgst_pos0 = 0;
8444 dgst_pos1 = 1;
8445 dgst_pos2 = 2;
8446 dgst_pos3 = 3;
8447 break;
8448
8449 case 6221: hash_type = HASH_TYPE_SHA512;
8450 salt_type = SALT_TYPE_EMBEDDED;
8451 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8452 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8453 kern_type = KERN_TYPE_TCSHA512_XTS512;
8454 dgst_size = DGST_SIZE_8_8;
8455 parse_func = truecrypt_parse_hash_1k;
8456 sort_by_digest = sort_by_digest_8_8;
8457 opti_type = OPTI_TYPE_ZERO_BYTE;
8458 dgst_pos0 = 0;
8459 dgst_pos1 = 1;
8460 dgst_pos2 = 2;
8461 dgst_pos3 = 3;
8462 break;
8463
8464 case 6222: hash_type = HASH_TYPE_SHA512;
8465 salt_type = SALT_TYPE_EMBEDDED;
8466 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8467 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8468 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8469 dgst_size = DGST_SIZE_8_8;
8470 parse_func = truecrypt_parse_hash_1k;
8471 sort_by_digest = sort_by_digest_8_8;
8472 opti_type = OPTI_TYPE_ZERO_BYTE;
8473 dgst_pos0 = 0;
8474 dgst_pos1 = 1;
8475 dgst_pos2 = 2;
8476 dgst_pos3 = 3;
8477 break;
8478
8479 case 6223: hash_type = HASH_TYPE_SHA512;
8480 salt_type = SALT_TYPE_EMBEDDED;
8481 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8482 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8483 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8484 dgst_size = DGST_SIZE_8_8;
8485 parse_func = truecrypt_parse_hash_1k;
8486 sort_by_digest = sort_by_digest_8_8;
8487 opti_type = OPTI_TYPE_ZERO_BYTE;
8488 dgst_pos0 = 0;
8489 dgst_pos1 = 1;
8490 dgst_pos2 = 2;
8491 dgst_pos3 = 3;
8492 break;
8493
8494 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8495 salt_type = SALT_TYPE_EMBEDDED;
8496 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8497 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8498 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8499 dgst_size = DGST_SIZE_4_8;
8500 parse_func = truecrypt_parse_hash_1k;
8501 sort_by_digest = sort_by_digest_4_8;
8502 opti_type = OPTI_TYPE_ZERO_BYTE;
8503 dgst_pos0 = 0;
8504 dgst_pos1 = 1;
8505 dgst_pos2 = 2;
8506 dgst_pos3 = 3;
8507 break;
8508
8509 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8510 salt_type = SALT_TYPE_EMBEDDED;
8511 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8512 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8513 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8514 dgst_size = DGST_SIZE_4_8;
8515 parse_func = truecrypt_parse_hash_1k;
8516 sort_by_digest = sort_by_digest_4_8;
8517 opti_type = OPTI_TYPE_ZERO_BYTE;
8518 dgst_pos0 = 0;
8519 dgst_pos1 = 1;
8520 dgst_pos2 = 2;
8521 dgst_pos3 = 3;
8522 break;
8523
8524 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8525 salt_type = SALT_TYPE_EMBEDDED;
8526 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8527 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8528 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8529 dgst_size = DGST_SIZE_4_8;
8530 parse_func = truecrypt_parse_hash_1k;
8531 sort_by_digest = sort_by_digest_4_8;
8532 opti_type = OPTI_TYPE_ZERO_BYTE;
8533 dgst_pos0 = 0;
8534 dgst_pos1 = 1;
8535 dgst_pos2 = 2;
8536 dgst_pos3 = 3;
8537 break;
8538
8539 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8540 salt_type = SALT_TYPE_EMBEDDED;
8541 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8542 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8543 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8544 dgst_size = DGST_SIZE_4_5;
8545 parse_func = truecrypt_parse_hash_1k;
8546 sort_by_digest = sort_by_digest_4_5;
8547 opti_type = OPTI_TYPE_ZERO_BYTE;
8548 dgst_pos0 = 0;
8549 dgst_pos1 = 1;
8550 dgst_pos2 = 2;
8551 dgst_pos3 = 3;
8552 break;
8553
8554 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8555 salt_type = SALT_TYPE_EMBEDDED;
8556 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8557 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8558 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8559 dgst_size = DGST_SIZE_4_5;
8560 parse_func = truecrypt_parse_hash_1k;
8561 sort_by_digest = sort_by_digest_4_5;
8562 opti_type = OPTI_TYPE_ZERO_BYTE;
8563 dgst_pos0 = 0;
8564 dgst_pos1 = 1;
8565 dgst_pos2 = 2;
8566 dgst_pos3 = 3;
8567 break;
8568
8569 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8570 salt_type = SALT_TYPE_EMBEDDED;
8571 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8572 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8573 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8574 dgst_size = DGST_SIZE_4_5;
8575 parse_func = truecrypt_parse_hash_1k;
8576 sort_by_digest = sort_by_digest_4_5;
8577 opti_type = OPTI_TYPE_ZERO_BYTE;
8578 dgst_pos0 = 0;
8579 dgst_pos1 = 1;
8580 dgst_pos2 = 2;
8581 dgst_pos3 = 3;
8582 break;
8583
8584 case 6300: hash_type = HASH_TYPE_MD5;
8585 salt_type = SALT_TYPE_EMBEDDED;
8586 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8587 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8588 kern_type = KERN_TYPE_MD5AIX;
8589 dgst_size = DGST_SIZE_4_4;
8590 parse_func = md5aix_parse_hash;
8591 sort_by_digest = sort_by_digest_4_4;
8592 opti_type = OPTI_TYPE_ZERO_BYTE;
8593 dgst_pos0 = 0;
8594 dgst_pos1 = 1;
8595 dgst_pos2 = 2;
8596 dgst_pos3 = 3;
8597 break;
8598
8599 case 6400: hash_type = HASH_TYPE_SHA256;
8600 salt_type = SALT_TYPE_EMBEDDED;
8601 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8602 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8603 kern_type = KERN_TYPE_SHA256AIX;
8604 dgst_size = DGST_SIZE_4_8;
8605 parse_func = sha256aix_parse_hash;
8606 sort_by_digest = sort_by_digest_4_8;
8607 opti_type = OPTI_TYPE_ZERO_BYTE;
8608 dgst_pos0 = 0;
8609 dgst_pos1 = 1;
8610 dgst_pos2 = 2;
8611 dgst_pos3 = 3;
8612 break;
8613
8614 case 6500: hash_type = HASH_TYPE_SHA512;
8615 salt_type = SALT_TYPE_EMBEDDED;
8616 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8617 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8618 kern_type = KERN_TYPE_SHA512AIX;
8619 dgst_size = DGST_SIZE_8_8;
8620 parse_func = sha512aix_parse_hash;
8621 sort_by_digest = sort_by_digest_8_8;
8622 opti_type = OPTI_TYPE_ZERO_BYTE;
8623 dgst_pos0 = 0;
8624 dgst_pos1 = 1;
8625 dgst_pos2 = 2;
8626 dgst_pos3 = 3;
8627 break;
8628
8629 case 6600: hash_type = HASH_TYPE_AES;
8630 salt_type = SALT_TYPE_EMBEDDED;
8631 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8632 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8633 kern_type = KERN_TYPE_AGILEKEY;
8634 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8635 parse_func = agilekey_parse_hash;
8636 sort_by_digest = sort_by_digest_4_5;
8637 opti_type = OPTI_TYPE_ZERO_BYTE;
8638 dgst_pos0 = 0;
8639 dgst_pos1 = 1;
8640 dgst_pos2 = 2;
8641 dgst_pos3 = 3;
8642 break;
8643
8644 case 6700: hash_type = HASH_TYPE_SHA1;
8645 salt_type = SALT_TYPE_EMBEDDED;
8646 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8647 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8648 kern_type = KERN_TYPE_SHA1AIX;
8649 dgst_size = DGST_SIZE_4_5;
8650 parse_func = sha1aix_parse_hash;
8651 sort_by_digest = sort_by_digest_4_5;
8652 opti_type = OPTI_TYPE_ZERO_BYTE;
8653 dgst_pos0 = 0;
8654 dgst_pos1 = 1;
8655 dgst_pos2 = 2;
8656 dgst_pos3 = 3;
8657 break;
8658
8659 case 6800: hash_type = HASH_TYPE_AES;
8660 salt_type = SALT_TYPE_EMBEDDED;
8661 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8662 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8663 kern_type = KERN_TYPE_LASTPASS;
8664 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
8665 parse_func = lastpass_parse_hash;
8666 sort_by_digest = sort_by_digest_4_8;
8667 opti_type = OPTI_TYPE_ZERO_BYTE;
8668 dgst_pos0 = 0;
8669 dgst_pos1 = 1;
8670 dgst_pos2 = 2;
8671 dgst_pos3 = 3;
8672 break;
8673
8674 case 6900: hash_type = HASH_TYPE_GOST;
8675 salt_type = SALT_TYPE_NONE;
8676 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8677 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8678 kern_type = KERN_TYPE_GOST;
8679 dgst_size = DGST_SIZE_4_8;
8680 parse_func = gost_parse_hash;
8681 sort_by_digest = sort_by_digest_4_8;
8682 opti_type = OPTI_TYPE_ZERO_BYTE;
8683 dgst_pos0 = 0;
8684 dgst_pos1 = 1;
8685 dgst_pos2 = 2;
8686 dgst_pos3 = 3;
8687 break;
8688
8689 case 7100: hash_type = HASH_TYPE_SHA512;
8690 salt_type = SALT_TYPE_EMBEDDED;
8691 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8692 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8693 kern_type = KERN_TYPE_PBKDF2_SHA512;
8694 dgst_size = DGST_SIZE_8_16;
8695 parse_func = sha512osx_parse_hash;
8696 sort_by_digest = sort_by_digest_8_16;
8697 opti_type = OPTI_TYPE_ZERO_BYTE;
8698 dgst_pos0 = 0;
8699 dgst_pos1 = 1;
8700 dgst_pos2 = 2;
8701 dgst_pos3 = 3;
8702 break;
8703
8704 case 7200: hash_type = HASH_TYPE_SHA512;
8705 salt_type = SALT_TYPE_EMBEDDED;
8706 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8707 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8708 kern_type = KERN_TYPE_PBKDF2_SHA512;
8709 dgst_size = DGST_SIZE_8_16;
8710 parse_func = sha512grub_parse_hash;
8711 sort_by_digest = sort_by_digest_8_16;
8712 opti_type = OPTI_TYPE_ZERO_BYTE;
8713 dgst_pos0 = 0;
8714 dgst_pos1 = 1;
8715 dgst_pos2 = 2;
8716 dgst_pos3 = 3;
8717 break;
8718
8719 case 7300: hash_type = HASH_TYPE_SHA1;
8720 salt_type = SALT_TYPE_EMBEDDED;
8721 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8722 opts_type = OPTS_TYPE_PT_GENERATE_BE
8723 | OPTS_TYPE_ST_ADD80
8724 | OPTS_TYPE_ST_ADDBITS15;
8725 kern_type = KERN_TYPE_RAKP;
8726 dgst_size = DGST_SIZE_4_5;
8727 parse_func = rakp_parse_hash;
8728 sort_by_digest = sort_by_digest_4_5;
8729 opti_type = OPTI_TYPE_ZERO_BYTE
8730 | OPTI_TYPE_NOT_ITERATED;
8731 dgst_pos0 = 3;
8732 dgst_pos1 = 4;
8733 dgst_pos2 = 2;
8734 dgst_pos3 = 1;
8735 break;
8736
8737 case 7400: hash_type = HASH_TYPE_SHA256;
8738 salt_type = SALT_TYPE_EMBEDDED;
8739 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8740 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8741 kern_type = KERN_TYPE_SHA256CRYPT;
8742 dgst_size = DGST_SIZE_4_8;
8743 parse_func = sha256crypt_parse_hash;
8744 sort_by_digest = sort_by_digest_4_8;
8745 opti_type = OPTI_TYPE_ZERO_BYTE;
8746 dgst_pos0 = 0;
8747 dgst_pos1 = 1;
8748 dgst_pos2 = 2;
8749 dgst_pos3 = 3;
8750 break;
8751
8752 case 7500: hash_type = HASH_TYPE_KRB5PA;
8753 salt_type = SALT_TYPE_EMBEDDED;
8754 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8755 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8756 kern_type = KERN_TYPE_KRB5PA;
8757 dgst_size = DGST_SIZE_4_4;
8758 parse_func = krb5pa_parse_hash;
8759 sort_by_digest = sort_by_digest_4_4;
8760 opti_type = OPTI_TYPE_ZERO_BYTE
8761 | OPTI_TYPE_NOT_ITERATED;
8762 dgst_pos0 = 3;
8763 dgst_pos1 = 7;
8764 dgst_pos2 = 2;
8765 dgst_pos3 = 6;
8766 break;
8767
8768 case 7600: hash_type = HASH_TYPE_SHA1;
8769 salt_type = SALT_TYPE_INTERN;
8770 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8771 opts_type = OPTS_TYPE_PT_GENERATE_BE
8772 | OPTS_TYPE_PT_ADD80
8773 | OPTS_TYPE_PT_ADDBITS15;
8774 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
8775 dgst_size = DGST_SIZE_4_5;
8776 parse_func = redmine_parse_hash;
8777 sort_by_digest = sort_by_digest_4_5;
8778 opti_type = OPTI_TYPE_ZERO_BYTE
8779 | OPTI_TYPE_PRECOMPUTE_INIT
8780 | OPTI_TYPE_EARLY_SKIP
8781 | OPTI_TYPE_NOT_ITERATED
8782 | OPTI_TYPE_PREPENDED_SALT;
8783 dgst_pos0 = 3;
8784 dgst_pos1 = 4;
8785 dgst_pos2 = 2;
8786 dgst_pos3 = 1;
8787 break;
8788
8789 case 7700: hash_type = HASH_TYPE_SAPB;
8790 salt_type = SALT_TYPE_EMBEDDED;
8791 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8792 opts_type = OPTS_TYPE_PT_GENERATE_LE
8793 | OPTS_TYPE_PT_UPPER
8794 | OPTS_TYPE_ST_UPPER;
8795 kern_type = KERN_TYPE_SAPB;
8796 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8797 parse_func = sapb_parse_hash;
8798 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8799 opti_type = OPTI_TYPE_ZERO_BYTE
8800 | OPTI_TYPE_PRECOMPUTE_INIT
8801 | OPTI_TYPE_NOT_ITERATED;
8802 dgst_pos0 = 0;
8803 dgst_pos1 = 1;
8804 dgst_pos2 = 2;
8805 dgst_pos3 = 3;
8806 break;
8807
8808 case 7800: hash_type = HASH_TYPE_SAPG;
8809 salt_type = SALT_TYPE_EMBEDDED;
8810 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8811 opts_type = OPTS_TYPE_PT_GENERATE_BE
8812 | OPTS_TYPE_ST_ADD80
8813 | OPTS_TYPE_ST_UPPER;
8814 kern_type = KERN_TYPE_SAPG;
8815 dgst_size = DGST_SIZE_4_5;
8816 parse_func = sapg_parse_hash;
8817 sort_by_digest = sort_by_digest_4_5;
8818 opti_type = OPTI_TYPE_ZERO_BYTE
8819 | OPTI_TYPE_PRECOMPUTE_INIT
8820 | OPTI_TYPE_NOT_ITERATED;
8821 dgst_pos0 = 3;
8822 dgst_pos1 = 4;
8823 dgst_pos2 = 2;
8824 dgst_pos3 = 1;
8825 break;
8826
8827 case 7900: hash_type = HASH_TYPE_SHA512;
8828 salt_type = SALT_TYPE_EMBEDDED;
8829 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8830 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8831 kern_type = KERN_TYPE_DRUPAL7;
8832 dgst_size = DGST_SIZE_8_8;
8833 parse_func = drupal7_parse_hash;
8834 sort_by_digest = sort_by_digest_8_8;
8835 opti_type = OPTI_TYPE_ZERO_BYTE;
8836 dgst_pos0 = 0;
8837 dgst_pos1 = 1;
8838 dgst_pos2 = 2;
8839 dgst_pos3 = 3;
8840 break;
8841
8842 case 8000: hash_type = HASH_TYPE_SHA256;
8843 salt_type = SALT_TYPE_EMBEDDED;
8844 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8845 opts_type = OPTS_TYPE_PT_GENERATE_BE
8846 | OPTS_TYPE_PT_UNICODE
8847 | OPTS_TYPE_ST_ADD80
8848 | OPTS_TYPE_ST_HEX;
8849 kern_type = KERN_TYPE_SYBASEASE;
8850 dgst_size = DGST_SIZE_4_8;
8851 parse_func = sybasease_parse_hash;
8852 sort_by_digest = sort_by_digest_4_8;
8853 opti_type = OPTI_TYPE_ZERO_BYTE
8854 | OPTI_TYPE_PRECOMPUTE_INIT
8855 | OPTI_TYPE_EARLY_SKIP
8856 | OPTI_TYPE_NOT_ITERATED
8857 | OPTI_TYPE_RAW_HASH;
8858 dgst_pos0 = 3;
8859 dgst_pos1 = 7;
8860 dgst_pos2 = 2;
8861 dgst_pos3 = 6;
8862 break;
8863
8864 case 8100: hash_type = HASH_TYPE_SHA1;
8865 salt_type = SALT_TYPE_EMBEDDED;
8866 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8867 opts_type = OPTS_TYPE_PT_GENERATE_BE;
8868 kern_type = KERN_TYPE_NETSCALER;
8869 dgst_size = DGST_SIZE_4_5;
8870 parse_func = netscaler_parse_hash;
8871 sort_by_digest = sort_by_digest_4_5;
8872 opti_type = OPTI_TYPE_ZERO_BYTE
8873 | OPTI_TYPE_PRECOMPUTE_INIT
8874 | OPTI_TYPE_PRECOMPUTE_MERKLE
8875 | OPTI_TYPE_EARLY_SKIP
8876 | OPTI_TYPE_NOT_ITERATED
8877 | OPTI_TYPE_PREPENDED_SALT
8878 | OPTI_TYPE_RAW_HASH;
8879 dgst_pos0 = 3;
8880 dgst_pos1 = 4;
8881 dgst_pos2 = 2;
8882 dgst_pos3 = 1;
8883 break;
8884
8885 case 8200: hash_type = HASH_TYPE_SHA256;
8886 salt_type = SALT_TYPE_EMBEDDED;
8887 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8888 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8889 kern_type = KERN_TYPE_CLOUDKEY;
8890 dgst_size = DGST_SIZE_4_8;
8891 parse_func = cloudkey_parse_hash;
8892 sort_by_digest = sort_by_digest_4_8;
8893 opti_type = OPTI_TYPE_ZERO_BYTE;
8894 dgst_pos0 = 0;
8895 dgst_pos1 = 1;
8896 dgst_pos2 = 2;
8897 dgst_pos3 = 3;
8898 break;
8899
8900 case 8300: hash_type = HASH_TYPE_SHA1;
8901 salt_type = SALT_TYPE_EMBEDDED;
8902 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8903 opts_type = OPTS_TYPE_PT_GENERATE_LE
8904 | OPTS_TYPE_ST_HEX
8905 | OPTS_TYPE_ST_ADD80;
8906 kern_type = KERN_TYPE_NSEC3;
8907 dgst_size = DGST_SIZE_4_5;
8908 parse_func = nsec3_parse_hash;
8909 sort_by_digest = sort_by_digest_4_5;
8910 opti_type = OPTI_TYPE_ZERO_BYTE;
8911 dgst_pos0 = 3;
8912 dgst_pos1 = 4;
8913 dgst_pos2 = 2;
8914 dgst_pos3 = 1;
8915 break;
8916
8917 case 8400: hash_type = HASH_TYPE_SHA1;
8918 salt_type = SALT_TYPE_INTERN;
8919 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8920 opts_type = OPTS_TYPE_PT_GENERATE_BE
8921 | OPTS_TYPE_PT_ADD80
8922 | OPTS_TYPE_PT_ADDBITS15;
8923 kern_type = KERN_TYPE_WBB3;
8924 dgst_size = DGST_SIZE_4_5;
8925 parse_func = wbb3_parse_hash;
8926 sort_by_digest = sort_by_digest_4_5;
8927 opti_type = OPTI_TYPE_ZERO_BYTE
8928 | OPTI_TYPE_PRECOMPUTE_INIT
8929 | OPTI_TYPE_NOT_ITERATED;
8930 dgst_pos0 = 3;
8931 dgst_pos1 = 4;
8932 dgst_pos2 = 2;
8933 dgst_pos3 = 1;
8934 break;
8935
8936 case 8500: hash_type = HASH_TYPE_DESRACF;
8937 salt_type = SALT_TYPE_EMBEDDED;
8938 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8939 opts_type = OPTS_TYPE_PT_GENERATE_LE
8940 | OPTS_TYPE_ST_UPPER;
8941 kern_type = KERN_TYPE_RACF;
8942 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8943 parse_func = racf_parse_hash;
8944 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8945 opti_type = OPTI_TYPE_ZERO_BYTE
8946 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8947 dgst_pos0 = 0;
8948 dgst_pos1 = 1;
8949 dgst_pos2 = 2;
8950 dgst_pos3 = 3;
8951 break;
8952
8953 case 8600: hash_type = HASH_TYPE_LOTUS5;
8954 salt_type = SALT_TYPE_NONE;
8955 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8956 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8957 kern_type = KERN_TYPE_LOTUS5;
8958 dgst_size = DGST_SIZE_4_4;
8959 parse_func = lotus5_parse_hash;
8960 sort_by_digest = sort_by_digest_4_4;
8961 opti_type = OPTI_TYPE_EARLY_SKIP
8962 | OPTI_TYPE_NOT_ITERATED
8963 | OPTI_TYPE_NOT_SALTED
8964 | OPTI_TYPE_RAW_HASH;
8965 dgst_pos0 = 0;
8966 dgst_pos1 = 1;
8967 dgst_pos2 = 2;
8968 dgst_pos3 = 3;
8969 break;
8970
8971 case 8700: hash_type = HASH_TYPE_LOTUS6;
8972 salt_type = SALT_TYPE_EMBEDDED;
8973 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8974 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8975 kern_type = KERN_TYPE_LOTUS6;
8976 dgst_size = DGST_SIZE_4_4;
8977 parse_func = lotus6_parse_hash;
8978 sort_by_digest = sort_by_digest_4_4;
8979 opti_type = OPTI_TYPE_EARLY_SKIP
8980 | OPTI_TYPE_NOT_ITERATED
8981 | OPTI_TYPE_RAW_HASH;
8982 dgst_pos0 = 0;
8983 dgst_pos1 = 1;
8984 dgst_pos2 = 2;
8985 dgst_pos3 = 3;
8986 break;
8987
8988 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
8989 salt_type = SALT_TYPE_EMBEDDED;
8990 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8991 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8992 kern_type = KERN_TYPE_ANDROIDFDE;
8993 dgst_size = DGST_SIZE_4_4;
8994 parse_func = androidfde_parse_hash;
8995 sort_by_digest = sort_by_digest_4_4;
8996 opti_type = OPTI_TYPE_ZERO_BYTE;
8997 dgst_pos0 = 0;
8998 dgst_pos1 = 1;
8999 dgst_pos2 = 2;
9000 dgst_pos3 = 3;
9001 break;
9002
9003 case 8900: hash_type = HASH_TYPE_SCRYPT;
9004 salt_type = SALT_TYPE_EMBEDDED;
9005 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9006 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9007 kern_type = KERN_TYPE_SCRYPT;
9008 dgst_size = DGST_SIZE_4_8;
9009 parse_func = scrypt_parse_hash;
9010 sort_by_digest = sort_by_digest_4_8;
9011 opti_type = OPTI_TYPE_ZERO_BYTE;
9012 dgst_pos0 = 0;
9013 dgst_pos1 = 1;
9014 dgst_pos2 = 2;
9015 dgst_pos3 = 3;
9016 break;
9017
9018 case 9000: hash_type = HASH_TYPE_SHA1;
9019 salt_type = SALT_TYPE_EMBEDDED;
9020 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9021 opts_type = OPTS_TYPE_PT_GENERATE_LE
9022 | OPTS_TYPE_ST_GENERATE_LE;
9023 kern_type = KERN_TYPE_PSAFE2;
9024 dgst_size = DGST_SIZE_4_5;
9025 parse_func = psafe2_parse_hash;
9026 sort_by_digest = sort_by_digest_4_5;
9027 opti_type = OPTI_TYPE_ZERO_BYTE;
9028 dgst_pos0 = 0;
9029 dgst_pos1 = 1;
9030 dgst_pos2 = 2;
9031 dgst_pos3 = 3;
9032 break;
9033
9034 case 9100: hash_type = HASH_TYPE_LOTUS8;
9035 salt_type = SALT_TYPE_EMBEDDED;
9036 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9037 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9038 kern_type = KERN_TYPE_LOTUS8;
9039 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9040 parse_func = lotus8_parse_hash;
9041 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9042 opti_type = OPTI_TYPE_ZERO_BYTE;
9043 dgst_pos0 = 0;
9044 dgst_pos1 = 1;
9045 dgst_pos2 = 2;
9046 dgst_pos3 = 3;
9047 break;
9048
9049 case 9200: hash_type = HASH_TYPE_SHA256;
9050 salt_type = SALT_TYPE_EMBEDDED;
9051 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9052 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9053 kern_type = KERN_TYPE_PBKDF2_SHA256;
9054 dgst_size = DGST_SIZE_4_32;
9055 parse_func = cisco8_parse_hash;
9056 sort_by_digest = sort_by_digest_4_32;
9057 opti_type = OPTI_TYPE_ZERO_BYTE;
9058 dgst_pos0 = 0;
9059 dgst_pos1 = 1;
9060 dgst_pos2 = 2;
9061 dgst_pos3 = 3;
9062 break;
9063
9064 case 9300: hash_type = HASH_TYPE_SCRYPT;
9065 salt_type = SALT_TYPE_EMBEDDED;
9066 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9067 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9068 kern_type = KERN_TYPE_SCRYPT;
9069 dgst_size = DGST_SIZE_4_8;
9070 parse_func = cisco9_parse_hash;
9071 sort_by_digest = sort_by_digest_4_8;
9072 opti_type = OPTI_TYPE_ZERO_BYTE;
9073 dgst_pos0 = 0;
9074 dgst_pos1 = 1;
9075 dgst_pos2 = 2;
9076 dgst_pos3 = 3;
9077 break;
9078
9079 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9080 salt_type = SALT_TYPE_EMBEDDED;
9081 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9082 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9083 kern_type = KERN_TYPE_OFFICE2007;
9084 dgst_size = DGST_SIZE_4_4;
9085 parse_func = office2007_parse_hash;
9086 sort_by_digest = sort_by_digest_4_4;
9087 opti_type = OPTI_TYPE_ZERO_BYTE;
9088 dgst_pos0 = 0;
9089 dgst_pos1 = 1;
9090 dgst_pos2 = 2;
9091 dgst_pos3 = 3;
9092 break;
9093
9094 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9095 salt_type = SALT_TYPE_EMBEDDED;
9096 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9097 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9098 kern_type = KERN_TYPE_OFFICE2010;
9099 dgst_size = DGST_SIZE_4_4;
9100 parse_func = office2010_parse_hash;
9101 sort_by_digest = sort_by_digest_4_4;
9102 opti_type = OPTI_TYPE_ZERO_BYTE;
9103 dgst_pos0 = 0;
9104 dgst_pos1 = 1;
9105 dgst_pos2 = 2;
9106 dgst_pos3 = 3;
9107 break;
9108
9109 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9110 salt_type = SALT_TYPE_EMBEDDED;
9111 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9112 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9113 kern_type = KERN_TYPE_OFFICE2013;
9114 dgst_size = DGST_SIZE_4_4;
9115 parse_func = office2013_parse_hash;
9116 sort_by_digest = sort_by_digest_4_4;
9117 opti_type = OPTI_TYPE_ZERO_BYTE;
9118 dgst_pos0 = 0;
9119 dgst_pos1 = 1;
9120 dgst_pos2 = 2;
9121 dgst_pos3 = 3;
9122 break;
9123
9124 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9125 salt_type = SALT_TYPE_EMBEDDED;
9126 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9127 opts_type = OPTS_TYPE_PT_GENERATE_LE
9128 | OPTS_TYPE_PT_ADD80
9129 | OPTS_TYPE_PT_UNICODE;
9130 kern_type = KERN_TYPE_OLDOFFICE01;
9131 dgst_size = DGST_SIZE_4_4;
9132 parse_func = oldoffice01_parse_hash;
9133 sort_by_digest = sort_by_digest_4_4;
9134 opti_type = OPTI_TYPE_ZERO_BYTE
9135 | OPTI_TYPE_PRECOMPUTE_INIT
9136 | OPTI_TYPE_NOT_ITERATED;
9137 dgst_pos0 = 0;
9138 dgst_pos1 = 1;
9139 dgst_pos2 = 2;
9140 dgst_pos3 = 3;
9141 break;
9142
9143 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9144 salt_type = SALT_TYPE_EMBEDDED;
9145 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9146 opts_type = OPTS_TYPE_PT_GENERATE_LE
9147 | OPTS_TYPE_PT_ADD80;
9148 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9149 dgst_size = DGST_SIZE_4_4;
9150 parse_func = oldoffice01cm1_parse_hash;
9151 sort_by_digest = sort_by_digest_4_4;
9152 opti_type = OPTI_TYPE_ZERO_BYTE
9153 | OPTI_TYPE_PRECOMPUTE_INIT
9154 | OPTI_TYPE_NOT_ITERATED;
9155 dgst_pos0 = 0;
9156 dgst_pos1 = 1;
9157 dgst_pos2 = 2;
9158 dgst_pos3 = 3;
9159 break;
9160
9161 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9162 salt_type = SALT_TYPE_EMBEDDED;
9163 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9164 opts_type = OPTS_TYPE_PT_GENERATE_LE
9165 | OPTS_TYPE_PT_ADD80
9166 | OPTS_TYPE_PT_UNICODE
9167 | OPTS_TYPE_PT_NEVERCRACK;
9168 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9169 dgst_size = DGST_SIZE_4_4;
9170 parse_func = oldoffice01cm2_parse_hash;
9171 sort_by_digest = sort_by_digest_4_4;
9172 opti_type = OPTI_TYPE_ZERO_BYTE
9173 | OPTI_TYPE_PRECOMPUTE_INIT
9174 | OPTI_TYPE_NOT_ITERATED;
9175 dgst_pos0 = 0;
9176 dgst_pos1 = 1;
9177 dgst_pos2 = 2;
9178 dgst_pos3 = 3;
9179 break;
9180
9181 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9182 salt_type = SALT_TYPE_EMBEDDED;
9183 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9184 opts_type = OPTS_TYPE_PT_GENERATE_BE
9185 | OPTS_TYPE_PT_ADD80
9186 | OPTS_TYPE_PT_UNICODE;
9187 kern_type = KERN_TYPE_OLDOFFICE34;
9188 dgst_size = DGST_SIZE_4_4;
9189 parse_func = oldoffice34_parse_hash;
9190 sort_by_digest = sort_by_digest_4_4;
9191 opti_type = OPTI_TYPE_ZERO_BYTE
9192 | OPTI_TYPE_PRECOMPUTE_INIT
9193 | OPTI_TYPE_NOT_ITERATED;
9194 dgst_pos0 = 0;
9195 dgst_pos1 = 1;
9196 dgst_pos2 = 2;
9197 dgst_pos3 = 3;
9198 break;
9199
9200 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9201 salt_type = SALT_TYPE_EMBEDDED;
9202 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9203 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9204 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9205 dgst_size = DGST_SIZE_4_4;
9206 parse_func = oldoffice34cm1_parse_hash;
9207 sort_by_digest = sort_by_digest_4_4;
9208 opti_type = OPTI_TYPE_ZERO_BYTE
9209 | OPTI_TYPE_PRECOMPUTE_INIT
9210 | OPTI_TYPE_NOT_ITERATED;
9211 dgst_pos0 = 0;
9212 dgst_pos1 = 1;
9213 dgst_pos2 = 2;
9214 dgst_pos3 = 3;
9215 break;
9216
9217 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9218 salt_type = SALT_TYPE_EMBEDDED;
9219 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9220 opts_type = OPTS_TYPE_PT_GENERATE_BE
9221 | OPTS_TYPE_PT_ADD80
9222 | OPTS_TYPE_PT_UNICODE
9223 | OPTS_TYPE_PT_NEVERCRACK;
9224 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9225 dgst_size = DGST_SIZE_4_4;
9226 parse_func = oldoffice34cm2_parse_hash;
9227 sort_by_digest = sort_by_digest_4_4;
9228 opti_type = OPTI_TYPE_ZERO_BYTE
9229 | OPTI_TYPE_PRECOMPUTE_INIT
9230 | OPTI_TYPE_NOT_ITERATED;
9231 dgst_pos0 = 0;
9232 dgst_pos1 = 1;
9233 dgst_pos2 = 2;
9234 dgst_pos3 = 3;
9235 break;
9236
9237 case 9900: hash_type = HASH_TYPE_MD5;
9238 salt_type = SALT_TYPE_NONE;
9239 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9240 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9241 kern_type = KERN_TYPE_RADMIN2;
9242 dgst_size = DGST_SIZE_4_4;
9243 parse_func = radmin2_parse_hash;
9244 sort_by_digest = sort_by_digest_4_4;
9245 opti_type = OPTI_TYPE_ZERO_BYTE
9246 | OPTI_TYPE_PRECOMPUTE_INIT
9247 | OPTI_TYPE_EARLY_SKIP
9248 | OPTI_TYPE_NOT_ITERATED
9249 | OPTI_TYPE_NOT_SALTED;
9250 dgst_pos0 = 0;
9251 dgst_pos1 = 3;
9252 dgst_pos2 = 2;
9253 dgst_pos3 = 1;
9254 break;
9255
9256 case 10000: hash_type = HASH_TYPE_SHA256;
9257 salt_type = SALT_TYPE_EMBEDDED;
9258 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9259 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9260 kern_type = KERN_TYPE_PBKDF2_SHA256;
9261 dgst_size = DGST_SIZE_4_32;
9262 parse_func = djangopbkdf2_parse_hash;
9263 sort_by_digest = sort_by_digest_4_32;
9264 opti_type = OPTI_TYPE_ZERO_BYTE;
9265 dgst_pos0 = 0;
9266 dgst_pos1 = 1;
9267 dgst_pos2 = 2;
9268 dgst_pos3 = 3;
9269 break;
9270
9271 case 10100: hash_type = HASH_TYPE_SIPHASH;
9272 salt_type = SALT_TYPE_EMBEDDED;
9273 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9274 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9275 kern_type = KERN_TYPE_SIPHASH;
9276 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9277 parse_func = siphash_parse_hash;
9278 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9279 opti_type = OPTI_TYPE_ZERO_BYTE
9280 | OPTI_TYPE_NOT_ITERATED
9281 | OPTI_TYPE_RAW_HASH;
9282 dgst_pos0 = 0;
9283 dgst_pos1 = 1;
9284 dgst_pos2 = 2;
9285 dgst_pos3 = 3;
9286 break;
9287
9288 case 10200: hash_type = HASH_TYPE_MD5;
9289 salt_type = SALT_TYPE_EMBEDDED;
9290 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9291 opts_type = OPTS_TYPE_PT_GENERATE_LE
9292 | OPTS_TYPE_ST_ADD80
9293 | OPTS_TYPE_ST_ADDBITS14;
9294 kern_type = KERN_TYPE_HMACMD5_PW;
9295 dgst_size = DGST_SIZE_4_4;
9296 parse_func = crammd5_parse_hash;
9297 sort_by_digest = sort_by_digest_4_4;
9298 opti_type = OPTI_TYPE_ZERO_BYTE
9299 | OPTI_TYPE_NOT_ITERATED;
9300 dgst_pos0 = 0;
9301 dgst_pos1 = 3;
9302 dgst_pos2 = 2;
9303 dgst_pos3 = 1;
9304 break;
9305
9306 case 10300: hash_type = HASH_TYPE_SHA1;
9307 salt_type = SALT_TYPE_EMBEDDED;
9308 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9309 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9310 kern_type = KERN_TYPE_SAPH_SHA1;
9311 dgst_size = DGST_SIZE_4_5;
9312 parse_func = saph_sha1_parse_hash;
9313 sort_by_digest = sort_by_digest_4_5;
9314 opti_type = OPTI_TYPE_ZERO_BYTE;
9315 dgst_pos0 = 0;
9316 dgst_pos1 = 1;
9317 dgst_pos2 = 2;
9318 dgst_pos3 = 3;
9319 break;
9320
9321 case 10400: hash_type = HASH_TYPE_PDFU16;
9322 salt_type = SALT_TYPE_EMBEDDED;
9323 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9324 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9325 kern_type = KERN_TYPE_PDF11;
9326 dgst_size = DGST_SIZE_4_4;
9327 parse_func = pdf11_parse_hash;
9328 sort_by_digest = sort_by_digest_4_4;
9329 opti_type = OPTI_TYPE_ZERO_BYTE
9330 | OPTI_TYPE_NOT_ITERATED;
9331 dgst_pos0 = 0;
9332 dgst_pos1 = 1;
9333 dgst_pos2 = 2;
9334 dgst_pos3 = 3;
9335 break;
9336
9337 case 10410: hash_type = HASH_TYPE_PDFU16;
9338 salt_type = SALT_TYPE_EMBEDDED;
9339 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9340 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9341 kern_type = KERN_TYPE_PDF11CM1;
9342 dgst_size = DGST_SIZE_4_4;
9343 parse_func = pdf11cm1_parse_hash;
9344 sort_by_digest = sort_by_digest_4_4;
9345 opti_type = OPTI_TYPE_ZERO_BYTE
9346 | OPTI_TYPE_NOT_ITERATED;
9347 dgst_pos0 = 0;
9348 dgst_pos1 = 1;
9349 dgst_pos2 = 2;
9350 dgst_pos3 = 3;
9351 break;
9352
9353 case 10420: hash_type = HASH_TYPE_PDFU16;
9354 salt_type = SALT_TYPE_EMBEDDED;
9355 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9356 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9357 kern_type = KERN_TYPE_PDF11CM2;
9358 dgst_size = DGST_SIZE_4_4;
9359 parse_func = pdf11cm2_parse_hash;
9360 sort_by_digest = sort_by_digest_4_4;
9361 opti_type = OPTI_TYPE_ZERO_BYTE
9362 | OPTI_TYPE_NOT_ITERATED;
9363 dgst_pos0 = 0;
9364 dgst_pos1 = 1;
9365 dgst_pos2 = 2;
9366 dgst_pos3 = 3;
9367 break;
9368
9369 case 10500: hash_type = HASH_TYPE_PDFU16;
9370 salt_type = SALT_TYPE_EMBEDDED;
9371 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9372 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9373 kern_type = KERN_TYPE_PDF14;
9374 dgst_size = DGST_SIZE_4_4;
9375 parse_func = pdf14_parse_hash;
9376 sort_by_digest = sort_by_digest_4_4;
9377 opti_type = OPTI_TYPE_ZERO_BYTE
9378 | OPTI_TYPE_NOT_ITERATED;
9379 dgst_pos0 = 0;
9380 dgst_pos1 = 1;
9381 dgst_pos2 = 2;
9382 dgst_pos3 = 3;
9383 break;
9384
9385 case 10600: hash_type = HASH_TYPE_SHA256;
9386 salt_type = SALT_TYPE_EMBEDDED;
9387 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9388 opts_type = OPTS_TYPE_PT_GENERATE_BE
9389 | OPTS_TYPE_ST_ADD80
9390 | OPTS_TYPE_ST_ADDBITS15
9391 | OPTS_TYPE_HASH_COPY;
9392 kern_type = KERN_TYPE_SHA256_PWSLT;
9393 dgst_size = DGST_SIZE_4_8;
9394 parse_func = pdf17l3_parse_hash;
9395 sort_by_digest = sort_by_digest_4_8;
9396 opti_type = OPTI_TYPE_ZERO_BYTE
9397 | OPTI_TYPE_PRECOMPUTE_INIT
9398 | OPTI_TYPE_PRECOMPUTE_MERKLE
9399 | OPTI_TYPE_EARLY_SKIP
9400 | OPTI_TYPE_NOT_ITERATED
9401 | OPTI_TYPE_APPENDED_SALT
9402 | OPTI_TYPE_RAW_HASH;
9403 dgst_pos0 = 3;
9404 dgst_pos1 = 7;
9405 dgst_pos2 = 2;
9406 dgst_pos3 = 6;
9407 break;
9408
9409 case 10700: hash_type = HASH_TYPE_PDFU32;
9410 salt_type = SALT_TYPE_EMBEDDED;
9411 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9412 opts_type = OPTS_TYPE_PT_GENERATE_LE
9413 | OPTS_TYPE_HASH_COPY;
9414 kern_type = KERN_TYPE_PDF17L8;
9415 dgst_size = DGST_SIZE_4_8;
9416 parse_func = pdf17l8_parse_hash;
9417 sort_by_digest = sort_by_digest_4_8;
9418 opti_type = OPTI_TYPE_ZERO_BYTE
9419 | OPTI_TYPE_NOT_ITERATED;
9420 dgst_pos0 = 0;
9421 dgst_pos1 = 1;
9422 dgst_pos2 = 2;
9423 dgst_pos3 = 3;
9424 break;
9425
9426 case 10800: hash_type = HASH_TYPE_SHA384;
9427 salt_type = SALT_TYPE_NONE;
9428 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9429 opts_type = OPTS_TYPE_PT_GENERATE_BE
9430 | OPTS_TYPE_PT_ADD80
9431 | OPTS_TYPE_PT_ADDBITS15;
9432 kern_type = KERN_TYPE_SHA384;
9433 dgst_size = DGST_SIZE_8_8;
9434 parse_func = sha384_parse_hash;
9435 sort_by_digest = sort_by_digest_8_8;
9436 opti_type = OPTI_TYPE_ZERO_BYTE
9437 | OPTI_TYPE_PRECOMPUTE_INIT
9438 | OPTI_TYPE_PRECOMPUTE_MERKLE
9439 | OPTI_TYPE_EARLY_SKIP
9440 | OPTI_TYPE_NOT_ITERATED
9441 | OPTI_TYPE_NOT_SALTED
9442 | OPTI_TYPE_RAW_HASH;
9443 dgst_pos0 = 6;
9444 dgst_pos1 = 7;
9445 dgst_pos2 = 4;
9446 dgst_pos3 = 5;
9447 break;
9448
9449 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9450 salt_type = SALT_TYPE_EMBEDDED;
9451 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9452 opts_type = OPTS_TYPE_PT_GENERATE_LE
9453 | OPTS_TYPE_ST_BASE64
9454 | OPTS_TYPE_HASH_COPY;
9455 kern_type = KERN_TYPE_PBKDF2_SHA256;
9456 dgst_size = DGST_SIZE_4_32;
9457 parse_func = pbkdf2_sha256_parse_hash;
9458 sort_by_digest = sort_by_digest_4_32;
9459 opti_type = OPTI_TYPE_ZERO_BYTE;
9460 dgst_pos0 = 0;
9461 dgst_pos1 = 1;
9462 dgst_pos2 = 2;
9463 dgst_pos3 = 3;
9464 break;
9465
9466 case 11000: hash_type = HASH_TYPE_MD5;
9467 salt_type = SALT_TYPE_INTERN;
9468 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9469 opts_type = OPTS_TYPE_PT_GENERATE_LE
9470 | OPTS_TYPE_PT_ADD80;
9471 kern_type = KERN_TYPE_PRESTASHOP;
9472 dgst_size = DGST_SIZE_4_4;
9473 parse_func = prestashop_parse_hash;
9474 sort_by_digest = sort_by_digest_4_4;
9475 opti_type = OPTI_TYPE_ZERO_BYTE
9476 | OPTI_TYPE_PRECOMPUTE_INIT
9477 | OPTI_TYPE_NOT_ITERATED
9478 | OPTI_TYPE_PREPENDED_SALT;
9479 dgst_pos0 = 0;
9480 dgst_pos1 = 3;
9481 dgst_pos2 = 2;
9482 dgst_pos3 = 1;
9483 break;
9484
9485 case 11100: hash_type = HASH_TYPE_MD5;
9486 salt_type = SALT_TYPE_EMBEDDED;
9487 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9488 opts_type = OPTS_TYPE_PT_GENERATE_LE
9489 | OPTS_TYPE_ST_ADD80;
9490 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9491 dgst_size = DGST_SIZE_4_4;
9492 parse_func = postgresql_auth_parse_hash;
9493 sort_by_digest = sort_by_digest_4_4;
9494 opti_type = OPTI_TYPE_ZERO_BYTE
9495 | OPTI_TYPE_PRECOMPUTE_INIT
9496 | OPTI_TYPE_PRECOMPUTE_MERKLE
9497 | OPTI_TYPE_EARLY_SKIP;
9498 dgst_pos0 = 0;
9499 dgst_pos1 = 3;
9500 dgst_pos2 = 2;
9501 dgst_pos3 = 1;
9502 break;
9503
9504 case 11200: hash_type = HASH_TYPE_SHA1;
9505 salt_type = SALT_TYPE_EMBEDDED;
9506 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9507 opts_type = OPTS_TYPE_PT_GENERATE_BE
9508 | OPTS_TYPE_PT_ADD80
9509 | OPTS_TYPE_ST_HEX;
9510 kern_type = KERN_TYPE_MYSQL_AUTH;
9511 dgst_size = DGST_SIZE_4_5;
9512 parse_func = mysql_auth_parse_hash;
9513 sort_by_digest = sort_by_digest_4_5;
9514 opti_type = OPTI_TYPE_ZERO_BYTE
9515 | OPTI_TYPE_EARLY_SKIP;
9516 dgst_pos0 = 3;
9517 dgst_pos1 = 4;
9518 dgst_pos2 = 2;
9519 dgst_pos3 = 1;
9520 break;
9521
9522 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9523 salt_type = SALT_TYPE_EMBEDDED;
9524 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9525 opts_type = OPTS_TYPE_PT_GENERATE_LE
9526 | OPTS_TYPE_ST_HEX
9527 | OPTS_TYPE_ST_ADD80;
9528 kern_type = KERN_TYPE_BITCOIN_WALLET;
9529 dgst_size = DGST_SIZE_4_4;
9530 parse_func = bitcoin_wallet_parse_hash;
9531 sort_by_digest = sort_by_digest_4_4;
9532 opti_type = OPTI_TYPE_ZERO_BYTE;
9533 dgst_pos0 = 0;
9534 dgst_pos1 = 1;
9535 dgst_pos2 = 2;
9536 dgst_pos3 = 3;
9537 break;
9538
9539 case 11400: hash_type = HASH_TYPE_MD5;
9540 salt_type = SALT_TYPE_EMBEDDED;
9541 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9542 opts_type = OPTS_TYPE_PT_GENERATE_LE
9543 | OPTS_TYPE_PT_ADD80
9544 | OPTS_TYPE_HASH_COPY;
9545 kern_type = KERN_TYPE_SIP_AUTH;
9546 dgst_size = DGST_SIZE_4_4;
9547 parse_func = sip_auth_parse_hash;
9548 sort_by_digest = sort_by_digest_4_4;
9549 opti_type = OPTI_TYPE_ZERO_BYTE;
9550 dgst_pos0 = 0;
9551 dgst_pos1 = 3;
9552 dgst_pos2 = 2;
9553 dgst_pos3 = 1;
9554 break;
9555
9556 case 11500: hash_type = HASH_TYPE_CRC32;
9557 salt_type = SALT_TYPE_INTERN;
9558 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9559 opts_type = OPTS_TYPE_PT_GENERATE_LE
9560 | OPTS_TYPE_ST_GENERATE_LE
9561 | OPTS_TYPE_ST_HEX;
9562 kern_type = KERN_TYPE_CRC32;
9563 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9564 parse_func = crc32_parse_hash;
9565 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9566 opti_type = OPTI_TYPE_ZERO_BYTE;
9567 dgst_pos0 = 0;
9568 dgst_pos1 = 1;
9569 dgst_pos2 = 2;
9570 dgst_pos3 = 3;
9571 break;
9572
9573 case 11600: hash_type = HASH_TYPE_AES;
9574 salt_type = SALT_TYPE_EMBEDDED;
9575 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9576 opts_type = OPTS_TYPE_PT_GENERATE_LE
9577 | OPTS_TYPE_PT_NEVERCRACK;
9578 kern_type = KERN_TYPE_SEVEN_ZIP;
9579 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9580 parse_func = seven_zip_parse_hash;
9581 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9582 opti_type = OPTI_TYPE_ZERO_BYTE;
9583 dgst_pos0 = 0;
9584 dgst_pos1 = 1;
9585 dgst_pos2 = 2;
9586 dgst_pos3 = 3;
9587 break;
9588
9589 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9590 salt_type = SALT_TYPE_NONE;
9591 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9592 opts_type = OPTS_TYPE_PT_GENERATE_LE
9593 | OPTS_TYPE_PT_ADD01;
9594 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9595 dgst_size = DGST_SIZE_4_8;
9596 parse_func = gost2012sbog_256_parse_hash;
9597 sort_by_digest = sort_by_digest_4_8;
9598 opti_type = OPTI_TYPE_ZERO_BYTE;
9599 dgst_pos0 = 0;
9600 dgst_pos1 = 1;
9601 dgst_pos2 = 2;
9602 dgst_pos3 = 3;
9603 break;
9604
9605 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9606 salt_type = SALT_TYPE_NONE;
9607 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9608 opts_type = OPTS_TYPE_PT_GENERATE_LE
9609 | OPTS_TYPE_PT_ADD01;
9610 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9611 dgst_size = DGST_SIZE_4_16;
9612 parse_func = gost2012sbog_512_parse_hash;
9613 sort_by_digest = sort_by_digest_4_16;
9614 opti_type = OPTI_TYPE_ZERO_BYTE;
9615 dgst_pos0 = 0;
9616 dgst_pos1 = 1;
9617 dgst_pos2 = 2;
9618 dgst_pos3 = 3;
9619 break;
9620
9621 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9622 salt_type = SALT_TYPE_EMBEDDED;
9623 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9624 opts_type = OPTS_TYPE_PT_GENERATE_LE
9625 | OPTS_TYPE_ST_BASE64
9626 | OPTS_TYPE_HASH_COPY;
9627 kern_type = KERN_TYPE_PBKDF2_MD5;
9628 dgst_size = DGST_SIZE_4_32;
9629 parse_func = pbkdf2_md5_parse_hash;
9630 sort_by_digest = sort_by_digest_4_32;
9631 opti_type = OPTI_TYPE_ZERO_BYTE;
9632 dgst_pos0 = 0;
9633 dgst_pos1 = 1;
9634 dgst_pos2 = 2;
9635 dgst_pos3 = 3;
9636 break;
9637
9638 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
9639 salt_type = SALT_TYPE_EMBEDDED;
9640 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9641 opts_type = OPTS_TYPE_PT_GENERATE_LE
9642 | OPTS_TYPE_ST_BASE64
9643 | OPTS_TYPE_HASH_COPY;
9644 kern_type = KERN_TYPE_PBKDF2_SHA1;
9645 dgst_size = DGST_SIZE_4_32;
9646 parse_func = pbkdf2_sha1_parse_hash;
9647 sort_by_digest = sort_by_digest_4_32;
9648 opti_type = OPTI_TYPE_ZERO_BYTE;
9649 dgst_pos0 = 0;
9650 dgst_pos1 = 1;
9651 dgst_pos2 = 2;
9652 dgst_pos3 = 3;
9653 break;
9654
9655 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
9656 salt_type = SALT_TYPE_EMBEDDED;
9657 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9658 opts_type = OPTS_TYPE_PT_GENERATE_LE
9659 | OPTS_TYPE_ST_BASE64
9660 | OPTS_TYPE_HASH_COPY;
9661 kern_type = KERN_TYPE_PBKDF2_SHA512;
9662 dgst_size = DGST_SIZE_8_16;
9663 parse_func = pbkdf2_sha512_parse_hash;
9664 sort_by_digest = sort_by_digest_8_16;
9665 opti_type = OPTI_TYPE_ZERO_BYTE;
9666 dgst_pos0 = 0;
9667 dgst_pos1 = 1;
9668 dgst_pos2 = 2;
9669 dgst_pos3 = 3;
9670 break;
9671
9672 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
9673 salt_type = SALT_TYPE_EMBEDDED;
9674 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9675 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9676 kern_type = KERN_TYPE_ECRYPTFS;
9677 dgst_size = DGST_SIZE_8_8;
9678 parse_func = ecryptfs_parse_hash;
9679 sort_by_digest = sort_by_digest_8_8;
9680 opti_type = OPTI_TYPE_ZERO_BYTE;
9681 dgst_pos0 = 0;
9682 dgst_pos1 = 1;
9683 dgst_pos2 = 2;
9684 dgst_pos3 = 3;
9685 break;
9686
9687 case 12300: hash_type = HASH_TYPE_ORACLET;
9688 salt_type = SALT_TYPE_EMBEDDED;
9689 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9690 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9691 kern_type = KERN_TYPE_ORACLET;
9692 dgst_size = DGST_SIZE_8_16;
9693 parse_func = oraclet_parse_hash;
9694 sort_by_digest = sort_by_digest_8_16;
9695 opti_type = OPTI_TYPE_ZERO_BYTE;
9696 dgst_pos0 = 0;
9697 dgst_pos1 = 1;
9698 dgst_pos2 = 2;
9699 dgst_pos3 = 3;
9700 break;
9701
9702 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
9703 salt_type = SALT_TYPE_EMBEDDED;
9704 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9705 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9706 kern_type = KERN_TYPE_BSDICRYPT;
9707 dgst_size = DGST_SIZE_4_4;
9708 parse_func = bsdicrypt_parse_hash;
9709 sort_by_digest = sort_by_digest_4_4;
9710 opti_type = OPTI_TYPE_ZERO_BYTE
9711 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9712 dgst_pos0 = 0;
9713 dgst_pos1 = 1;
9714 dgst_pos2 = 2;
9715 dgst_pos3 = 3;
9716 break;
9717
9718 case 12500: hash_type = HASH_TYPE_RAR3HP;
9719 salt_type = SALT_TYPE_EMBEDDED;
9720 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9721 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9722 kern_type = KERN_TYPE_RAR3;
9723 dgst_size = DGST_SIZE_4_4;
9724 parse_func = rar3hp_parse_hash;
9725 sort_by_digest = sort_by_digest_4_4;
9726 opti_type = OPTI_TYPE_ZERO_BYTE;
9727 dgst_pos0 = 0;
9728 dgst_pos1 = 1;
9729 dgst_pos2 = 2;
9730 dgst_pos3 = 3;
9731 break;
9732
9733 case 12600: hash_type = HASH_TYPE_SHA256;
9734 salt_type = SALT_TYPE_INTERN;
9735 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9736 opts_type = OPTS_TYPE_PT_GENERATE_BE
9737 | OPTS_TYPE_PT_ADD80;
9738 kern_type = KERN_TYPE_CF10;
9739 dgst_size = DGST_SIZE_4_8;
9740 parse_func = cf10_parse_hash;
9741 sort_by_digest = sort_by_digest_4_8;
9742 opti_type = OPTI_TYPE_ZERO_BYTE
9743 | OPTI_TYPE_PRECOMPUTE_INIT
9744 | OPTI_TYPE_EARLY_SKIP
9745 | OPTI_TYPE_NOT_ITERATED;
9746 dgst_pos0 = 3;
9747 dgst_pos1 = 7;
9748 dgst_pos2 = 2;
9749 dgst_pos3 = 6;
9750 break;
9751
9752 case 12700: hash_type = HASH_TYPE_AES;
9753 salt_type = SALT_TYPE_EMBEDDED;
9754 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9755 opts_type = OPTS_TYPE_PT_GENERATE_LE
9756 | OPTS_TYPE_HASH_COPY;
9757 kern_type = KERN_TYPE_MYWALLET;
9758 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9759 parse_func = mywallet_parse_hash;
9760 sort_by_digest = sort_by_digest_4_5;
9761 opti_type = OPTI_TYPE_ZERO_BYTE;
9762 dgst_pos0 = 0;
9763 dgst_pos1 = 1;
9764 dgst_pos2 = 2;
9765 dgst_pos3 = 3;
9766 break;
9767
9768 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
9769 salt_type = SALT_TYPE_EMBEDDED;
9770 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9771 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9772 kern_type = KERN_TYPE_MS_DRSR;
9773 dgst_size = DGST_SIZE_4_8;
9774 parse_func = ms_drsr_parse_hash;
9775 sort_by_digest = sort_by_digest_4_8;
9776 opti_type = OPTI_TYPE_ZERO_BYTE;
9777 dgst_pos0 = 0;
9778 dgst_pos1 = 1;
9779 dgst_pos2 = 2;
9780 dgst_pos3 = 3;
9781 break;
9782
9783 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9784 salt_type = SALT_TYPE_EMBEDDED;
9785 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9786 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9787 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
9788 dgst_size = DGST_SIZE_4_8;
9789 parse_func = androidfde_samsung_parse_hash;
9790 sort_by_digest = sort_by_digest_4_8;
9791 opti_type = OPTI_TYPE_ZERO_BYTE;
9792 dgst_pos0 = 0;
9793 dgst_pos1 = 1;
9794 dgst_pos2 = 2;
9795 dgst_pos3 = 3;
9796 break;
9797
9798 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
9799 salt_type = SALT_TYPE_EMBEDDED;
9800 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9801 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9802 kern_type = KERN_TYPE_RAR5;
9803 dgst_size = DGST_SIZE_4_4;
9804 parse_func = rar5_parse_hash;
9805 sort_by_digest = sort_by_digest_4_4;
9806 opti_type = OPTI_TYPE_ZERO_BYTE;
9807 dgst_pos0 = 0;
9808 dgst_pos1 = 1;
9809 dgst_pos2 = 2;
9810 dgst_pos3 = 3;
9811 break;
9812
9813 default: usage_mini_print (PROGNAME); return (-1);
9814 }
9815
9816 /**
9817 * transpose
9818 */
9819
9820 data.parse_func = parse_func;
9821
9822 /**
9823 * misc stuff
9824 */
9825
9826 if (hex_salt)
9827 {
9828 if (salt_type == SALT_TYPE_INTERN)
9829 {
9830 opts_type |= OPTS_TYPE_ST_HEX;
9831 }
9832 else
9833 {
9834 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
9835
9836 return (-1);
9837 }
9838 }
9839
9840 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
9841 | (salt_type == SALT_TYPE_EXTERN)
9842 | (salt_type == SALT_TYPE_EMBEDDED)
9843 | (salt_type == SALT_TYPE_VIRTUAL));
9844
9845 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
9846
9847 data.hash_type = hash_type;
9848 data.attack_mode = attack_mode;
9849 data.attack_kern = attack_kern;
9850 data.attack_exec = attack_exec;
9851 data.kern_type = kern_type;
9852 data.opts_type = opts_type;
9853 data.dgst_size = dgst_size;
9854 data.salt_type = salt_type;
9855 data.isSalted = isSalted;
9856 data.sort_by_digest = sort_by_digest;
9857 data.dgst_pos0 = dgst_pos0;
9858 data.dgst_pos1 = dgst_pos1;
9859 data.dgst_pos2 = dgst_pos2;
9860 data.dgst_pos3 = dgst_pos3;
9861
9862 esalt_size = 0;
9863
9864 switch (hash_mode)
9865 {
9866 case 2500: esalt_size = sizeof (wpa_t); break;
9867 case 5300: esalt_size = sizeof (ikepsk_t); break;
9868 case 5400: esalt_size = sizeof (ikepsk_t); break;
9869 case 5500: esalt_size = sizeof (netntlm_t); break;
9870 case 5600: esalt_size = sizeof (netntlm_t); break;
9871 case 6211:
9872 case 6212:
9873 case 6213:
9874 case 6221:
9875 case 6222:
9876 case 6223:
9877 case 6231:
9878 case 6232:
9879 case 6233:
9880 case 6241:
9881 case 6242:
9882 case 6243: esalt_size = sizeof (tc_t); break;
9883 case 6600: esalt_size = sizeof (agilekey_t); break;
9884 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
9885 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
9886 case 7300: esalt_size = sizeof (rakp_t); break;
9887 case 7500: esalt_size = sizeof (krb5pa_t); break;
9888 case 8200: esalt_size = sizeof (cloudkey_t); break;
9889 case 8800: esalt_size = sizeof (androidfde_t); break;
9890 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
9891 case 9400: esalt_size = sizeof (office2007_t); break;
9892 case 9500: esalt_size = sizeof (office2010_t); break;
9893 case 9600: esalt_size = sizeof (office2013_t); break;
9894 case 9700: esalt_size = sizeof (oldoffice01_t); break;
9895 case 9710: esalt_size = sizeof (oldoffice01_t); break;
9896 case 9720: esalt_size = sizeof (oldoffice01_t); break;
9897 case 9800: esalt_size = sizeof (oldoffice34_t); break;
9898 case 9810: esalt_size = sizeof (oldoffice34_t); break;
9899 case 9820: esalt_size = sizeof (oldoffice34_t); break;
9900 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
9901 case 10200: esalt_size = sizeof (cram_md5_t); break;
9902 case 10400: esalt_size = sizeof (pdf_t); break;
9903 case 10410: esalt_size = sizeof (pdf_t); break;
9904 case 10420: esalt_size = sizeof (pdf_t); break;
9905 case 10500: esalt_size = sizeof (pdf_t); break;
9906 case 10600: esalt_size = sizeof (pdf_t); break;
9907 case 10700: esalt_size = sizeof (pdf_t); break;
9908 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
9909 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
9910 case 11400: esalt_size = sizeof (sip_t); break;
9911 case 11600: esalt_size = sizeof (seven_zip_t); break;
9912 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
9913 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
9914 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
9915 case 13000: esalt_size = sizeof (rar5_t); break;
9916 }
9917
9918 data.esalt_size = esalt_size;
9919
9920 /**
9921 * choose dictionary parser
9922 */
9923
9924 if (hash_type == HASH_TYPE_LM)
9925 {
9926 get_next_word_func = get_next_word_lm;
9927 }
9928 else if (opts_type & OPTS_TYPE_PT_UPPER)
9929 {
9930 get_next_word_func = get_next_word_uc;
9931 }
9932 else
9933 {
9934 get_next_word_func = get_next_word_std;
9935 }
9936
9937 /**
9938 * dictstat
9939 */
9940
9941 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
9942
9943 #ifdef _POSIX
9944 size_t dictstat_nmemb = 0;
9945 #endif
9946
9947 #ifdef _WIN
9948 uint dictstat_nmemb = 0;
9949 #endif
9950
9951 char dictstat[256];
9952
9953 FILE *dictstat_fp = NULL;
9954
9955 if (keyspace == 0)
9956 {
9957 memset (dictstat, 0, sizeof (dictstat));
9958
9959 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
9960
9961 dictstat_fp = fopen (dictstat, "rb");
9962
9963 if (dictstat_fp)
9964 {
9965 #ifdef _POSIX
9966 struct stat tmpstat;
9967
9968 fstat (fileno (dictstat_fp), &tmpstat);
9969 #endif
9970
9971 #ifdef _WIN
9972 struct stat64 tmpstat;
9973
9974 _fstat64 (fileno (dictstat_fp), &tmpstat);
9975 #endif
9976
9977 if (tmpstat.st_mtime < COMPTIME)
9978 {
9979 /* with v0.15 the format changed so we have to ensure user is using a good version
9980 since there is no version-header in the dictstat file */
9981
9982 fclose (dictstat_fp);
9983
9984 unlink (dictstat);
9985 }
9986 else
9987 {
9988 while (!feof (dictstat_fp))
9989 {
9990 dictstat_t d;
9991
9992 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
9993
9994 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
9995
9996 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
9997 {
9998 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
9999
10000 return -1;
10001 }
10002 }
10003
10004 fclose (dictstat_fp);
10005 }
10006 }
10007 }
10008
10009 /**
10010 * potfile
10011 */
10012
10013 char potfile[256];
10014
10015 memset (potfile, 0, sizeof (potfile));
10016
10017 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
10018
10019 data.pot_fp = NULL;
10020
10021 FILE *out_fp = NULL;
10022 FILE *pot_fp = NULL;
10023
10024 if (show == 1 || left == 1)
10025 {
10026 pot_fp = fopen (potfile, "rb");
10027
10028 if (pot_fp == NULL)
10029 {
10030 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10031
10032 return (-1);
10033 }
10034
10035 if (outfile != NULL)
10036 {
10037 if ((out_fp = fopen (outfile, "ab")) == NULL)
10038 {
10039 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10040
10041 fclose (pot_fp);
10042
10043 return (-1);
10044 }
10045 }
10046 else
10047 {
10048 out_fp = stdout;
10049 }
10050 }
10051 else
10052 {
10053 if (potfile_disable == 0)
10054 {
10055 pot_fp = fopen (potfile, "ab");
10056
10057 if (pot_fp == NULL)
10058 {
10059 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10060
10061 return (-1);
10062 }
10063
10064 data.pot_fp = pot_fp;
10065 }
10066 }
10067
10068 pot_t *pot = NULL;
10069
10070 uint pot_cnt = 0;
10071 uint pot_avail = 0;
10072
10073 if (show == 1 || left == 1)
10074 {
10075 SUPPRESS_OUTPUT = 1;
10076
10077 pot_avail = count_lines (pot_fp);
10078
10079 rewind (pot_fp);
10080
10081 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10082
10083 uint pot_hashes_avail = 0;
10084
10085 uint line_num = 0;
10086
10087 while (!feof (pot_fp))
10088 {
10089 line_num++;
10090
10091 char line_buf[BUFSIZ];
10092
10093 int line_len = fgetl (pot_fp, line_buf);
10094
10095 if (line_len == 0) continue;
10096
10097 char *plain_buf = line_buf + line_len;
10098
10099 pot_t *pot_ptr = &pot[pot_cnt];
10100
10101 hash_t *hashes_buf = &pot_ptr->hash;
10102
10103 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10104 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10105
10106 if (pot_cnt == pot_hashes_avail)
10107 {
10108 uint pos = 0;
10109
10110 for (pos = 0; pos < INCR_POT; pos++)
10111 {
10112 if ((pot_cnt + pos) >= pot_avail) break;
10113
10114 pot_t *tmp_pot = &pot[pot_cnt + pos];
10115
10116 hash_t *tmp_hash = &tmp_pot->hash;
10117
10118 tmp_hash->digest = mymalloc (dgst_size);
10119
10120 if (isSalted)
10121 {
10122 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10123 }
10124
10125 if (esalt_size)
10126 {
10127 tmp_hash->esalt = mymalloc (esalt_size);
10128 }
10129
10130 pot_hashes_avail++;
10131 }
10132 }
10133
10134 int plain_len = 0;
10135
10136 int parser_status;
10137
10138 int iter = MAX_CUT_TRIES;
10139
10140 do
10141 {
10142 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10143 {
10144 if (line_buf[i] == ':')
10145 {
10146 line_len--;
10147
10148 break;
10149 }
10150 }
10151
10152 if (data.hash_mode != 2500)
10153 {
10154 parser_status = parse_func (line_buf, line_len, hashes_buf);
10155 }
10156 else
10157 {
10158 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10159
10160 if (line_len > max_salt_size)
10161 {
10162 parser_status = PARSER_GLOBAL_LENGTH;
10163 }
10164 else
10165 {
10166 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10167
10168 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10169
10170 hashes_buf->salt->salt_len = line_len;
10171
10172 parser_status = PARSER_OK;
10173 }
10174 }
10175
10176 // if NOT parsed without error, we add the ":" to the plain
10177
10178 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10179 {
10180 plain_len++;
10181 plain_buf--;
10182 }
10183
10184 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10185
10186 if (parser_status < PARSER_GLOBAL_ZERO)
10187 {
10188 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10189
10190 continue;
10191 }
10192
10193 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10194
10195 pot_ptr->plain_len = plain_len;
10196
10197 pot_cnt++;
10198 }
10199
10200 fclose (pot_fp);
10201
10202 SUPPRESS_OUTPUT = 0;
10203
10204 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10205 }
10206
10207 /**
10208 * kernel accel and loops auto adjustment
10209 */
10210
10211 if (kernel_accel_chgd == 0) kernel_accel = set_kernel_accel (hash_mode);
10212 if (kernel_loops_chgd == 0) kernel_loops = set_kernel_loops (hash_mode);
10213
10214 if (workload_profile == 1)
10215 {
10216 kernel_loops /= 8;
10217 kernel_accel /= 4;
10218
10219 if (kernel_loops == 0) kernel_loops = 8;
10220 if (kernel_accel == 0) kernel_accel = 2;
10221 }
10222 else if (workload_profile == 3)
10223 {
10224 kernel_loops *= 8;
10225 kernel_accel *= 4;
10226
10227 if (kernel_loops > 1024) kernel_loops = 1024;
10228 if (kernel_accel > 256) kernel_accel = 256; // causes memory problems otherwise
10229 }
10230
10231 // those hashes *must* run at a specific kernel_loops count because of some optimization inside the kernel
10232
10233 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
10234 {
10235 kernel_loops = 1024;
10236 }
10237
10238 if (hash_mode == 12500)
10239 {
10240 kernel_loops = ROUNDS_RAR3 / 16;
10241 }
10242
10243 data.kernel_accel = kernel_accel;
10244 data.kernel_loops = kernel_loops;
10245
10246 /**
10247 * word len
10248 */
10249
10250 uint pw_min = PW_MIN;
10251 uint pw_max = PW_MAX;
10252
10253 switch (hash_mode)
10254 {
10255 case 400: if (pw_max > 40) pw_max = 40;
10256 break;
10257 case 500: if (pw_max > 16) pw_max = 16;
10258 break;
10259 case 1500: if (pw_max > 8) pw_max = 8;
10260 break;
10261 case 1600: if (pw_max > 16) pw_max = 16;
10262 break;
10263 case 1800: if (pw_max > 16) pw_max = 16;
10264 break;
10265 case 2100: if (pw_max > 16) pw_max = 16;
10266 break;
10267 case 2500: if (pw_min < 8) pw_min = 8;
10268 break;
10269 case 3000: if (pw_max > 7) pw_max = 7;
10270 break;
10271 case 5200: if (pw_max > 24) pw_max = 24;
10272 break;
10273 case 5800: if (pw_max > 16) pw_max = 16;
10274 break;
10275 case 6300: if (pw_max > 16) pw_max = 16;
10276 break;
10277 case 7400: if (pw_max > 16) pw_max = 16;
10278 break;
10279 case 7900: if (pw_max > 48) pw_max = 48;
10280 break;
10281 case 8500: if (pw_max > 8) pw_max = 8;
10282 break;
10283 case 8600: if (pw_max > 16) pw_max = 16;
10284 break;
10285 case 9710: pw_min = 5;
10286 pw_max = 5;
10287 break;
10288 case 9810: pw_min = 5;
10289 pw_max = 5;
10290 break;
10291 case 10410: pw_min = 5;
10292 pw_max = 5;
10293 break;
10294 case 10300: if (pw_max < 3) pw_min = 3;
10295 if (pw_max > 40) pw_max = 40;
10296 break;
10297 case 10500: if (pw_max < 3) pw_min = 3;
10298 if (pw_max > 40) pw_max = 40;
10299 break;
10300 case 10700: if (pw_max > 16) pw_max = 16;
10301 break;
10302 case 11300: if (pw_max > 40) pw_max = 40;
10303 break;
10304 case 12500: if (pw_max > 20) pw_max = 20;
10305 break;
10306 case 12800: if (pw_max > 24) pw_max = 24;
10307 break;
10308 }
10309
10310 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10311 {
10312 switch (attack_kern)
10313 {
10314 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10315 break;
10316 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10317 break;
10318 }
10319 }
10320
10321 /**
10322 * charsets : keep them together for more easy maintainnce
10323 */
10324
10325 cs_t mp_sys[6];
10326 cs_t mp_usr[4];
10327
10328 memset (mp_sys, 0, sizeof (mp_sys));
10329 memset (mp_usr, 0, sizeof (mp_usr));
10330
10331 mp_setup_sys (mp_sys);
10332
10333 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10334 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10335 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10336 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10337
10338 /**
10339 * load hashes, part I: find input mode, count hashes
10340 */
10341
10342 uint hashlist_mode = 0;
10343 uint hashlist_format = HLFMT_HASHCAT;
10344
10345 uint hashes_avail = 0;
10346
10347 if (benchmark == 0)
10348 {
10349 struct stat f;
10350
10351 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10352
10353 if ((hash_mode == 2500) ||
10354 (hash_mode == 5200) ||
10355 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10356 (hash_mode == 9000))
10357 {
10358 hashlist_mode = HL_MODE_ARG;
10359
10360 char *hashfile = myargv[optind];
10361
10362 data.hashfile = hashfile;
10363
10364 logfile_top_var_string ("target", hashfile);
10365 }
10366
10367 if (hashlist_mode == HL_MODE_ARG)
10368 {
10369 if (hash_mode == 2500)
10370 {
10371 struct stat st;
10372
10373 if (stat (data.hashfile, &st) == -1)
10374 {
10375 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10376
10377 return (-1);
10378 }
10379
10380 hashes_avail = st.st_size / sizeof (hccap_t);
10381 }
10382 else
10383 {
10384 hashes_avail = 1;
10385 }
10386 }
10387 else if (hashlist_mode == HL_MODE_FILE)
10388 {
10389 char *hashfile = myargv[optind];
10390
10391 data.hashfile = hashfile;
10392
10393 logfile_top_var_string ("target", hashfile);
10394
10395 FILE *fp = NULL;
10396
10397 if ((fp = fopen (hashfile, "rb")) == NULL)
10398 {
10399 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10400
10401 return (-1);
10402 }
10403
10404 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10405
10406 hashes_avail = count_lines (fp);
10407
10408 rewind (fp);
10409
10410 if (hashes_avail == 0)
10411 {
10412 log_error ("ERROR: hashfile is empty or corrupt");
10413
10414 fclose (fp);
10415
10416 return (-1);
10417 }
10418
10419 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10420
10421 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10422 {
10423 log_error ("ERROR: remove not supported in native hashfile-format mode");
10424
10425 fclose (fp);
10426
10427 return (-1);
10428 }
10429
10430 fclose (fp);
10431 }
10432 }
10433 else
10434 {
10435 hashlist_mode = HL_MODE_ARG;
10436
10437 hashes_avail = 1;
10438 }
10439
10440 if (hash_mode == 3000) hashes_avail *= 2;
10441
10442 data.hashlist_mode = hashlist_mode;
10443 data.hashlist_format = hashlist_format;
10444
10445 logfile_top_uint (hashlist_mode);
10446 logfile_top_uint (hashlist_format);
10447
10448 /**
10449 * load hashes, part II: allocate required memory, set pointers
10450 */
10451
10452 hash_t *hashes_buf = NULL;
10453 void *digests_buf = NULL;
10454 salt_t *salts_buf = NULL;
10455 void *esalts_buf = NULL;
10456
10457 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10458
10459 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10460
10461 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10462 {
10463 uint32_t hash_pos;
10464
10465 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10466 {
10467 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10468
10469 hashes_buf[hash_pos].hash_info = hash_info;
10470
10471 if (username && (remove || show || left))
10472 {
10473 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10474 }
10475
10476 if (benchmark)
10477 {
10478 hash_info->orighash = (char *) mymalloc (256);
10479 }
10480 }
10481 }
10482
10483 if (isSalted)
10484 {
10485 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10486
10487 if (esalt_size)
10488 {
10489 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10490 }
10491 }
10492 else
10493 {
10494 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10495 }
10496
10497 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10498 {
10499 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10500
10501 if (isSalted)
10502 {
10503 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10504
10505 if (esalt_size)
10506 {
10507 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10508 }
10509 }
10510 else
10511 {
10512 hashes_buf[hash_pos].salt = &salts_buf[0];
10513 }
10514 }
10515
10516 /**
10517 * load hashes, part III: parse hashes or generate them if benchmark
10518 */
10519
10520 uint hashes_cnt = 0;
10521
10522 if (benchmark == 0)
10523 {
10524 if (keyspace == 1)
10525 {
10526 // useless to read hash file for keyspace, cheat a little bit w/ optind
10527 }
10528 else if (hashes_avail == 0)
10529 {
10530 }
10531 else if (hashlist_mode == HL_MODE_ARG)
10532 {
10533 char *input_buf = myargv[optind];
10534
10535 uint input_len = strlen (input_buf);
10536
10537 logfile_top_var_string ("target", input_buf);
10538
10539 char *hash_buf = NULL;
10540 int hash_len = 0;
10541
10542 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10543
10544 if (hash_len)
10545 {
10546 if (opts_type & OPTS_TYPE_HASH_COPY)
10547 {
10548 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10549
10550 hash_info_tmp->orighash = mystrdup (hash_buf);
10551 }
10552
10553 if (isSalted)
10554 {
10555 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10556 }
10557
10558 int parser_status = PARSER_OK;
10559
10560 if (hash_mode == 2500)
10561 {
10562 if (hash_len == 0)
10563 {
10564 log_error ("ERROR: hccap file not specified");
10565
10566 return (-1);
10567 }
10568
10569 hashlist_mode = HL_MODE_FILE;
10570
10571 data.hashlist_mode = hashlist_mode;
10572
10573 FILE *fp = fopen (hash_buf, "rb");
10574
10575 if (fp == NULL)
10576 {
10577 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10578
10579 return (-1);
10580 }
10581
10582 if (hashes_avail < 1)
10583 {
10584 log_error ("ERROR: hccap file is empty or corrupt");
10585
10586 fclose (fp);
10587
10588 return (-1);
10589 }
10590
10591 uint hccap_size = sizeof (hccap_t);
10592
10593 char in[hccap_size];
10594
10595 while (!feof (fp))
10596 {
10597 int n = fread (&in, hccap_size, 1, fp);
10598
10599 if (n != 1)
10600 {
10601 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
10602
10603 break;
10604 }
10605
10606 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
10607
10608 if (parser_status != PARSER_OK)
10609 {
10610 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
10611
10612 continue;
10613 }
10614
10615 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
10616
10617 if ((show == 1) || (left == 1))
10618 {
10619 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
10620
10621 char *salt_ptr = (char *) tmp_salt->salt_buf;
10622
10623 int cur_pos = tmp_salt->salt_len;
10624 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10625
10626 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
10627
10628 unsigned char *pke_ptr = (unsigned char *) wpa->pke;
10629
10630 // do the appending task
10631
10632 snprintf (salt_ptr + cur_pos,
10633 rem_len,
10634 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
10635 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
10636 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
10637
10638
10639 // memset () the remaining part of the salt
10640
10641 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
10642 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10643
10644 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
10645
10646 tmp_salt->salt_len += 1 + 12 + 1 + 12;
10647 }
10648
10649 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);
10650 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);
10651
10652 hashes_cnt++;
10653 }
10654
10655 fclose (fp);
10656 }
10657 else if (hash_mode == 3000)
10658 {
10659 if (hash_len == 32)
10660 {
10661 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10662
10663 hash_t *lm_hash_left = NULL;
10664
10665 if (parser_status == PARSER_OK)
10666 {
10667 lm_hash_left = &hashes_buf[hashes_cnt];
10668
10669 hashes_cnt++;
10670 }
10671 else
10672 {
10673 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10674 }
10675
10676
10677 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10678
10679 hash_t *lm_hash_right = NULL;
10680
10681 if (parser_status == PARSER_OK)
10682 {
10683 lm_hash_right = &hashes_buf[hashes_cnt];
10684
10685 hashes_cnt++;
10686 }
10687 else
10688 {
10689 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10690 }
10691
10692 // show / left
10693
10694 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
10695 {
10696 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);
10697 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);
10698 }
10699 }
10700 else
10701 {
10702 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10703
10704 if (parser_status == PARSER_OK)
10705 {
10706 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10707 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10708 }
10709
10710 if (parser_status == PARSER_OK)
10711 {
10712 hashes_cnt++;
10713 }
10714 else
10715 {
10716 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10717 }
10718 }
10719 }
10720 else
10721 {
10722 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10723
10724 if (parser_status == PARSER_OK)
10725 {
10726 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10727 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10728 }
10729
10730 if (parser_status == PARSER_OK)
10731 {
10732 hashes_cnt++;
10733 }
10734 else
10735 {
10736 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10737 }
10738 }
10739 }
10740 }
10741 else if (hashlist_mode == HL_MODE_FILE)
10742 {
10743 char *hashfile = data.hashfile;
10744
10745 FILE *fp;
10746
10747 if ((fp = fopen (hashfile, "rb")) == NULL)
10748 {
10749 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10750
10751 return (-1);
10752 }
10753
10754 uint line_num = 0;
10755
10756 while (!feof (fp))
10757 {
10758 line_num++;
10759
10760 char line_buf[BUFSIZ];
10761
10762 int line_len = fgetl (fp, line_buf);
10763
10764 if (line_len == 0) continue;
10765
10766 char *hash_buf = NULL;
10767 int hash_len = 0;
10768
10769 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
10770
10771 if (username)
10772 {
10773 char *user_buf = NULL;
10774 int user_len = 0;
10775
10776 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
10777
10778 if (remove || show)
10779 {
10780 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
10781
10782 *user = (user_t *) malloc (sizeof (user_t));
10783
10784 user_t *user_ptr = *user;
10785
10786 if (user_buf != NULL)
10787 {
10788 user_ptr->user_name = mystrdup (user_buf);
10789 }
10790 else
10791 {
10792 user_ptr->user_name = mystrdup ("");
10793 }
10794
10795 user_ptr->user_len = user_len;
10796 }
10797 }
10798
10799 if (opts_type & OPTS_TYPE_HASH_COPY)
10800 {
10801 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10802
10803 hash_info_tmp->orighash = mystrdup (hash_buf);
10804 }
10805
10806 if (isSalted)
10807 {
10808 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
10809 }
10810
10811 if (hash_mode == 3000)
10812 {
10813 if (hash_len == 32)
10814 {
10815 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10816
10817 if (parser_status < PARSER_GLOBAL_ZERO)
10818 {
10819 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10820
10821 continue;
10822 }
10823
10824 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
10825
10826 hashes_cnt++;
10827
10828 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10829
10830 if (parser_status < PARSER_GLOBAL_ZERO)
10831 {
10832 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10833
10834 continue;
10835 }
10836
10837 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
10838
10839 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);
10840
10841 hashes_cnt++;
10842
10843 // show / left
10844
10845 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);
10846 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);
10847 }
10848 else
10849 {
10850 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10851
10852 if (parser_status < PARSER_GLOBAL_ZERO)
10853 {
10854 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10855
10856 continue;
10857 }
10858
10859 if (data.quiet == 0) if ((hashes_cnt % 0x20000) == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_cnt, hashes_avail, ((float) hashes_cnt / hashes_avail) * 100);
10860
10861 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10862 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10863
10864 hashes_cnt++;
10865 }
10866 }
10867 else
10868 {
10869 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10870
10871 if (parser_status < PARSER_GLOBAL_ZERO)
10872 {
10873 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10874
10875 continue;
10876 }
10877
10878 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);
10879
10880 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10881 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10882
10883 hashes_cnt++;
10884 }
10885 }
10886
10887 fclose (fp);
10888
10889 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
10890
10891 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
10892 }
10893 }
10894 else
10895 {
10896 if (isSalted)
10897 {
10898 hashes_buf[0].salt->salt_len = 8;
10899
10900 // special salt handling
10901
10902 switch (hash_mode)
10903 {
10904 case 1500: hashes_buf[0].salt->salt_len = 2;
10905 break;
10906 case 1731: hashes_buf[0].salt->salt_len = 4;
10907 break;
10908 case 2410: hashes_buf[0].salt->salt_len = 4;
10909 break;
10910 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
10911 break;
10912 case 3100: hashes_buf[0].salt->salt_len = 1;
10913 break;
10914 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
10915 break;
10916 case 5800: hashes_buf[0].salt->salt_len = 16;
10917 break;
10918 case 6800: hashes_buf[0].salt->salt_len = 32;
10919 break;
10920 case 8400: hashes_buf[0].salt->salt_len = 40;
10921 break;
10922 case 8800: hashes_buf[0].salt->salt_len = 16;
10923 break;
10924 case 8900: hashes_buf[0].salt->salt_len = 16;
10925 hashes_buf[0].salt->scrypt_N = 1024;
10926 hashes_buf[0].salt->scrypt_r = 1;
10927 hashes_buf[0].salt->scrypt_p = 1;
10928 break;
10929 case 9100: hashes_buf[0].salt->salt_len = 16;
10930 break;
10931 case 9300: hashes_buf[0].salt->salt_len = 14;
10932 hashes_buf[0].salt->scrypt_N = 16384;
10933 hashes_buf[0].salt->scrypt_r = 1;
10934 hashes_buf[0].salt->scrypt_p = 1;
10935 break;
10936 case 9400: hashes_buf[0].salt->salt_len = 16;
10937 break;
10938 case 9500: hashes_buf[0].salt->salt_len = 16;
10939 break;
10940 case 9600: hashes_buf[0].salt->salt_len = 16;
10941 break;
10942 case 9700: hashes_buf[0].salt->salt_len = 16;
10943 break;
10944 case 9710: hashes_buf[0].salt->salt_len = 16;
10945 break;
10946 case 9720: hashes_buf[0].salt->salt_len = 16;
10947 break;
10948 case 9800: hashes_buf[0].salt->salt_len = 16;
10949 break;
10950 case 9810: hashes_buf[0].salt->salt_len = 16;
10951 break;
10952 case 9820: hashes_buf[0].salt->salt_len = 16;
10953 break;
10954 case 10300: hashes_buf[0].salt->salt_len = 12;
10955 break;
10956 case 11500: hashes_buf[0].salt->salt_len = 4;
10957 break;
10958 case 11600: hashes_buf[0].salt->salt_len = 4;
10959 break;
10960 case 12400: hashes_buf[0].salt->salt_len = 4;
10961 break;
10962 case 12500: hashes_buf[0].salt->salt_len = 8;
10963 break;
10964 case 12600: hashes_buf[0].salt->salt_len = 64;
10965 break;
10966 }
10967
10968 // special esalt handling
10969
10970 switch (hash_mode)
10971 {
10972 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
10973 break;
10974 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
10975 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
10976 break;
10977 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
10978 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
10979 break;
10980 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
10981 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
10982 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
10983 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
10984 break;
10985 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
10986 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
10987 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
10988 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
10989 break;
10990 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
10991 break;
10992 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10993 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
10994 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
10995 break;
10996 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10997 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
10998 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
10999 break;
11000 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11001 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11002 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11003 break;
11004 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11005 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11006 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11007 break;
11008 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11009 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11010 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11011 break;
11012 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11013 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11014 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11015 break;
11016 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11017 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11018 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11019 break;
11020 }
11021 }
11022
11023 // set hashfile
11024
11025 switch (hash_mode)
11026 {
11027 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11028 break;
11029 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11030 break;
11031 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11032 break;
11033 case 6211:
11034 case 6212:
11035 case 6213:
11036 case 6221:
11037 case 6222:
11038 case 6223:
11039 case 6231:
11040 case 6232:
11041 case 6233:
11042 case 6241:
11043 case 6242:
11044 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11045 break;
11046 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11047 break;
11048 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11049 break;
11050 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11051 break;
11052 }
11053
11054 // set default iterations
11055
11056 switch (hash_mode)
11057 {
11058 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11059 break;
11060 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11061 break;
11062 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11063 break;
11064 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11065 break;
11066 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11067 break;
11068 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11069 break;
11070 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11071 break;
11072 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11073 break;
11074 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11075 break;
11076 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11077 break;
11078 case 6211:
11079 case 6212:
11080 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11081 break;
11082 case 6221:
11083 case 6222:
11084 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11085 break;
11086 case 6231:
11087 case 6232:
11088 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11089 break;
11090 case 6241:
11091 case 6242:
11092 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11093 break;
11094 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11095 break;
11096 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11097 break;
11098 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11099 break;
11100 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11101 break;
11102 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11103 break;
11104 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11105 break;
11106 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11107 break;
11108 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11109 break;
11110 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11111 break;
11112 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11113 break;
11114 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11115 break;
11116 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11117 break;
11118 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11119 break;
11120 case 8900: hashes_buf[0].salt->salt_iter = 1;
11121 break;
11122 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11123 break;
11124 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11125 break;
11126 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11127 break;
11128 case 9300: hashes_buf[0].salt->salt_iter = 1;
11129 break;
11130 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11131 break;
11132 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11133 break;
11134 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11135 break;
11136 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11137 break;
11138 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11139 break;
11140 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11141 break;
11142 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11143 break;
11144 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11145 break;
11146 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11147 break;
11148 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11149 break;
11150 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11151 break;
11152 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11153 break;
11154 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11155 break;
11156 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11157 break;
11158 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11159 break;
11160 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11161 break;
11162 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11163 break;
11164 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11165 break;
11166 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11167 break;
11168 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11169 break;
11170 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11171 break;
11172 }
11173
11174 // set special tuning for benchmark-mode 1
11175
11176 if (benchmark_mode == 1)
11177 {
11178 kernel_loops *= 8;
11179 kernel_accel *= 4;
11180
11181 switch (hash_mode)
11182 {
11183 case 400: kernel_loops = ROUNDS_PHPASS;
11184 kernel_accel = 32;
11185 break;
11186 case 500: kernel_loops = ROUNDS_MD5CRYPT;
11187 kernel_accel = 32;
11188 break;
11189 case 501: kernel_loops = ROUNDS_MD5CRYPT;
11190 kernel_accel = 32;
11191 break;
11192 case 1600: kernel_loops = ROUNDS_MD5CRYPT;
11193 kernel_accel = 32;
11194 break;
11195 case 1800: kernel_loops = ROUNDS_SHA512CRYPT;
11196 kernel_accel = 16;
11197 break;
11198 case 2100: kernel_loops = ROUNDS_DCC2;
11199 kernel_accel = 16;
11200 break;
11201 case 2500: kernel_loops = ROUNDS_WPA2;
11202 kernel_accel = 32;
11203 break;
11204 case 3200: kernel_loops = ROUNDS_BCRYPT;
11205 kernel_accel = 8;
11206 break;
11207 case 5200: kernel_loops = ROUNDS_PSAFE3;
11208 kernel_accel = 16;
11209 break;
11210 case 5800: kernel_loops = ROUNDS_ANDROIDPIN;
11211 kernel_accel = 16;
11212 break;
11213 case 6211: kernel_loops = ROUNDS_TRUECRYPT_2K;
11214 kernel_accel = 64;
11215 break;
11216 case 6212: kernel_loops = ROUNDS_TRUECRYPT_2K;
11217 kernel_accel = 32;
11218 break;
11219 case 6213: kernel_loops = ROUNDS_TRUECRYPT_2K;
11220 kernel_accel = 32;
11221 break;
11222 case 6221: kernel_loops = ROUNDS_TRUECRYPT_1K;
11223 kernel_accel = 8;
11224 break;
11225 case 6222: kernel_loops = ROUNDS_TRUECRYPT_1K;
11226 kernel_accel = 8;
11227 break;
11228 case 6223: kernel_loops = ROUNDS_TRUECRYPT_1K;
11229 kernel_accel = 8;
11230 break;
11231 case 6231: kernel_loops = ROUNDS_TRUECRYPT_1K;
11232 kernel_accel = 8;
11233 break;
11234 case 6232: kernel_loops = ROUNDS_TRUECRYPT_1K;
11235 kernel_accel = 8;
11236 break;
11237 case 6233: kernel_loops = ROUNDS_TRUECRYPT_1K;
11238 kernel_accel = 8;
11239 break;
11240 case 6241: kernel_loops = ROUNDS_TRUECRYPT_1K;
11241 kernel_accel = 128;
11242 break;
11243 case 6242: kernel_loops = ROUNDS_TRUECRYPT_1K;
11244 kernel_accel = 64;
11245 break;
11246 case 6243: kernel_loops = ROUNDS_TRUECRYPT_1K;
11247 kernel_accel = 64;
11248 break;
11249 case 6300: kernel_loops = ROUNDS_MD5CRYPT;
11250 kernel_accel = 32;
11251 break;
11252 case 6700: kernel_loops = ROUNDS_SHA1AIX;
11253 kernel_accel = 128;
11254 break;
11255 case 6400: kernel_loops = ROUNDS_SHA256AIX;
11256 kernel_accel = 128;
11257 break;
11258 case 6500: kernel_loops = ROUNDS_SHA512AIX;
11259 kernel_accel = 32;
11260 break;
11261 case 6600: kernel_loops = ROUNDS_AGILEKEY;
11262 kernel_accel = 64;
11263 break;
11264 case 6800: kernel_loops = ROUNDS_LASTPASS;
11265 kernel_accel = 64;
11266 break;
11267 case 7100: kernel_loops = ROUNDS_SHA512OSX;
11268 kernel_accel = 8;
11269 break;
11270 case 7200: kernel_loops = ROUNDS_GRUB;
11271 kernel_accel = 16;
11272 break;
11273 case 7400: kernel_loops = ROUNDS_SHA256CRYPT;
11274 kernel_accel = 8;
11275 break;
11276 case 7900: kernel_loops = ROUNDS_DRUPAL7;
11277 kernel_accel = 8;
11278 break;
11279 case 8200: kernel_loops = ROUNDS_CLOUDKEY;
11280 kernel_accel = 8;
11281 break;
11282 case 8800: kernel_loops = ROUNDS_ANDROIDFDE;
11283 kernel_accel = 32;
11284 break;
11285 case 8900: kernel_loops = 1;
11286 kernel_accel = 64;
11287 break;
11288 case 9000: kernel_loops = ROUNDS_PSAFE2;
11289 kernel_accel = 16;
11290 break;
11291 case 9100: kernel_loops = ROUNDS_LOTUS8;
11292 kernel_accel = 64;
11293 break;
11294 case 9200: kernel_loops = ROUNDS_CISCO8;
11295 kernel_accel = 8;
11296 break;
11297 case 9300: kernel_loops = 1;
11298 kernel_accel = 4;
11299 break;
11300 case 9400: kernel_loops = ROUNDS_OFFICE2007;
11301 kernel_accel = 32;
11302 break;
11303 case 9500: kernel_loops = ROUNDS_OFFICE2010;
11304 kernel_accel = 32;
11305 break;
11306 case 9600: kernel_loops = ROUNDS_OFFICE2013;
11307 kernel_accel = 8;
11308 break;
11309 case 10000: kernel_loops = ROUNDS_DJANGOPBKDF2;
11310 kernel_accel = 8;
11311 break;
11312 case 10300: kernel_loops = ROUNDS_SAPH_SHA1;
11313 kernel_accel = 16;
11314 break;
11315 case 10500: kernel_loops = ROUNDS_PDF14;
11316 kernel_accel = 256;
11317 break;
11318 case 10700: kernel_loops = ROUNDS_PDF17L8;
11319 kernel_accel = 8;
11320 break;
11321 case 10900: kernel_loops = ROUNDS_PBKDF2_SHA256;
11322 kernel_accel = 8;
11323 break;
11324 case 11300: kernel_loops = ROUNDS_BITCOIN_WALLET;
11325 kernel_accel = 8;
11326 break;
11327 case 11600: kernel_loops = ROUNDS_SEVEN_ZIP;
11328 kernel_accel = 8;
11329 break;
11330 case 11900: kernel_loops = ROUNDS_PBKDF2_MD5;
11331 kernel_accel = 8;
11332 break;
11333 case 12000: kernel_loops = ROUNDS_PBKDF2_SHA1;
11334 kernel_accel = 8;
11335 break;
11336 case 12100: kernel_loops = ROUNDS_PBKDF2_SHA512;
11337 kernel_accel = 8;
11338 break;
11339 case 12200: kernel_loops = ROUNDS_ECRYPTFS;
11340 kernel_accel = 8;
11341 break;
11342 case 12300: kernel_loops = ROUNDS_ORACLET;
11343 kernel_accel = 8;
11344 break;
11345 case 12500: kernel_loops = ROUNDS_RAR3;
11346 kernel_accel = 32;
11347 break;
11348 case 12700: kernel_loops = ROUNDS_MYWALLET;
11349 kernel_accel = 512;
11350 break;
11351 case 12800: kernel_loops = ROUNDS_MS_DRSR;
11352 kernel_accel = 512;
11353 break;
11354 case 12900: kernel_loops = ROUNDS_ANDROIDFDE_SAMSUNG;
11355 kernel_accel = 8;
11356 break;
11357 case 13000: kernel_loops = ROUNDS_RAR5;
11358 kernel_accel = 8;
11359 break;
11360 }
11361
11362 // some algorithm collide too fast, make that impossible
11363
11364 switch (hash_mode)
11365 {
11366 case 11500: ((uint *) digests_buf)[1] = 1;
11367 break;
11368 }
11369
11370 if (kernel_loops > 1024) kernel_loops = 1024;
11371 if (kernel_accel > 256) kernel_accel = 256; // causes memory problems otherwise
11372 }
11373
11374 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
11375 {
11376 kernel_loops = 1024;
11377 }
11378
11379 if (hash_mode == 12500)
11380 {
11381 kernel_loops = ROUNDS_RAR3 / 16;
11382 }
11383
11384 data.kernel_accel = kernel_accel;
11385 data.kernel_loops = kernel_loops;
11386
11387 hashes_cnt = 1;
11388 }
11389
11390 if (show == 1 || left == 1)
11391 {
11392 for (uint i = 0; i < pot_cnt; i++)
11393 {
11394 pot_t *pot_ptr = &pot[i];
11395
11396 hash_t *hashes_buf = &pot_ptr->hash;
11397
11398 local_free (hashes_buf->digest);
11399
11400 if (isSalted)
11401 {
11402 local_free (hashes_buf->salt);
11403 }
11404 }
11405
11406 local_free (pot);
11407
11408 if (data.quiet == 0) log_info_nn ("");
11409
11410 return (0);
11411 }
11412
11413 if (keyspace == 0)
11414 {
11415 if (hashes_cnt == 0)
11416 {
11417 log_error ("ERROR: No hashes loaded");
11418
11419 return (-1);
11420 }
11421 }
11422
11423 /**
11424 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11425 */
11426
11427 if (data.outfile != NULL)
11428 {
11429 if (data.hashfile != NULL)
11430 {
11431 #ifdef _POSIX
11432 struct stat tmpstat_outfile;
11433 struct stat tmpstat_hashfile;
11434 #endif
11435
11436 #ifdef _WIN
11437 struct stat64 tmpstat_outfile;
11438 struct stat64 tmpstat_hashfile;
11439 #endif
11440
11441 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11442
11443 if (tmp_outfile_fp)
11444 {
11445 #ifdef _POSIX
11446 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11447 #endif
11448
11449 #ifdef _WIN
11450 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11451 #endif
11452
11453 fclose (tmp_outfile_fp);
11454 }
11455
11456 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11457
11458 if (tmp_hashfile_fp)
11459 {
11460 #ifdef _POSIX
11461 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11462 #endif
11463
11464 #ifdef _WIN
11465 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11466 #endif
11467
11468 fclose (tmp_hashfile_fp);
11469 }
11470
11471 if (tmp_outfile_fp && tmp_outfile_fp)
11472 {
11473 tmpstat_outfile.st_mode = 0;
11474 tmpstat_outfile.st_nlink = 0;
11475 tmpstat_outfile.st_uid = 0;
11476 tmpstat_outfile.st_gid = 0;
11477 tmpstat_outfile.st_rdev = 0;
11478 tmpstat_outfile.st_atime = 0;
11479
11480 tmpstat_hashfile.st_mode = 0;
11481 tmpstat_hashfile.st_nlink = 0;
11482 tmpstat_hashfile.st_uid = 0;
11483 tmpstat_hashfile.st_gid = 0;
11484 tmpstat_hashfile.st_rdev = 0;
11485 tmpstat_hashfile.st_atime = 0;
11486
11487 #ifdef _POSIX
11488 tmpstat_outfile.st_blksize = 0;
11489 tmpstat_outfile.st_blocks = 0;
11490
11491 tmpstat_hashfile.st_blksize = 0;
11492 tmpstat_hashfile.st_blocks = 0;
11493 #endif
11494
11495 #ifdef _POSIX
11496 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11497 {
11498 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11499
11500 return (-1);
11501 }
11502 #endif
11503
11504 #ifdef _WIN
11505 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11506 {
11507 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11508
11509 return (-1);
11510 }
11511 #endif
11512 }
11513 }
11514 }
11515
11516 /**
11517 * Remove duplicates
11518 */
11519
11520 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11521
11522 if (isSalted)
11523 {
11524 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11525 }
11526 else
11527 {
11528 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11529 }
11530
11531 uint hashes_cnt_orig = hashes_cnt;
11532
11533 hashes_cnt = 1;
11534
11535 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11536 {
11537 if (isSalted)
11538 {
11539 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11540 {
11541 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11542 }
11543 }
11544 else
11545 {
11546 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11547 }
11548
11549 if (hashes_pos > hashes_cnt)
11550 {
11551 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11552 }
11553
11554 hashes_cnt++;
11555 }
11556
11557 /**
11558 * Potfile removes
11559 */
11560
11561 uint potfile_remove_cracks = 0;
11562
11563 if (potfile_disable == 0)
11564 {
11565 hash_t hash_buf;
11566
11567 hash_buf.digest = mymalloc (dgst_size);
11568 hash_buf.salt = NULL;
11569 hash_buf.esalt = NULL;
11570 hash_buf.hash_info = NULL;
11571 hash_buf.cracked = 0;
11572
11573 if (isSalted)
11574 {
11575 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11576 }
11577
11578 if (esalt_size)
11579 {
11580 hash_buf.esalt = mymalloc (esalt_size);
11581 }
11582
11583 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11584
11585 // no solution for these special hash types (for instane because they use hashfile in output etc)
11586 if ((hash_mode != 5200) &&
11587 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11588 (hash_mode != 9000))
11589 {
11590 FILE *fp = fopen (potfile, "rb");
11591
11592 if (fp != NULL)
11593 {
11594 while (!feof (fp))
11595 {
11596 char line_buf[BUFSIZ];
11597
11598 memset (line_buf, 0, BUFSIZ);
11599
11600 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11601
11602 if (ptr == NULL) break;
11603
11604 int line_len = strlen (line_buf);
11605
11606 if (line_len == 0) continue;
11607
11608 int iter = MAX_CUT_TRIES;
11609
11610 for (int i = line_len - 1; i && iter; i--, line_len--)
11611 {
11612 if (line_buf[i] != ':') continue;
11613
11614 if (isSalted)
11615 {
11616 memset (hash_buf.salt, 0, sizeof (salt_t));
11617 }
11618
11619 hash_t *found = NULL;
11620
11621 if (hash_mode == 6800)
11622 {
11623 if (i < 48) // 48 = 12 * uint in salt_buf[]
11624 {
11625 // manipulate salt_buf
11626 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11627
11628 hash_buf.salt->salt_len = i;
11629
11630 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11631 }
11632 }
11633 else if (hash_mode == 2500)
11634 {
11635 if (i < 48) // 48 = 12 * uint in salt_buf[]
11636 {
11637 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11638 // manipulate salt_buf
11639
11640 // to be safe work with a copy (because of line_len loop, i etc)
11641
11642 char line_buf_cpy[BUFSIZ];
11643 memset (line_buf_cpy, 0, BUFSIZ);
11644
11645 memset (line_buf_cpy, 0, sizeof (line_buf_cpy));
11646
11647 memcpy (line_buf_cpy, line_buf, i);
11648
11649 char *mac2_pos = strrchr (line_buf_cpy, ':');
11650
11651 if (mac2_pos == NULL) continue;
11652
11653 mac2_pos[0] = 0;
11654 mac2_pos++;
11655
11656 if (strlen (mac2_pos) != 12) continue;
11657
11658 char *mac1_pos = strrchr (line_buf_cpy, ':');
11659
11660 if (mac1_pos == NULL) continue;
11661
11662 mac1_pos[0] = 0;
11663 mac1_pos++;
11664
11665 if (strlen (mac1_pos) != 12) continue;
11666
11667 uint essid_length = mac1_pos - line_buf_cpy - 1;
11668
11669 // here we need the ESSID
11670 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11671
11672 hash_buf.salt->salt_len = essid_length;
11673
11674 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11675
11676 if (found)
11677 {
11678 wpa_t *wpa = (wpa_t *) found->esalt;
11679
11680 uint pke[25];
11681
11682 char *pke_ptr = (char *) pke;
11683
11684 for (uint i = 0; i < 25; i++)
11685 {
11686 pke[i] = byte_swap_32 (wpa->pke[i]);
11687 }
11688
11689 unsigned char mac1[6];
11690 unsigned char mac2[6];
11691
11692 memcpy (mac1, pke_ptr + 23, 6);
11693 memcpy (mac2, pke_ptr + 29, 6);
11694
11695 // compare hex string(s) vs binary MAC address(es)
11696
11697 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11698 {
11699 if (mac1[i] != (unsigned char) hex_to_char (&mac1_pos[j]))
11700 {
11701 found = NULL;
11702 break;
11703 }
11704 }
11705
11706 // early skip ;)
11707 if (!found) continue;
11708
11709 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11710 {
11711 if (mac2[i] != (unsigned char) hex_to_char (&mac2_pos[j]))
11712 {
11713 found = NULL;
11714 break;
11715 }
11716 }
11717 }
11718 }
11719 }
11720 else
11721 {
11722 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11723
11724 if (parser_status == PARSER_OK)
11725 {
11726 if (isSalted)
11727 {
11728 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11729 }
11730 else
11731 {
11732 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11733 }
11734 }
11735 }
11736
11737 if (found == NULL) continue;
11738
11739 if (!found->cracked) potfile_remove_cracks++;
11740
11741 found->cracked = 1;
11742
11743 if (found) break;
11744
11745 iter--;
11746 }
11747 }
11748
11749 fclose (fp);
11750 }
11751 }
11752
11753 if (esalt_size)
11754 {
11755 local_free (hash_buf.esalt);
11756 }
11757
11758 if (isSalted)
11759 {
11760 local_free (hash_buf.salt);
11761 }
11762
11763 local_free (hash_buf.digest);
11764 }
11765
11766 /**
11767 * Now generate all the buffers required for later
11768 */
11769
11770 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11771
11772 salt_t *salts_buf_new = NULL;
11773 void *esalts_buf_new = NULL;
11774
11775 if (isSalted)
11776 {
11777 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11778
11779 if (esalt_size)
11780 {
11781 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
11782 }
11783 }
11784 else
11785 {
11786 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
11787 }
11788
11789 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
11790
11791 uint digests_cnt = hashes_cnt;
11792 uint digests_done = 0;
11793
11794 uint size_digests = digests_cnt * dgst_size;
11795 uint size_shown = digests_cnt * sizeof (uint);
11796
11797 uint *digests_shown = (uint *) mymalloc (size_shown);
11798 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
11799
11800 uint salts_cnt = 0;
11801 uint salts_done = 0;
11802
11803 hashinfo_t **hash_info = NULL;
11804
11805 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11806 {
11807 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
11808
11809 if (username && (remove || show))
11810 {
11811 uint user_pos;
11812
11813 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
11814 {
11815 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
11816
11817 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
11818 }
11819 }
11820 }
11821
11822 uint *salts_shown = (uint *) mymalloc (size_shown);
11823
11824 salt_t *salt_buf;
11825
11826 {
11827 // copied from inner loop
11828
11829 salt_buf = &salts_buf_new[salts_cnt];
11830
11831 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
11832
11833 if (esalt_size)
11834 {
11835 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
11836 }
11837
11838 salt_buf->digests_cnt = 0;
11839 salt_buf->digests_done = 0;
11840 salt_buf->digests_offset = 0;
11841
11842 salts_cnt++;
11843 }
11844
11845 if (hashes_buf[0].cracked == 1)
11846 {
11847 digests_shown[0] = 1;
11848
11849 digests_done++;
11850
11851 salt_buf->digests_done++;
11852 }
11853
11854 salt_buf->digests_cnt++;
11855
11856 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
11857
11858 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11859 {
11860 hash_info[0] = hashes_buf[0].hash_info;
11861 }
11862
11863 // copy from inner loop
11864
11865 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
11866 {
11867 if (isSalted)
11868 {
11869 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
11870 {
11871 salt_buf = &salts_buf_new[salts_cnt];
11872
11873 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
11874
11875 if (esalt_size)
11876 {
11877 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
11878 }
11879
11880 salt_buf->digests_cnt = 0;
11881 salt_buf->digests_done = 0;
11882 salt_buf->digests_offset = hashes_pos;
11883
11884 salts_cnt++;
11885 }
11886 }
11887
11888 if (hashes_buf[hashes_pos].cracked == 1)
11889 {
11890 digests_shown[hashes_pos] = 1;
11891
11892 digests_done++;
11893
11894 salt_buf->digests_done++;
11895 }
11896
11897 salt_buf->digests_cnt++;
11898
11899 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
11900
11901 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11902 {
11903 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
11904 }
11905 }
11906
11907 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
11908 {
11909 salt_t *salt_buf = &salts_buf_new[salt_pos];
11910
11911 if (salt_buf->digests_done == salt_buf->digests_cnt)
11912 {
11913 salts_shown[salt_pos] = 1;
11914
11915 salts_done++;
11916 }
11917
11918 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
11919 }
11920
11921 local_free (digests_buf);
11922 local_free (salts_buf);
11923 local_free (esalts_buf);
11924
11925 digests_buf = digests_buf_new;
11926 salts_buf = salts_buf_new;
11927 esalts_buf = esalts_buf_new;
11928
11929 local_free (hashes_buf);
11930
11931 /**
11932 * special modification not set from parser
11933 */
11934
11935 switch (hash_mode)
11936 {
11937 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
11938 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
11939 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
11940 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
11941 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
11942 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
11943 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
11944 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
11945 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
11946 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
11947 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
11948 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
11949 }
11950
11951 if (truecrypt_keyfiles)
11952 {
11953 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
11954
11955 char *keyfiles = strdup (truecrypt_keyfiles);
11956
11957 char *keyfile = strtok (keyfiles, ",");
11958
11959 do
11960 {
11961 truecrypt_crc32 (keyfile, (unsigned char *) keyfile_buf);
11962
11963 } while ((keyfile = strtok (NULL, ",")) != NULL);
11964
11965 free (keyfiles);
11966 }
11967
11968 data.digests_cnt = digests_cnt;
11969 data.digests_done = digests_done;
11970 data.digests_buf = digests_buf;
11971 data.digests_shown = digests_shown;
11972 data.digests_shown_tmp = digests_shown_tmp;
11973
11974 data.salts_cnt = salts_cnt;
11975 data.salts_done = salts_done;
11976 data.salts_buf = salts_buf;
11977 data.salts_shown = salts_shown;
11978
11979 data.esalts_buf = esalts_buf;
11980 data.hash_info = hash_info;
11981
11982 /**
11983 * Automatic Optimizers
11984 */
11985
11986 if (salts_cnt == 1)
11987 opti_type |= OPTI_TYPE_SINGLE_SALT;
11988
11989 if (digests_cnt == 1)
11990 opti_type |= OPTI_TYPE_SINGLE_HASH;
11991
11992 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11993 opti_type |= OPTI_TYPE_NOT_ITERATED;
11994
11995 if (attack_mode == ATTACK_MODE_BF)
11996 opti_type |= OPTI_TYPE_BRUTE_FORCE;
11997
11998 data.opti_type = opti_type;
11999
12000 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12001 {
12002 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12003 {
12004 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12005 {
12006 if (opts_type & OPTS_TYPE_ST_ADD80)
12007 {
12008 opts_type &= ~OPTS_TYPE_ST_ADD80;
12009 opts_type |= OPTS_TYPE_PT_ADD80;
12010 }
12011
12012 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12013 {
12014 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12015 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12016 }
12017
12018 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12019 {
12020 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12021 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12022 }
12023 }
12024 }
12025 }
12026
12027 /**
12028 * Some algorithm, like descrypt, can benefit from JIT compilation
12029 */
12030
12031 uint force_jit_compilation = 0;
12032
12033 if (hash_mode == 8900)
12034 {
12035 force_jit_compilation = 8900;
12036 }
12037 else if (hash_mode == 9300)
12038 {
12039 force_jit_compilation = 8900;
12040 }
12041 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12042 {
12043 force_jit_compilation = 1500;
12044 }
12045
12046 /**
12047 * generate bitmap tables
12048 */
12049
12050 const uint bitmap_shift1 = 5;
12051 const uint bitmap_shift2 = 13;
12052
12053 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12054
12055 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12056 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12057 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12058 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12059 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12060 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12061 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12062 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12063
12064 uint bitmap_bits;
12065 uint bitmap_nums;
12066 uint bitmap_mask;
12067 uint bitmap_size;
12068
12069 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12070 {
12071 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12072
12073 bitmap_nums = 1 << bitmap_bits;
12074
12075 bitmap_mask = bitmap_nums - 1;
12076
12077 bitmap_size = bitmap_nums * sizeof (uint);
12078
12079 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12080
12081 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;
12082 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;
12083
12084 break;
12085 }
12086
12087 bitmap_nums = 1 << bitmap_bits;
12088
12089 bitmap_mask = bitmap_nums - 1;
12090
12091 bitmap_size = bitmap_nums * sizeof (uint);
12092
12093 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);
12094 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);
12095
12096 /**
12097 * prepare quick rule
12098 */
12099
12100 data.rule_buf_l = rule_buf_l;
12101 data.rule_buf_r = rule_buf_r;
12102
12103 int rule_len_l = (int) strlen (rule_buf_l);
12104 int rule_len_r = (int) strlen (rule_buf_r);
12105
12106 data.rule_len_l = rule_len_l;
12107 data.rule_len_r = rule_len_r;
12108
12109 /**
12110 * load rules
12111 */
12112
12113 uint *all_kernel_rules_cnt = NULL;
12114
12115 kernel_rule_t **all_kernel_rules_buf = NULL;
12116
12117 if (rp_files_cnt)
12118 {
12119 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12120
12121 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12122 }
12123
12124 char rule_buf[BUFSIZ];
12125
12126 int rule_len = 0;
12127
12128 for (uint i = 0; i < rp_files_cnt; i++)
12129 {
12130 uint kernel_rules_avail = 0;
12131
12132 uint kernel_rules_cnt = 0;
12133
12134 kernel_rule_t *kernel_rules_buf = NULL;
12135
12136 char *rp_file = rp_files[i];
12137
12138 char in[BLOCK_SIZE];
12139 char out[BLOCK_SIZE];
12140
12141 FILE *fp = NULL;
12142
12143 uint rule_line = 0;
12144
12145 if ((fp = fopen (rp_file, "rb")) == NULL)
12146 {
12147 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12148
12149 return (-1);
12150 }
12151
12152 while (!feof (fp))
12153 {
12154 memset (rule_buf, 0, BUFSIZ);
12155
12156 rule_len = fgetl (fp, rule_buf);
12157
12158 rule_line++;
12159
12160 if (rule_len == 0) continue;
12161
12162 if (rule_buf[0] == '#') continue;
12163
12164 if (kernel_rules_avail == kernel_rules_cnt)
12165 {
12166 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12167
12168 kernel_rules_avail += INCR_RULES;
12169 }
12170
12171 memset (in, 0, BLOCK_SIZE);
12172 memset (out, 0, BLOCK_SIZE);
12173
12174 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12175
12176 if (result == -1)
12177 {
12178 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12179
12180 continue;
12181 }
12182
12183 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12184 {
12185 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12186
12187 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12188
12189 continue;
12190 }
12191
12192 /* its so slow
12193 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12194 {
12195 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12196
12197 continue;
12198 }
12199 */
12200
12201 kernel_rules_cnt++;
12202 }
12203
12204 fclose (fp);
12205
12206 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12207
12208 all_kernel_rules_buf[i] = kernel_rules_buf;
12209 }
12210
12211 /**
12212 * merge rules or automatic rule generator
12213 */
12214
12215 uint kernel_rules_cnt = 0;
12216
12217 kernel_rule_t *kernel_rules_buf = NULL;
12218
12219 if (attack_mode == ATTACK_MODE_STRAIGHT)
12220 {
12221 if (rp_files_cnt)
12222 {
12223 kernel_rules_cnt = 1;
12224
12225 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12226
12227 repeats[0] = kernel_rules_cnt;
12228
12229 for (uint i = 0; i < rp_files_cnt; i++)
12230 {
12231 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12232
12233 repeats[i + 1] = kernel_rules_cnt;
12234 }
12235
12236 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12237
12238 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12239
12240 for (uint i = 0; i < kernel_rules_cnt; i++)
12241 {
12242 uint out_pos = 0;
12243
12244 kernel_rule_t *out = &kernel_rules_buf[i];
12245
12246 for (uint j = 0; j < rp_files_cnt; j++)
12247 {
12248 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12249 uint in_pos;
12250
12251 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12252
12253 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12254 {
12255 if (out_pos == RULES_MAX - 1)
12256 {
12257 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12258
12259 break;
12260 }
12261
12262 out->cmds[out_pos] = in->cmds[in_pos];
12263 }
12264 }
12265 }
12266
12267 local_free (repeats);
12268 }
12269 else if (rp_gen)
12270 {
12271 uint kernel_rules_avail = 0;
12272
12273 while (kernel_rules_cnt < rp_gen)
12274 {
12275 if (kernel_rules_avail == kernel_rules_cnt)
12276 {
12277 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12278
12279 kernel_rules_avail += INCR_RULES;
12280 }
12281
12282 memset (rule_buf, 0, BLOCK_SIZE);
12283
12284 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12285
12286 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12287
12288 kernel_rules_cnt++;
12289 }
12290 }
12291 }
12292
12293 /**
12294 * generate NOP rules
12295 */
12296
12297 if (kernel_rules_cnt == 0)
12298 {
12299 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12300
12301 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12302
12303 kernel_rules_cnt++;
12304 }
12305
12306 data.kernel_rules_cnt = kernel_rules_cnt;
12307 data.kernel_rules_buf = kernel_rules_buf;
12308
12309 /**
12310 * platform
12311 */
12312
12313 cl_platform_id CL_platforms[CL_PLATFORMS_MAX];
12314
12315 uint CL_platforms_cnt = 0;
12316
12317 hc_clGetPlatformIDs (CL_PLATFORMS_MAX, CL_platforms, &CL_platforms_cnt);
12318
12319 if (CL_platforms_cnt == 0)
12320 {
12321 log_error ("ERROR: No OpenCL compatible platform found");
12322
12323 return (-1);
12324 }
12325
12326 int CL_platform_sel = 1;
12327
12328 if (opencl_platform != NULL)
12329 {
12330 CL_platform_sel = atoi (opencl_platform);
12331 }
12332
12333 if (CL_platforms_cnt > 1)
12334 {
12335 if (opencl_platform == NULL)
12336 {
12337 log_error ("ERROR: Too many OpenCL compatible platforms found");
12338
12339 log_info ("Please select a single platform using the --opencl-platform option");
12340 log_info ("");
12341 log_info ("Available OpenCL platforms:");
12342 log_info ("");
12343
12344 for (uint i = 0; i < CL_platforms_cnt; i++)
12345 {
12346 char CL_platform_vendor[INFOSZ];
12347
12348 memset (CL_platform_vendor, 0, sizeof (CL_platform_vendor));
12349
12350 hc_clGetPlatformInfo (CL_platforms[i], CL_PLATFORM_VENDOR, sizeof (CL_platform_vendor), CL_platform_vendor, NULL);
12351
12352 log_info ("* %d = %s", i + 1, CL_platform_vendor);
12353 }
12354
12355 log_info ("");
12356
12357 return (-1);
12358 }
12359 else
12360 {
12361 if (CL_platform_sel < 1)
12362 {
12363 log_error ("ERROR: --opencl-platform < 1");
12364
12365 return (-1);
12366 }
12367
12368 if (CL_platform_sel > (int) CL_platforms_cnt)
12369 {
12370 log_error ("ERROR: invalid OpenCL platforms selected");
12371
12372 return (-1);
12373 }
12374 }
12375 }
12376 else
12377 {
12378 if (CL_platform_sel != 1)
12379 {
12380 log_error ("ERROR: OpenCL platform number %d is not available", CL_platform_sel);
12381
12382 return (-1);
12383 }
12384 }
12385
12386 // zero-indexed: not starting to count at 1, as user does
12387
12388 CL_platform_sel -= 1;
12389
12390
12391 cl_platform_id CL_platform = CL_platforms[CL_platform_sel];
12392
12393 char CL_platform_vendor[INFOSZ];
12394
12395 memset (CL_platform_vendor, 0, sizeof (CL_platform_vendor));
12396
12397 hc_clGetPlatformInfo (CL_platform, CL_PLATFORM_VENDOR, sizeof (CL_platform_vendor), CL_platform_vendor, NULL);
12398
12399 cl_device_type device_type_filter;
12400
12401 uint vendor_id;
12402
12403 if (strcmp (CL_platform_vendor, CL_VENDOR_AMD) == 0)
12404 {
12405 vendor_id = VENDOR_ID_AMD;
12406
12407 device_type_filter = CL_DEVICE_TYPE_GPU;
12408 }
12409 else if (strcmp (CL_platform_vendor, CL_VENDOR_NV) == 0)
12410 {
12411 vendor_id = VENDOR_ID_NV;
12412
12413 device_type_filter = CL_DEVICE_TYPE_GPU;
12414
12415 // make sure that we do not directly control the fan for NVidia
12416
12417 gpu_temp_retain = 0;
12418
12419 data.gpu_temp_retain = gpu_temp_retain;
12420 }
12421 else if (strcmp (CL_platform_vendor, CL_VENDOR_POCL) == 0)
12422 {
12423 if (force == 0)
12424 {
12425 log_error ("");
12426 log_error ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12427 log_error ("You are STRONGLY encouraged not to use it");
12428 log_error ("You can use --force to override this but do not post error reports if you do so");
12429
12430 return (-1);
12431 }
12432
12433 vendor_id = VENDOR_ID_GENERIC;
12434
12435 device_type_filter = CL_DEVICE_TYPE_DEFAULT;
12436 }
12437 else
12438 {
12439 vendor_id = VENDOR_ID_GENERIC;
12440
12441 device_type_filter = CL_DEVICE_TYPE_DEFAULT;
12442 }
12443
12444 if (vendor_id == VENDOR_ID_GENERIC)
12445 {
12446 log_error ("Warning: unknown OpenCL vendor '%s' detected", CL_platform_vendor);
12447
12448 gpu_temp_disable = 1;
12449 }
12450
12451 data.vendor_id = vendor_id;
12452
12453 /**
12454 * cached kernel path depends on vendor_id which we don't know, so create it here
12455 */
12456
12457 int vendor_id_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 10 + 1;
12458
12459 char *vendor_id_folder = (char *) mymalloc (vendor_id_folder_size);
12460
12461 snprintf (vendor_id_folder, vendor_id_folder_size - 1, "%s/kernels", profile_dir);
12462
12463 mkdir (vendor_id_folder, 0700);
12464
12465 snprintf (vendor_id_folder, vendor_id_folder_size - 1, "%s/kernels/%d", profile_dir, vendor_id);
12466
12467 mkdir (vendor_id_folder, 0700);
12468
12469 myfree (vendor_id_folder);
12470
12471 /**
12472 * devices
12473 */
12474
12475 cl_device_id devices_all[DEVICES_MAX];
12476 cl_device_id devices[DEVICES_MAX];
12477
12478 uint devices_all_cnt = 0;
12479
12480 hc_clGetDeviceIDs (CL_platform, device_type_filter, DEVICES_MAX, devices_all, (uint *) &devices_all_cnt);
12481
12482 int hm_adapters_all = devices_all_cnt;
12483
12484 hm_attrs_t hm_adapter_all[DEVICES_MAX];
12485
12486 memset (hm_adapter_all, 0, sizeof (hm_adapter_all));
12487
12488 if (gpu_temp_disable == 0)
12489 {
12490 if (vendor_id == VENDOR_ID_NV)
12491 {
12492 #ifdef LINUX
12493 HM_LIB hm_dll = hm_init ();
12494
12495 data.hm_dll = hm_dll;
12496
12497 if (hc_NVML_nvmlInit (hm_dll) == NVML_SUCCESS)
12498 {
12499 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX];
12500
12501 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12502
12503 int tmp_out = 0;
12504
12505 for (int i = 0; i < tmp_in; i++)
12506 {
12507 hm_adapter_all[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12508 }
12509
12510 hm_adapters_all = tmp_out;
12511
12512 for (int i = 0; i < tmp_out; i++)
12513 {
12514 unsigned int speed;
12515
12516 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;
12517 }
12518 }
12519 #endif
12520
12521 #ifdef WIN
12522 if (NvAPI_Initialize () == NVAPI_OK)
12523 {
12524 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX];
12525
12526 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12527
12528 int tmp_out = 0;
12529
12530 for (int i = 0; i < tmp_in; i++)
12531 {
12532 hm_adapter_all[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12533 }
12534
12535 hm_adapters_all = tmp_out;
12536
12537 for (int i = 0; i < tmp_out; i++)
12538 {
12539 NvU32 speed;
12540
12541 if (NvAPI_GPU_GetTachReading (hm_adapter_all[i].adapter_index.nv, &speed) != NVAPI_NOT_SUPPORTED) hm_adapter_all[i].fan_supported = 1;
12542 }
12543 }
12544 #endif
12545 }
12546
12547 if (vendor_id == VENDOR_ID_AMD)
12548 {
12549 HM_LIB hm_dll = hm_init ();
12550
12551 data.hm_dll = hm_dll;
12552
12553 if (hc_ADL_Main_Control_Create (hm_dll, ADL_Main_Memory_Alloc, 0) == ADL_OK)
12554 {
12555 // total number of adapters
12556
12557 int hm_adapters_num;
12558
12559 if (get_adapters_num_amd (hm_dll, &hm_adapters_num) != 0) return (-1);
12560
12561 // adapter info
12562
12563 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (hm_dll, hm_adapters_num);
12564
12565 if (lpAdapterInfo == NULL) return (-1);
12566
12567 // get a list (of ids of) valid/usable adapters
12568
12569 int num_adl_adapters = 0;
12570
12571 uint32_t *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
12572
12573 if (num_adl_adapters > 0)
12574 {
12575 hc_thread_mutex_lock (mux_adl);
12576
12577 // hm_get_opencl_busid_devid (hm_adapter_all, devices_all_cnt, devices_all);
12578
12579 hm_get_adapter_index_amd (hm_adapter_all, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12580
12581 hm_get_overdrive_version (hm_dll, hm_adapter_all, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12582 hm_check_fanspeed_control (hm_dll, hm_adapter_all, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12583
12584 hc_thread_mutex_unlock (mux_adl);
12585 }
12586
12587 hm_adapters_all = num_adl_adapters;
12588
12589 myfree (valid_adl_device_list);
12590 myfree (lpAdapterInfo);
12591 }
12592 }
12593 }
12594
12595 if (hm_adapters_all == 0)
12596 {
12597 gpu_temp_disable = 1;
12598 }
12599
12600 if (gpu_temp_disable == 1)
12601 {
12602 gpu_temp_abort = 0;
12603 gpu_temp_retain = 0;
12604 }
12605
12606 /**
12607 * enable custom signal handler(s)
12608 */
12609
12610 if (benchmark == 0)
12611 {
12612 hc_signal (sigHandler_default);
12613 }
12614 else
12615 {
12616 hc_signal (sigHandler_benchmark);
12617 }
12618
12619 /**
12620 * devices mask and properties
12621 */
12622
12623 uint devices_cnt = 0;
12624
12625 for (uint device_all_id = 0; device_all_id < devices_all_cnt; device_all_id++)
12626 {
12627 if (opencl_devicemask)
12628 {
12629 uint device_all_id_mask = 1 << device_all_id;
12630
12631 if ((device_all_id_mask & opencl_devicemask) != device_all_id_mask)
12632 {
12633 if (quiet == 0 && algorithm_pos == 0) log_info ("Device #%d: skipped by user", device_all_id_mask + 1);
12634
12635 continue;
12636 }
12637 }
12638
12639 const uint device_id = devices_cnt;
12640
12641 devices[device_id] = devices_all[device_all_id];
12642
12643 memcpy (&data.hm_device[device_id], &hm_adapter_all[device_all_id], sizeof (hm_attrs_t));
12644
12645 char device_name[INFOSZ];
12646
12647 memset (device_name, 0, sizeof (device_name));
12648
12649 cl_ulong global_mem_size;
12650 cl_ulong max_mem_alloc_size;
12651 cl_uint max_clock_frequency;
12652 cl_uint max_compute_units;
12653
12654 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_NAME, sizeof (device_name), &device_name, NULL);
12655 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (global_mem_size), &global_mem_size, NULL);
12656 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (max_mem_alloc_size), &max_mem_alloc_size, NULL);
12657 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (max_clock_frequency), &max_clock_frequency, NULL);
12658 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (max_compute_units), &max_compute_units, NULL);
12659
12660 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12661 {
12662 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12663 device_all_id + 1,
12664 device_name,
12665 (unsigned int) (max_mem_alloc_size / 1024 / 1024),
12666 (unsigned int) (global_mem_size / 1024 / 1024),
12667 (unsigned int) (max_clock_frequency),
12668 (unsigned int) max_compute_units);
12669 }
12670
12671 devices_cnt++;
12672 }
12673
12674 if (devices_cnt == 0)
12675 {
12676 log_error ("ERROR: No devices left that matches your specification.");
12677
12678 return (-1);
12679 }
12680
12681 data.devices_cnt = devices_cnt;
12682
12683 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12684 {
12685 log_info ("");
12686 }
12687
12688 /**
12689 * inform the user
12690 */
12691
12692 // gpu temp sanity check
12693
12694 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
12695 {
12696 if (gpu_temp_abort < gpu_temp_retain)
12697 {
12698 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
12699
12700 return (-1);
12701 }
12702 }
12703
12704 data.gpu_temp_disable = gpu_temp_disable;
12705 data.gpu_temp_abort = gpu_temp_abort;
12706 data.gpu_temp_retain = gpu_temp_retain;
12707
12708 if (data.quiet == 0)
12709 {
12710 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
12711
12712 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);
12713
12714 if (attack_mode == ATTACK_MODE_STRAIGHT)
12715 {
12716 log_info ("Rules: %u", kernel_rules_cnt);
12717 }
12718
12719 if (opti_type)
12720 {
12721 log_info ("Applicable Optimizers:");
12722
12723 for (uint i = 0; i < 32; i++)
12724 {
12725 const uint opti_bit = 1 << i;
12726
12727 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
12728 }
12729 }
12730
12731 /**
12732 * Watchdog and Temperature balance
12733 */
12734
12735 if (gpu_temp_abort == 0)
12736 {
12737 log_info ("Watchdog: Temperature abort trigger disabled");
12738 }
12739 else
12740 {
12741 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
12742 }
12743
12744 if (gpu_temp_retain == 0)
12745 {
12746 log_info ("Watchdog: Temperature retain trigger disabled");
12747 }
12748 else
12749 {
12750 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
12751 }
12752 }
12753
12754 /**
12755 * devices init
12756 */
12757
12758 int *temp_retain_fanspeed_value = (int *) mycalloc (devices_cnt, sizeof (int));
12759
12760 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (devices_cnt, sizeof (ADLOD6MemClockState));
12761
12762 int *od_power_control_status = (int *) mycalloc (devices_cnt, sizeof (int));
12763
12764 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (devices_cnt, sizeof (hc_device_param_t));
12765
12766 data.devices_param = devices_param;
12767
12768 for (uint device_id = 0; device_id < devices_cnt; device_id++)
12769 {
12770 hc_device_param_t *device_param = &data.devices_param[device_id];
12771
12772 cl_device_id device = devices[device_id];
12773
12774 device_param->device = device;
12775
12776 cl_device_type device_type = 0;
12777
12778 hc_clGetDeviceInfo (device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12779
12780 device_param->device_type = device_type;
12781
12782 cl_uint max_compute_units = 0;
12783
12784 hc_clGetDeviceInfo (device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (max_compute_units), &max_compute_units, NULL);
12785
12786 device_param->device_processors = max_compute_units;
12787
12788 cl_ulong max_mem_alloc_size = 0;
12789
12790 hc_clGetDeviceInfo (device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (max_mem_alloc_size), &max_mem_alloc_size, NULL);
12791
12792 device_param->device_maxmem_alloc = max_mem_alloc_size;
12793
12794 char tmp[INFOSZ], t1[64];
12795
12796 memset (tmp, 0, sizeof (tmp));
12797
12798 hc_clGetDeviceInfo (device, CL_DEVICE_NAME, sizeof (tmp), &tmp, NULL);
12799
12800 device_param->device_name = mystrdup (tmp);
12801
12802 memset (tmp, 0, sizeof (tmp));
12803
12804 hc_clGetDeviceInfo (device, CL_DEVICE_VERSION, sizeof (tmp), &tmp, NULL);
12805
12806 memset (t1, 0, sizeof (t1));
12807
12808 sscanf (tmp, "%*16s %*16s %*16s (%[^)]16s)", t1);
12809
12810 device_param->device_version = mystrdup (t1);
12811
12812 memset (tmp, 0, sizeof (tmp));
12813
12814 hc_clGetDeviceInfo (device, CL_DRIVER_VERSION, sizeof (tmp), &tmp, NULL);
12815
12816 device_param->driver_version = mystrdup (tmp);
12817
12818 // create some filename that is easier to read on cached folder
12819
12820 snprintf (tmp, sizeof (tmp) - 1, "%s-%s-%s-%d", device_param->device_name, device_param->device_version, device_param->driver_version, COMPTIME);
12821
12822 uint device_name_digest[4];
12823
12824 device_name_digest[0] = 0;
12825 device_name_digest[1] = 0;
12826 device_name_digest[2] = 0;
12827 device_name_digest[3] = 0;
12828
12829 md5_64 ((uint *) tmp, device_name_digest);
12830
12831 sprintf (tmp, "%08x", device_name_digest[0]);
12832
12833 device_param->device_name_chksum = mystrdup (tmp);
12834
12835 if (device_type & CL_DEVICE_TYPE_CPU)
12836 {
12837 cl_uint device_processor_cores = 1;
12838
12839 device_param->device_processor_cores = device_processor_cores;
12840 }
12841
12842 if (device_type & CL_DEVICE_TYPE_GPU)
12843 {
12844 if (vendor_id == VENDOR_ID_AMD)
12845 {
12846 cl_uint device_processor_cores = 0;
12847
12848 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12849
12850 hc_clGetDeviceInfo (device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12851
12852 device_param->device_processor_cores = device_processor_cores;
12853 }
12854
12855 if (vendor_id == VENDOR_ID_NV)
12856 {
12857 cl_uint kernel_exec_timeout = 0;
12858
12859 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12860
12861 hc_clGetDeviceInfo (device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12862
12863 device_param->kernel_exec_timeout = kernel_exec_timeout;
12864
12865 cl_uint device_processor_cores = 0;
12866
12867 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12868
12869 hc_clGetDeviceInfo (device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12870
12871 device_param->device_processor_cores = device_processor_cores;
12872
12873 cl_uint sm_minor = 0;
12874 cl_uint sm_major = 0;
12875
12876 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12877 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12878
12879 hc_clGetDeviceInfo (device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12880 hc_clGetDeviceInfo (device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12881
12882 device_param->sm_minor = sm_minor;
12883 device_param->sm_major = sm_major;
12884 }
12885 }
12886
12887 /**
12888 * common driver check
12889 */
12890
12891 if (device_type & CL_DEVICE_TYPE_GPU)
12892 {
12893 if (vendor_id == VENDOR_ID_NV)
12894 {
12895 if (device_param->kernel_exec_timeout != 0)
12896 {
12897 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);
12898 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12899 }
12900 }
12901
12902 if (vendor_id == VENDOR_ID_AMD)
12903 {
12904 int catalyst_check = (force == 1) ? 0 : 1;
12905
12906 int catalyst_warn = 0;
12907
12908 int catalyst_broken = 0;
12909
12910 if (catalyst_check == 1)
12911 {
12912 catalyst_warn = 1;
12913
12914 // v14.9 and higher
12915 if ((atoi (device_param->device_version) >= 1573)
12916 && (atoi (device_param->driver_version) >= 1573))
12917 {
12918 catalyst_warn = 0;
12919 }
12920
12921 catalyst_check = 0;
12922 }
12923
12924 if (catalyst_broken == 1)
12925 {
12926 log_error ("");
12927 log_error ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12928 log_error ("It will pass over cracked hashes and does not report them as cracked");
12929 log_error ("You are STRONGLY encouraged not to use it");
12930 log_error ("You can use --force to override this but do not post error reports if you do so");
12931
12932 return (-1);
12933 }
12934
12935 if (catalyst_warn == 1)
12936 {
12937 log_error ("");
12938 log_error ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12939 log_error ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12940 log_error ("See oclHashcat's homepage for official supported catalyst drivers");
12941 #ifdef _WIN
12942 log_error ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12943 #endif
12944 log_error ("You can use --force to override this but do not post error reports if you do so");
12945
12946 return (-1);
12947 }
12948 }
12949 }
12950 }
12951
12952 /*
12953 * Temporary fix:
12954 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
12955 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
12956 * were not working @ full speed (setting hc_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
12957 * Driver / ADL bug?
12958 */
12959
12960 if (vendor_id == VENDOR_ID_AMD)
12961 {
12962 if (powertune_enable == 1)
12963 {
12964 hc_thread_mutex_lock (mux_adl);
12965
12966 for (uint i = 0; i < devices_cnt; i++)
12967 {
12968 if (data.hm_device[i].od_version == 6)
12969 {
12970 // set powertune value only
12971
12972 int powertune_supported = 0;
12973
12974 int ADL_rc = 0;
12975
12976 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll, data.hm_device[i].adapter_index.amd, &powertune_supported)) != ADL_OK)
12977 {
12978 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
12979
12980 return (-1);
12981 }
12982
12983 if (powertune_supported != 0)
12984 {
12985 // powertune set
12986 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
12987
12988 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll, data.hm_device[i].adapter_index.amd, &powertune)) != ADL_OK)
12989 {
12990 log_error ("ERROR: Failed to get current ADL PowerControl settings");
12991
12992 return (-1);
12993 }
12994
12995 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll, data.hm_device[i].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
12996 {
12997 log_error ("ERROR: Failed to set new ADL PowerControl values");
12998
12999 return (-1);
13000 }
13001 }
13002 }
13003 }
13004
13005 hc_thread_mutex_unlock (mux_adl);
13006 }
13007 }
13008
13009 uint kernel_blocks_all = 0;
13010
13011 for (uint device_id = 0; device_id < devices_cnt; device_id++)
13012 {
13013 /**
13014 * host buffer
13015 */
13016
13017 hc_device_param_t *device_param = &data.devices_param[device_id];
13018
13019 /**
13020 * device properties
13021 */
13022
13023 char *device_name_chksum = device_param->device_name_chksum;
13024
13025 uint device_processors = device_param->device_processors;
13026
13027 uint device_processor_cores = device_param->device_processor_cores;
13028
13029 cl_device_type device_type = device_param->device_type;
13030
13031 /**
13032 * create context for each device
13033 */
13034
13035 device_param->context = hc_clCreateContext (NULL, 1, &device_param->device, NULL, NULL);
13036
13037 /**
13038 * create command-queue
13039 */
13040
13041 // not support with NV
13042 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13043
13044 device_param->command_queue = hc_clCreateCommandQueue (device_param->context, device_param->device, 0);
13045
13046 /**
13047 * create input buffers on device
13048 */
13049
13050 uint kernel_threads = KERNEL_THREADS;
13051
13052 // bcrypt
13053 if (hash_mode == 3200) kernel_threads = 8;
13054 if (hash_mode == 9000) kernel_threads = 8;
13055
13056 if (device_type & CL_DEVICE_TYPE_CPU)
13057 {
13058 // CPU still need lots of workitems, don't know why...
13059 // for testing phase, lets start with this
13060
13061 kernel_accel = 1;
13062 }
13063
13064 uint kernel_power = device_processors * kernel_threads * kernel_accel;
13065 uint kernel_blocks = kernel_power;
13066
13067 device_param->kernel_threads = kernel_threads;
13068 device_param->kernel_power_user = kernel_power;
13069 device_param->kernel_blocks_user = kernel_blocks;
13070
13071 kernel_blocks_all += kernel_blocks;
13072
13073 uint size_pws = kernel_power * sizeof (pw_t);
13074
13075 uint size_tmps = 4;
13076
13077 switch (hash_mode)
13078 {
13079 case 400: size_tmps = kernel_blocks * sizeof (phpass_tmp_t); break;
13080 case 500: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13081 case 501: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13082 case 1600: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13083 case 1800: size_tmps = kernel_blocks * sizeof (sha512crypt_tmp_t); break;
13084 case 2100: size_tmps = kernel_blocks * sizeof (dcc2_tmp_t); break;
13085 case 2500: size_tmps = kernel_blocks * sizeof (wpa_tmp_t); break;
13086 case 3200: size_tmps = kernel_blocks * sizeof (bcrypt_tmp_t); break;
13087 case 5200: size_tmps = kernel_blocks * sizeof (pwsafe3_tmp_t); break;
13088 case 5800: size_tmps = kernel_blocks * sizeof (androidpin_tmp_t); break;
13089 case 6211:
13090 case 6212:
13091 case 6213: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13092 case 6221:
13093 case 6222:
13094 case 6223: size_tmps = kernel_blocks * sizeof (tc64_tmp_t); break;
13095 case 6231:
13096 case 6232:
13097 case 6233: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13098 case 6241:
13099 case 6242:
13100 case 6243: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13101 case 6300: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13102 case 6400: size_tmps = kernel_blocks * sizeof (sha256aix_tmp_t); break;
13103 case 6500: size_tmps = kernel_blocks * sizeof (sha512aix_tmp_t); break;
13104 case 6600: size_tmps = kernel_blocks * sizeof (agilekey_tmp_t); break;
13105 case 6700: size_tmps = kernel_blocks * sizeof (sha1aix_tmp_t); break;
13106 case 6800: size_tmps = kernel_blocks * sizeof (lastpass_tmp_t); break;
13107 case 7100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13108 case 7200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13109 case 7400: size_tmps = kernel_blocks * sizeof (sha256crypt_tmp_t); break;
13110 case 7900: size_tmps = kernel_blocks * sizeof (drupal7_tmp_t); break;
13111 case 8200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13112 case 8800: size_tmps = kernel_blocks * sizeof (androidfde_tmp_t); break;
13113 case 8900: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13114 case 9000: size_tmps = kernel_blocks * sizeof (pwsafe2_tmp_t); break;
13115 case 9100: size_tmps = kernel_blocks * sizeof (lotus8_tmp_t); break;
13116 case 9200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13117 case 9300: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13118 case 9400: size_tmps = kernel_blocks * sizeof (office2007_tmp_t); break;
13119 case 9500: size_tmps = kernel_blocks * sizeof (office2010_tmp_t); break;
13120 case 9600: size_tmps = kernel_blocks * sizeof (office2013_tmp_t); break;
13121 case 10000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13122 case 10200: size_tmps = kernel_blocks * sizeof (cram_md5_t); break;
13123 case 10300: size_tmps = kernel_blocks * sizeof (saph_sha1_tmp_t); break;
13124 case 10500: size_tmps = kernel_blocks * sizeof (pdf14_tmp_t); break;
13125 case 10700: size_tmps = kernel_blocks * sizeof (pdf17l8_tmp_t); break;
13126 case 10900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13127 case 11300: size_tmps = kernel_blocks * sizeof (bitcoin_wallet_tmp_t); break;
13128 case 11600: size_tmps = kernel_blocks * sizeof (seven_zip_tmp_t); break;
13129 case 11900: size_tmps = kernel_blocks * sizeof (pbkdf2_md5_tmp_t); break;
13130 case 12000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha1_tmp_t); break;
13131 case 12100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13132 case 12200: size_tmps = kernel_blocks * sizeof (ecryptfs_tmp_t); break;
13133 case 12300: size_tmps = kernel_blocks * sizeof (oraclet_tmp_t); break;
13134 case 12400: size_tmps = kernel_blocks * sizeof (bsdicrypt_tmp_t); break;
13135 case 12500: size_tmps = kernel_blocks * sizeof (rar3_tmp_t); break;
13136 case 12700: size_tmps = kernel_blocks * sizeof (mywallet_tmp_t); break;
13137 case 12800: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13138 case 12900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13139 case 13000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13140 };
13141
13142 uint size_hooks = 4;
13143
13144 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13145 {
13146 // insert correct hook size
13147 }
13148
13149 // we can optimize some stuff here...
13150
13151 device_param->size_pws = size_pws;
13152 device_param->size_tmps = size_tmps;
13153 device_param->size_hooks = size_hooks;
13154
13155 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13156 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13157
13158 device_param->size_root_css = size_root_css;
13159 device_param->size_markov_css = size_markov_css;
13160
13161 uint size_results = KERNEL_THREADS * sizeof (uint);
13162
13163 device_param->size_results = size_results;
13164
13165 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13166 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13167
13168 uint size_plains = digests_cnt * sizeof (plain_t);
13169 uint size_salts = salts_cnt * sizeof (salt_t);
13170 uint size_esalts = salts_cnt * esalt_size;
13171
13172 device_param->size_plains = size_plains;
13173 device_param->size_digests = size_digests;
13174 device_param->size_shown = size_shown;
13175 device_param->size_salts = size_salts;
13176
13177 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13178 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13179 uint size_tm = 32 * sizeof (bs_word_t);
13180
13181 uint64_t size_scryptV = 1;
13182
13183 if ((hash_mode == 8900) || (hash_mode == 9300))
13184 {
13185 uint tmto_start = 0;
13186 uint tmto_stop = 10;
13187
13188 if (scrypt_tmto)
13189 {
13190 tmto_start = scrypt_tmto;
13191 }
13192 else
13193 {
13194 // in case the user did not specify the tmto manually
13195 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13196 // but set the lower end only in case the user has a device with too less memory
13197
13198 if (hash_mode == 8900)
13199 {
13200 if (vendor_id == VENDOR_ID_AMD)
13201 {
13202 tmto_start = 1;
13203 }
13204 else if (vendor_id == VENDOR_ID_NV)
13205 {
13206 tmto_start = 3;
13207 }
13208 }
13209 else if (hash_mode == 9300)
13210 {
13211 if (vendor_id == VENDOR_ID_AMD)
13212 {
13213 tmto_start = 3;
13214 }
13215 else if (vendor_id == VENDOR_ID_NV)
13216 {
13217 tmto_start = 5;
13218 }
13219 }
13220 }
13221
13222 if (quiet == 0) log_info ("");
13223
13224 uint shader_per_mp = 1;
13225
13226 if (vendor_id == VENDOR_ID_AMD)
13227 {
13228 shader_per_mp = 8;
13229 }
13230
13231 if (vendor_id == VENDOR_ID_NV)
13232 {
13233 shader_per_mp = 32;
13234 }
13235
13236 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13237 {
13238 // TODO: in theory the following calculation needs to be done per salt, not global
13239 // we assume all hashes have the same scrypt settings
13240
13241 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13242
13243 size_scryptV /= 1 << tmto;
13244
13245 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13246
13247 if (size_scryptV > device_param->device_maxmem_alloc)
13248 {
13249 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13250
13251 continue;
13252 }
13253
13254 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13255 {
13256 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13257 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13258 }
13259
13260 break;
13261 }
13262
13263 if (data.salts_buf[0].scrypt_phy == 0)
13264 {
13265 log_error ("ERROR: can't allocate enough device memory");
13266
13267 return -1;
13268 }
13269
13270 if (quiet == 0) log_info ("");
13271 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13272 }
13273
13274 /**
13275 * default building options
13276 */
13277
13278 char build_opts[1024];
13279
13280 // we don't have sm_* on AMD but it doesn't matter
13281
13282 sprintf (build_opts, "-I%s/ -DVENDOR_ID=%d -DCUDA_ARCH=%d", shared_dir, vendor_id, (device_param->sm_major * 100) + device_param->sm_minor);
13283
13284 /**
13285 * a0 kernel, required for some fast hashes to make weak_hash_check work
13286 */
13287
13288 const uint add_flag = OPTS_TYPE_PT_ADD01
13289 | OPTS_TYPE_PT_ADD02
13290 | OPTS_TYPE_PT_ADD80
13291 | OPTS_TYPE_PT_ADDBITS14
13292 | OPTS_TYPE_PT_ADDBITS15
13293 | OPTS_TYPE_ST_ADD01
13294 | OPTS_TYPE_ST_ADD02
13295 | OPTS_TYPE_ST_ADD80
13296 | OPTS_TYPE_ST_ADDBITS14
13297 | OPTS_TYPE_ST_ADDBITS15;
13298
13299 if ((weak_hash_threshold) && (attack_exec == ATTACK_EXEC_INSIDE_KERNEL) && (opts_type & add_flag))
13300 {
13301 /**
13302 * kernel source filename
13303 */
13304
13305 char source_file[256];
13306
13307 memset (source_file, 0, sizeof (source_file));
13308
13309 generate_source_kernel_filename (attack_exec, ATTACK_KERN_STRAIGHT, kern_type, shared_dir, source_file);
13310
13311 struct stat sst;
13312
13313 if (stat (source_file, &sst) == -1)
13314 {
13315 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13316
13317 return -1;
13318 }
13319
13320 /**
13321 * kernel cached filename
13322 */
13323
13324 char cached_file[256];
13325
13326 memset (cached_file, 0, sizeof (cached_file));
13327
13328 generate_cached_kernel_filename (attack_exec, ATTACK_KERN_STRAIGHT, kern_type, profile_dir, device_name_chksum, vendor_id, cached_file);
13329
13330 int cached = 1;
13331
13332 struct stat cst;
13333
13334 if (stat (cached_file, &cst) == -1)
13335 {
13336 cached = 0;
13337 }
13338
13339 /**
13340 * kernel compile or load
13341 */
13342
13343 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13344
13345 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13346
13347 if (force_jit_compilation == 0)
13348 {
13349 if (cached == 0)
13350 {
13351 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13352
13353 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13354
13355 device_param->program_weak = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13356
13357 hc_clBuildProgram (device_param->program_weak, 1, &device_param->device, build_opts, NULL, NULL);
13358
13359 size_t binary_size;
13360
13361 clGetProgramInfo (device_param->program_weak, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13362
13363 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13364
13365 clGetProgramInfo (device_param->program_weak, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13366
13367 writeProgramBin (cached_file, binary, binary_size);
13368
13369 local_free (binary);
13370 }
13371 else
13372 {
13373 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13374
13375 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13376
13377 device_param->program_weak = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13378
13379 hc_clBuildProgram (device_param->program_weak, 1, &device_param->device, build_opts, NULL, NULL);
13380 }
13381 }
13382 else
13383 {
13384 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13385
13386 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13387
13388 device_param->program_weak = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13389
13390 if (force_jit_compilation == 1500)
13391 {
13392 sprintf (build_opts, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13393 }
13394 else if (force_jit_compilation == 8900)
13395 {
13396 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);
13397 }
13398
13399 hc_clBuildProgram (device_param->program_weak, 1, &device_param->device, build_opts, NULL, NULL);
13400 }
13401
13402 local_free (kernel_lengths);
13403 local_free (kernel_sources[0]);
13404 local_free (kernel_sources);
13405
13406 // this is mostly for debug
13407
13408 size_t ret_val_size = 0;
13409
13410 clGetProgramBuildInfo (device_param->program_weak, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13411
13412 if (ret_val_size > 2)
13413 {
13414 char *build_log = (char *) mymalloc (ret_val_size + 1);
13415
13416 memset (build_log, 0, ret_val_size + 1);
13417
13418 clGetProgramBuildInfo (device_param->program_weak, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13419
13420 puts (build_log);
13421
13422 myfree (build_log);
13423 }
13424 }
13425
13426 /**
13427 * main kernel
13428 */
13429
13430 {
13431 /**
13432 * kernel source filename
13433 */
13434
13435 char source_file[256];
13436
13437 memset (source_file, 0, sizeof (source_file));
13438
13439 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13440
13441 struct stat sst;
13442
13443 if (stat (source_file, &sst) == -1)
13444 {
13445 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13446
13447 return -1;
13448 }
13449
13450 /**
13451 * kernel cached filename
13452 */
13453
13454 char cached_file[256];
13455
13456 memset (cached_file, 0, sizeof (cached_file));
13457
13458 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, vendor_id, cached_file);
13459
13460 int cached = 1;
13461
13462 struct stat cst;
13463
13464 if (stat (cached_file, &cst) == -1)
13465 {
13466 cached = 0;
13467 }
13468
13469 /**
13470 * kernel compile or load
13471 */
13472
13473 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13474
13475 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13476
13477 if (force_jit_compilation == 0)
13478 {
13479 if (cached == 0)
13480 {
13481 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13482
13483 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13484
13485 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13486
13487 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13488
13489 size_t binary_size;
13490
13491 clGetProgramInfo (device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13492
13493 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13494
13495 clGetProgramInfo (device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13496
13497 writeProgramBin (cached_file, binary, binary_size);
13498
13499 local_free (binary);
13500 }
13501 else
13502 {
13503 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13504
13505 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13506
13507 device_param->program = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13508
13509 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13510 }
13511 }
13512 else
13513 {
13514 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13515
13516 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13517
13518 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13519
13520 if (force_jit_compilation == 1500)
13521 {
13522 sprintf (build_opts, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13523 }
13524 else if (force_jit_compilation == 8900)
13525 {
13526 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);
13527 }
13528
13529 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13530 }
13531
13532 local_free (kernel_lengths);
13533 local_free (kernel_sources[0]);
13534 local_free (kernel_sources);
13535
13536 // this is mostly for debug
13537
13538 size_t ret_val_size = 0;
13539
13540 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13541
13542 if (ret_val_size > 2)
13543 {
13544 char *build_log = (char *) mymalloc (ret_val_size + 1);
13545
13546 memset (build_log, 0, ret_val_size + 1);
13547
13548 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13549
13550 puts (build_log);
13551
13552 myfree (build_log);
13553 }
13554 }
13555
13556 /**
13557 * word generator kernel
13558 */
13559
13560 if (attack_mode != ATTACK_MODE_STRAIGHT)
13561 {
13562 /**
13563 * kernel mp source filename
13564 */
13565
13566 char source_file[256];
13567
13568 memset (source_file, 0, sizeof (source_file));
13569
13570 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
13571
13572 struct stat sst;
13573
13574 if (stat (source_file, &sst) == -1)
13575 {
13576 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13577
13578 return -1;
13579 }
13580
13581 /**
13582 * kernel mp cached filename
13583 */
13584
13585 char cached_file[256];
13586
13587 memset (cached_file, 0, sizeof (cached_file));
13588
13589 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, vendor_id, cached_file);
13590
13591 int cached = 1;
13592
13593 struct stat cst;
13594
13595 if (stat (cached_file, &cst) == -1)
13596 {
13597 cached = 0;
13598 }
13599
13600 /**
13601 * kernel compile or load
13602 */
13603
13604 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13605
13606 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13607
13608 if (cached == 0)
13609 {
13610 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13611
13612 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13613
13614 device_param->program_mp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13615
13616 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13617
13618 size_t binary_size;
13619
13620 clGetProgramInfo (device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13621
13622 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13623
13624 clGetProgramInfo (device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13625
13626 writeProgramBin (cached_file, binary, binary_size);
13627
13628 local_free (binary);
13629 }
13630 else
13631 {
13632 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13633
13634 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13635
13636 device_param->program_mp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13637
13638 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13639 }
13640
13641 local_free (kernel_lengths);
13642 local_free (kernel_sources[0]);
13643 local_free (kernel_sources);
13644
13645 // this is mostly for debug
13646
13647 size_t ret_val_size = 0;
13648
13649 clGetProgramBuildInfo (device_param->program_mp, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13650
13651 if (ret_val_size > 2)
13652 {
13653 char *build_log = (char *) mymalloc (ret_val_size + 1);
13654
13655 memset (build_log, 0, ret_val_size + 1);
13656
13657 clGetProgramBuildInfo (device_param->program_mp, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13658
13659 puts (build_log);
13660
13661 myfree (build_log);
13662 }
13663 }
13664
13665 /**
13666 * amplifier kernel
13667 */
13668
13669 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13670 {
13671
13672 }
13673 else
13674 {
13675 /**
13676 * kernel amp source filename
13677 */
13678
13679 char source_file[256];
13680
13681 memset (source_file, 0, sizeof (source_file));
13682
13683 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
13684
13685 struct stat sst;
13686
13687 if (stat (source_file, &sst) == -1)
13688 {
13689 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13690
13691 return -1;
13692 }
13693
13694 /**
13695 * kernel amp cached filename
13696 */
13697
13698 char cached_file[256];
13699
13700 memset (cached_file, 0, sizeof (cached_file));
13701
13702 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, vendor_id, cached_file);
13703
13704 int cached = 1;
13705
13706 struct stat cst;
13707
13708 if (stat (cached_file, &cst) == -1)
13709 {
13710 cached = 0;
13711 }
13712
13713 /**
13714 * kernel compile or load
13715 */
13716
13717 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13718
13719 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13720
13721 if (cached == 0)
13722 {
13723 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13724
13725 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13726
13727 device_param->program_amp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13728
13729 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13730
13731 size_t binary_size;
13732
13733 clGetProgramInfo (device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13734
13735 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13736
13737 clGetProgramInfo (device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13738
13739 writeProgramBin (cached_file, binary, binary_size);
13740
13741 local_free (binary);
13742 }
13743 else
13744 {
13745 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13746
13747 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13748
13749 device_param->program_amp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13750
13751 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13752 }
13753
13754 local_free (kernel_lengths);
13755 local_free (kernel_sources[0]);
13756 local_free (kernel_sources);
13757
13758 // this is mostly for debug
13759
13760 size_t ret_val_size = 0;
13761
13762 clGetProgramBuildInfo (device_param->program_amp, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13763
13764 if (ret_val_size > 2)
13765 {
13766 char *build_log = (char *) mymalloc (ret_val_size + 1);
13767
13768 memset (build_log, 0, ret_val_size + 1);
13769
13770 clGetProgramBuildInfo (device_param->program_amp, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13771
13772 puts (build_log);
13773
13774 myfree (build_log);
13775 }
13776 }
13777
13778 /**
13779 * global buffers
13780 */
13781
13782 device_param->d_pws_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13783 device_param->d_pws_amp_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13784 device_param->d_tmps = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
13785 device_param->d_hooks = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
13786 device_param->d_bitmap_s1_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13787 device_param->d_bitmap_s1_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13788 device_param->d_bitmap_s1_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13789 device_param->d_bitmap_s1_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13790 device_param->d_bitmap_s2_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13791 device_param->d_bitmap_s2_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13792 device_param->d_bitmap_s2_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13793 device_param->d_bitmap_s2_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13794 device_param->d_plain_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
13795 device_param->d_digests_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
13796 device_param->d_digests_shown = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
13797 device_param->d_salt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
13798 device_param->d_result = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
13799 device_param->d_scryptV_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
13800
13801 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_a, CL_TRUE, 0, bitmap_size, bitmap_s1_a, 0, NULL, NULL);
13802 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_b, CL_TRUE, 0, bitmap_size, bitmap_s1_b, 0, NULL, NULL);
13803 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_c, CL_TRUE, 0, bitmap_size, bitmap_s1_c, 0, NULL, NULL);
13804 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_d, CL_TRUE, 0, bitmap_size, bitmap_s1_d, 0, NULL, NULL);
13805 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_a, CL_TRUE, 0, bitmap_size, bitmap_s2_a, 0, NULL, NULL);
13806 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_b, CL_TRUE, 0, bitmap_size, bitmap_s2_b, 0, NULL, NULL);
13807 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_c, CL_TRUE, 0, bitmap_size, bitmap_s2_c, 0, NULL, NULL);
13808 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_d, CL_TRUE, 0, bitmap_size, bitmap_s2_d, 0, NULL, NULL);
13809 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
13810 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
13811 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
13812
13813 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
13814 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
13815 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
13816 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
13817 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
13818 run_kernel_bzero (device_param, device_param->d_result, size_results);
13819
13820 /**
13821 * special buffers
13822 */
13823
13824 if (attack_kern == ATTACK_KERN_STRAIGHT)
13825 {
13826 device_param->d_rules = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
13827 device_param->d_rules_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
13828
13829 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
13830
13831 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
13832 }
13833 else if (attack_kern == ATTACK_KERN_COMBI)
13834 {
13835 device_param->d_combs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13836 device_param->d_combs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13837 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13838 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13839
13840 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
13841 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
13842 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13843 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13844 }
13845 else if (attack_kern == ATTACK_KERN_BF)
13846 {
13847 device_param->d_bfs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13848 device_param->d_bfs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13849 device_param->d_tm_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
13850 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13851 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13852
13853 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
13854 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
13855 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
13856 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13857 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13858 }
13859
13860 if (size_esalts)
13861 {
13862 device_param->d_esalt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
13863
13864 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
13865 }
13866
13867 /**
13868 * main host data
13869 */
13870
13871 uint *result = (uint *) mymalloc (size_results);
13872
13873 memset (result, 0, size_results);
13874
13875 device_param->result = result;
13876
13877 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
13878
13879 memset (pws_buf, 0, size_pws);
13880
13881 device_param->pws_buf = pws_buf;
13882
13883 pw_cache_t *pw_caches = (pw_cache_t *) mycalloc (64, sizeof (pw_cache_t));
13884
13885 for (int i = 0; i < 64; i++)
13886 {
13887 pw_caches[i].pw_buf.pw_len = i;
13888 pw_caches[i].cnt = 0;
13889 }
13890
13891 device_param->pw_caches = pw_caches;
13892
13893 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
13894
13895 device_param->combs_buf = combs_buf;
13896
13897 void *hooks_buf = mymalloc (size_hooks);
13898
13899 device_param->hooks_buf = hooks_buf;
13900
13901 device_param->pw_transpose = pw_transpose_to_hi1;
13902 device_param->pw_add = pw_add_to_hc1;
13903
13904 /**
13905 * kernel args
13906 */
13907
13908 device_param->kernel_params_buf32[21] = bitmap_mask;
13909 device_param->kernel_params_buf32[22] = bitmap_shift1;
13910 device_param->kernel_params_buf32[23] = bitmap_shift2;
13911 device_param->kernel_params_buf32[24] = 0; // salt_pos
13912 device_param->kernel_params_buf32[25] = 0; // loop_pos
13913 device_param->kernel_params_buf32[26] = 0; // loop_cnt
13914 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
13915 device_param->kernel_params_buf32[28] = 0; // digests_cnt
13916 device_param->kernel_params_buf32[29] = 0; // digests_offset
13917 device_param->kernel_params_buf32[30] = 0; // combs_mode
13918 device_param->kernel_params_buf32[31] = 0; // gid_max
13919
13920 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13921 ? &device_param->d_pws_buf
13922 : &device_param->d_pws_amp_buf;
13923 device_param->kernel_params[ 1] = &device_param->d_rules_c;
13924 device_param->kernel_params[ 2] = &device_param->d_combs_c;
13925 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
13926 device_param->kernel_params[ 4] = &device_param->d_tmps;
13927 device_param->kernel_params[ 5] = &device_param->d_hooks;
13928 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
13929 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
13930 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
13931 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
13932 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
13933 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
13934 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
13935 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
13936 device_param->kernel_params[14] = &device_param->d_plain_bufs;
13937 device_param->kernel_params[15] = &device_param->d_digests_buf;
13938 device_param->kernel_params[16] = &device_param->d_digests_shown;
13939 device_param->kernel_params[17] = &device_param->d_salt_bufs;
13940 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
13941 device_param->kernel_params[19] = &device_param->d_result;
13942 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
13943 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
13944 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
13945 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
13946 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
13947 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
13948 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
13949 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
13950 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
13951 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
13952 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
13953 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
13954
13955 device_param->kernel_params_mp_buf64[3] = 0;
13956 device_param->kernel_params_mp_buf32[4] = 0;
13957 device_param->kernel_params_mp_buf32[5] = 0;
13958 device_param->kernel_params_mp_buf32[6] = 0;
13959 device_param->kernel_params_mp_buf32[7] = 0;
13960 device_param->kernel_params_mp_buf32[8] = 0;
13961
13962 device_param->kernel_params_mp[0] = NULL;
13963 device_param->kernel_params_mp[1] = NULL;
13964 device_param->kernel_params_mp[2] = NULL;
13965 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
13966 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
13967 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
13968 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
13969 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
13970 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
13971
13972 device_param->kernel_params_mp_l_buf64[3] = 0;
13973 device_param->kernel_params_mp_l_buf32[4] = 0;
13974 device_param->kernel_params_mp_l_buf32[5] = 0;
13975 device_param->kernel_params_mp_l_buf32[6] = 0;
13976 device_param->kernel_params_mp_l_buf32[7] = 0;
13977 device_param->kernel_params_mp_l_buf32[8] = 0;
13978 device_param->kernel_params_mp_l_buf32[9] = 0;
13979
13980 device_param->kernel_params_mp_l[0] = NULL;
13981 device_param->kernel_params_mp_l[1] = NULL;
13982 device_param->kernel_params_mp_l[2] = NULL;
13983 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
13984 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
13985 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
13986 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
13987 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
13988 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
13989 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
13990
13991 device_param->kernel_params_mp_r_buf64[3] = 0;
13992 device_param->kernel_params_mp_r_buf32[4] = 0;
13993 device_param->kernel_params_mp_r_buf32[5] = 0;
13994 device_param->kernel_params_mp_r_buf32[6] = 0;
13995 device_param->kernel_params_mp_r_buf32[7] = 0;
13996 device_param->kernel_params_mp_r_buf32[8] = 0;
13997
13998 device_param->kernel_params_mp_r[0] = NULL;
13999 device_param->kernel_params_mp_r[1] = NULL;
14000 device_param->kernel_params_mp_r[2] = NULL;
14001 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14002 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14003 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14004 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14005 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14006 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14007
14008 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14009 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14010
14011 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14012 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14013 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14014 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14015 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14016 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14017 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14018
14019 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
14020
14021 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14022 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14023
14024 /**
14025 * kernel name
14026 */
14027
14028 char kernel_name[64];
14029
14030 memset (kernel_name, 0, sizeof (kernel_name));
14031
14032 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14033 {
14034 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14035 {
14036 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14037
14038 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
14039
14040 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14041
14042 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
14043
14044 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14045
14046 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
14047 }
14048 else
14049 {
14050 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14051
14052 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
14053
14054 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14055
14056 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
14057
14058 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14059
14060 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
14061 }
14062
14063 if (weak_hash_threshold)
14064 {
14065 if (opts_type & add_flag)
14066 {
14067 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14068 {
14069 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14070
14071 device_param->kernel_weak = hc_clCreateKernel (device_param->program_weak, kernel_name);
14072 }
14073 else
14074 {
14075 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14076
14077 device_param->kernel_weak = hc_clCreateKernel (device_param->program_weak, kernel_name);
14078 }
14079 }
14080 else
14081 {
14082 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14083 {
14084 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14085
14086 device_param->kernel_weak = hc_clCreateKernel (device_param->program, kernel_name);
14087 }
14088 else
14089 {
14090 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14091
14092 device_param->kernel_weak = hc_clCreateKernel (device_param->program, kernel_name);
14093 }
14094 }
14095 }
14096
14097 if (data.attack_mode == ATTACK_MODE_BF)
14098 {
14099 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14100 {
14101 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
14102
14103 device_param->kernel_tb = hc_clCreateKernel (device_param->program, kernel_name);
14104
14105 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14106
14107 device_param->kernel_tm = hc_clCreateKernel (device_param->program, kernel_name);
14108 }
14109 }
14110 }
14111 else
14112 {
14113 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14114
14115 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
14116
14117 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14118
14119 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
14120
14121 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14122
14123 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
14124
14125 if (opts_type & OPTS_TYPE_HOOK12)
14126 {
14127 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14128
14129 device_param->kernel12 = hc_clCreateKernel (device_param->program, kernel_name);
14130 }
14131
14132 if (opts_type & OPTS_TYPE_HOOK23)
14133 {
14134 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14135
14136 device_param->kernel23 = hc_clCreateKernel (device_param->program, kernel_name);
14137 }
14138 }
14139
14140 for (uint i = 0; i <= 20; i++)
14141 {
14142 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14143 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14144 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14145
14146 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14147 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14148
14149 if (weak_hash_threshold)
14150 {
14151 hc_clSetKernelArg (device_param->kernel_weak, i, sizeof (cl_mem), device_param->kernel_params[i]);
14152 }
14153 }
14154
14155 for (uint i = 21; i <= 31; i++)
14156 {
14157 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14158 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14159 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14160
14161 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14162 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14163
14164 if (weak_hash_threshold)
14165 {
14166 hc_clSetKernelArg (device_param->kernel_weak, i, sizeof (cl_uint), device_param->kernel_params[i]);
14167 }
14168 }
14169
14170 if (attack_mode == ATTACK_MODE_BF)
14171 {
14172 device_param->kernel_mp_l = hc_clCreateKernel (device_param->program_mp, "l_markov");
14173 device_param->kernel_mp_r = hc_clCreateKernel (device_param->program_mp, "r_markov");
14174
14175 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14176 {
14177 hc_clSetKernelArg (device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
14178
14179 hc_clSetKernelArg (device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14180 hc_clSetKernelArg (device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14181 }
14182 }
14183 else if (attack_mode == ATTACK_MODE_HYBRID1)
14184 {
14185 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
14186 }
14187 else if (attack_mode == ATTACK_MODE_HYBRID2)
14188 {
14189 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
14190 }
14191
14192 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14193 {
14194 // nothing to do
14195 }
14196 else
14197 {
14198 device_param->kernel_amp = hc_clCreateKernel (device_param->program_amp, "amp");
14199 }
14200
14201 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14202 {
14203 // nothing to do
14204 }
14205 else
14206 {
14207 for (uint i = 0; i < 5; i++)
14208 {
14209 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14210 }
14211
14212 for (uint i = 5; i < 7; i++)
14213 {
14214 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14215 }
14216 }
14217
14218 /**
14219 * Store initial fanspeed if gpu_temp_retain is enabled
14220 */
14221
14222 int gpu_temp_retain_set = 0;
14223
14224 if (gpu_temp_disable == 0)
14225 {
14226 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14227 {
14228 hc_thread_mutex_lock (mux_adl);
14229
14230 if (data.hm_device[device_id].fan_supported == 1)
14231 {
14232 if (gpu_temp_retain_chgd == 0)
14233 {
14234 uint cur_temp = 0;
14235 uint default_temp = 0;
14236
14237 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);
14238
14239 if (ADL_rc == ADL_OK)
14240 {
14241 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14242
14243 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14244
14245 // special case with multi gpu setups: always use minimum retain
14246
14247 if (gpu_temp_retain_set == 0)
14248 {
14249 gpu_temp_retain = gpu_temp_retain_target;
14250 gpu_temp_retain_set = 1;
14251 }
14252 else
14253 {
14254 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14255 }
14256
14257 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14258 }
14259 }
14260
14261 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14262
14263 temp_retain_fanspeed_value[device_id] = fan_speed;
14264
14265 if (fan_speed == -1)
14266 {
14267 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14268
14269 temp_retain_fanspeed_value[device_id] = 0;
14270 }
14271 }
14272
14273 hc_thread_mutex_unlock (mux_adl);
14274 }
14275 }
14276
14277 /**
14278 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14279 */
14280
14281 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14282 {
14283 hc_thread_mutex_lock (mux_adl);
14284
14285 if (data.hm_device[device_id].od_version == 6)
14286 {
14287 int ADL_rc;
14288
14289 // check powertune capabilities first, if not available then skip device
14290
14291 int powertune_supported = 0;
14292
14293 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14294 {
14295 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14296
14297 return (-1);
14298 }
14299
14300 if (powertune_supported != 0)
14301 {
14302 // powercontrol settings
14303
14304 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14305
14306 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14307 {
14308 ADL_rc = hc_ADL_Overdrive_PowerControl_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14309 }
14310
14311 if (ADL_rc != ADL_OK)
14312 {
14313 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14314
14315 return (-1);
14316 }
14317
14318 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14319 {
14320 log_error ("ERROR: Failed to set new ADL PowerControl values");
14321
14322 return (-1);
14323 }
14324
14325 // clocks
14326
14327 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14328
14329 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14330
14331 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)
14332 {
14333 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14334
14335 return (-1);
14336 }
14337
14338 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14339
14340 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14341
14342 if ((ADL_rc = hc_ADL_Overdrive_Capabilities_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14343 {
14344 log_error ("ERROR: Failed to get ADL device capabilities");
14345
14346 return (-1);
14347 }
14348
14349 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14350 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14351
14352 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14353 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14354
14355 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14356 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14357
14358 // warning if profile has to low max values
14359
14360 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14361 {
14362 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14363 }
14364
14365 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14366 {
14367 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14368 }
14369
14370 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14371
14372 performance_state->iNumberOfPerformanceLevels = 2;
14373
14374 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14375 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14376 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14377 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14378
14379 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)
14380 {
14381 log_info ("ERROR: Failed to set ADL performance state");
14382
14383 return (-1);
14384 }
14385
14386 local_free (performance_state);
14387 }
14388 }
14389
14390 hc_thread_mutex_unlock (mux_adl);
14391 }
14392 }
14393
14394 data.kernel_blocks_all = kernel_blocks_all;
14395
14396 if (data.quiet == 0) log_info ("");
14397
14398 /**
14399 * Inform user which algorithm is checked and at which workload setting
14400 */
14401
14402 if (benchmark == 1)
14403 {
14404 quiet = 0;
14405
14406 data.quiet = quiet;
14407
14408 char *hash_type = strhashtype (data.hash_mode); // not a bug
14409
14410 log_info ("Hashtype: %s", hash_type);
14411 log_info ("Workload: %u loops, %u accel", kernel_loops, kernel_accel);
14412 log_info ("");
14413 }
14414
14415 /**
14416 * keep track of the progress
14417 */
14418
14419 data.words_progress_done = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
14420 data.words_progress_rejected = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
14421 data.words_progress_restored = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
14422
14423 /**
14424 * open filehandles
14425 */
14426
14427 #if _WIN
14428 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14429 {
14430 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14431
14432 return (-1);
14433 }
14434
14435 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14436 {
14437 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14438
14439 return (-1);
14440 }
14441
14442 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14443 {
14444 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14445
14446 return (-1);
14447 }
14448 #endif
14449
14450 /**
14451 * dictionary pad
14452 */
14453
14454 segment_size *= (1024 * 1024);
14455
14456 data.segment_size = segment_size;
14457
14458 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14459
14460 wl_data->buf = (char *) mymalloc (segment_size);
14461 wl_data->avail = segment_size;
14462 wl_data->incr = segment_size;
14463 wl_data->cnt = 0;
14464 wl_data->pos = 0;
14465
14466 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14467
14468 data.wordlist_mode = wordlist_mode;
14469
14470 cs_t *css_buf = NULL;
14471 uint css_cnt = 0;
14472 uint dictcnt = 0;
14473 uint maskcnt = 1;
14474 char **masks = NULL;
14475 char **dictfiles = NULL;
14476
14477 uint mask_from_file = 0;
14478
14479 if (attack_mode == ATTACK_MODE_STRAIGHT)
14480 {
14481 if (wordlist_mode == WL_MODE_FILE)
14482 {
14483 int wls_left = myargc - (optind + 1);
14484
14485 for (int i = 0; i < wls_left; i++)
14486 {
14487 char *l0_filename = myargv[optind + 1 + i];
14488
14489 struct stat l0_stat;
14490
14491 if (stat (l0_filename, &l0_stat) == -1)
14492 {
14493 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14494
14495 return (-1);
14496 }
14497
14498 uint is_dir = S_ISDIR (l0_stat.st_mode);
14499
14500 if (is_dir == 0)
14501 {
14502 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14503
14504 dictcnt++;
14505
14506 dictfiles[dictcnt - 1] = l0_filename;
14507 }
14508 else
14509 {
14510 // do not allow --keyspace w/ a directory
14511
14512 if (keyspace == 1)
14513 {
14514 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14515
14516 return (-1);
14517 }
14518
14519 char **dictionary_files = NULL;
14520
14521 dictionary_files = scan_directory (l0_filename);
14522
14523 if (dictionary_files != NULL)
14524 {
14525 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14526
14527 for (int d = 0; dictionary_files[d] != NULL; d++)
14528 {
14529 char *l1_filename = dictionary_files[d];
14530
14531 struct stat l1_stat;
14532
14533 if (stat (l1_filename, &l1_stat) == -1)
14534 {
14535 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14536
14537 return (-1);
14538 }
14539
14540 if (S_ISREG (l1_stat.st_mode))
14541 {
14542 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14543
14544 dictcnt++;
14545
14546 dictfiles[dictcnt - 1] = strdup (l1_filename);
14547 }
14548 }
14549 }
14550
14551 local_free (dictionary_files);
14552 }
14553 }
14554
14555 if (dictcnt < 1)
14556 {
14557 log_error ("ERROR: No usable dictionary file found.");
14558
14559 return (-1);
14560 }
14561 }
14562 else if (wordlist_mode == WL_MODE_STDIN)
14563 {
14564 dictcnt = 1;
14565 }
14566 }
14567 else if (attack_mode == ATTACK_MODE_COMBI)
14568 {
14569 // display
14570
14571 char *dictfile1 = myargv[optind + 1 + 0];
14572 char *dictfile2 = myargv[optind + 1 + 1];
14573
14574 // find the bigger dictionary and use as base
14575
14576 FILE *fp1;
14577 FILE *fp2;
14578
14579 struct stat tmp_stat;
14580
14581 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14582 {
14583 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14584
14585 return (-1);
14586 }
14587
14588 if (stat (dictfile1, &tmp_stat) == -1)
14589 {
14590 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14591
14592 fclose (fp1);
14593
14594 return (-1);
14595 }
14596
14597 if (S_ISDIR (tmp_stat.st_mode))
14598 {
14599 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14600
14601 fclose (fp1);
14602
14603 return (-1);
14604 }
14605
14606 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14607 {
14608 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14609
14610 fclose (fp1);
14611
14612 return (-1);
14613 }
14614
14615 if (stat (dictfile2, &tmp_stat) == -1)
14616 {
14617 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14618
14619 fclose (fp1);
14620 fclose (fp2);
14621
14622 return (-1);
14623 }
14624
14625 if (S_ISDIR (tmp_stat.st_mode))
14626 {
14627 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14628
14629 fclose (fp1);
14630 fclose (fp2);
14631
14632 return (-1);
14633 }
14634
14635 data.combs_cnt = 1;
14636
14637 data.quiet = 1;
14638
14639 const uint64_t words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14640
14641 data.quiet = quiet;
14642
14643 if (words1_cnt == 0)
14644 {
14645 log_error ("ERROR: %s: empty file", dictfile1);
14646
14647 fclose (fp1);
14648 fclose (fp2);
14649
14650 return (-1);
14651 }
14652
14653 data.combs_cnt = 1;
14654
14655 data.quiet = 1;
14656
14657 const uint64_t words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14658
14659 data.quiet = quiet;
14660
14661 if (words2_cnt == 0)
14662 {
14663 log_error ("ERROR: %s: empty file", dictfile2);
14664
14665 fclose (fp1);
14666 fclose (fp2);
14667
14668 return (-1);
14669 }
14670
14671 fclose (fp1);
14672 fclose (fp2);
14673
14674 data.dictfile = dictfile1;
14675 data.dictfile2 = dictfile2;
14676
14677 if (words1_cnt >= words2_cnt)
14678 {
14679 data.combs_cnt = words2_cnt;
14680 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14681
14682 dictfiles = &data.dictfile;
14683
14684 dictcnt = 1;
14685 }
14686 else
14687 {
14688 data.combs_cnt = words1_cnt;
14689 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14690
14691 dictfiles = &data.dictfile2;
14692
14693 dictcnt = 1;
14694
14695 // we also have to switch wordlist related rules!
14696
14697 char *tmpc = data.rule_buf_l;
14698
14699 data.rule_buf_l = data.rule_buf_r;
14700 data.rule_buf_r = tmpc;
14701
14702 int tmpi = data.rule_len_l;
14703
14704 data.rule_len_l = data.rule_len_r;
14705 data.rule_len_r = tmpi;
14706 }
14707 }
14708 else if (attack_mode == ATTACK_MODE_BF)
14709 {
14710 char *mask = NULL;
14711
14712 maskcnt = 0;
14713
14714 if (benchmark == 0)
14715 {
14716 mask = myargv[optind + 1];
14717
14718 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
14719
14720 if ((optind + 2) <= myargc)
14721 {
14722 struct stat file_stat;
14723
14724 if (stat (mask, &file_stat) == -1)
14725 {
14726 maskcnt = 1;
14727
14728 masks[maskcnt - 1] = mystrdup (mask);
14729 }
14730 else
14731 {
14732 int wls_left = myargc - (optind + 1);
14733
14734 uint masks_avail = INCR_MASKS;
14735
14736 for (int i = 0; i < wls_left; i++)
14737 {
14738 if (i != 0)
14739 {
14740 mask = myargv[optind + 1 + i];
14741
14742 if (stat (mask, &file_stat) == -1)
14743 {
14744 log_error ("ERROR: %s: %s", mask, strerror (errno));
14745
14746 return (-1);
14747 }
14748 }
14749
14750 uint is_file = S_ISREG (file_stat.st_mode);
14751
14752 if (is_file == 1)
14753 {
14754 FILE *mask_fp;
14755
14756 if ((mask_fp = fopen (mask, "r")) == NULL)
14757 {
14758 log_error ("ERROR: %s: %s", mask, strerror (errno));
14759
14760 return (-1);
14761 }
14762
14763 char line_buf[BUFSIZ];
14764
14765 while (!feof (mask_fp))
14766 {
14767 memset (line_buf, 0, BUFSIZ);
14768
14769 int line_len = fgetl (mask_fp, line_buf);
14770
14771 if (line_len == 0) continue;
14772
14773 if (line_buf[0] == '#') continue;
14774
14775 if (masks_avail == maskcnt)
14776 {
14777 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14778
14779 masks_avail += INCR_MASKS;
14780 }
14781
14782 masks[maskcnt] = mystrdup (line_buf);
14783
14784 maskcnt++;
14785 }
14786
14787 fclose (mask_fp);
14788 }
14789 else
14790 {
14791 log_error ("ERROR: %s: unsupported file-type", mask);
14792
14793 return (-1);
14794 }
14795 }
14796
14797 mask_from_file = 1;
14798 }
14799 }
14800 else
14801 {
14802 custom_charset_1 = (char *) "?l?d?u";
14803 custom_charset_2 = (char *) "?l?d";
14804 custom_charset_3 = (char *) "?l?d*!$@_";
14805
14806 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
14807 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
14808 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
14809
14810 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
14811
14812 wordlist_mode = WL_MODE_MASK;
14813
14814 data.wordlist_mode = wordlist_mode;
14815
14816 increment = 1;
14817
14818 maskcnt = 1;
14819 }
14820 }
14821 else
14822 {
14823 /**
14824 * generate full masks and charsets
14825 */
14826
14827 masks = (char **) mymalloc (sizeof (char *));
14828
14829 switch (hash_mode)
14830 {
14831 case 1731: pw_min = 5;
14832 pw_max = 5;
14833 mask = mystrdup ("?b?b?b?b?b");
14834 break;
14835 case 12500: pw_min = 5;
14836 pw_max = 5;
14837 mask = mystrdup ("?b?b?b?b?b");
14838 break;
14839 default: pw_min = 7;
14840 pw_max = 7;
14841 mask = mystrdup ("?b?b?b?b?b?b?b");
14842 break;
14843 }
14844
14845 maskcnt = 1;
14846
14847 masks[maskcnt - 1] = mystrdup (mask);
14848
14849 wordlist_mode = WL_MODE_MASK;
14850
14851 data.wordlist_mode = wordlist_mode;
14852
14853 increment = 1;
14854 }
14855
14856 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
14857
14858 if (increment)
14859 {
14860 if (increment_min > pw_min) pw_min = increment_min;
14861
14862 if (increment_max < pw_max) pw_max = increment_max;
14863 }
14864 }
14865 else if (attack_mode == ATTACK_MODE_HYBRID1)
14866 {
14867 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14868
14869 // display
14870
14871 char *mask = myargv[myargc - 1];
14872
14873 maskcnt = 0;
14874
14875 masks = (char **) mymalloc (1 * sizeof (char *));
14876
14877 // mod
14878
14879 struct stat file_stat;
14880
14881 if (stat (mask, &file_stat) == -1)
14882 {
14883 maskcnt = 1;
14884
14885 masks[maskcnt - 1] = mystrdup (mask);
14886 }
14887 else
14888 {
14889 uint is_file = S_ISREG (file_stat.st_mode);
14890
14891 if (is_file == 1)
14892 {
14893 FILE *mask_fp;
14894
14895 if ((mask_fp = fopen (mask, "r")) == NULL)
14896 {
14897 log_error ("ERROR: %s: %s", mask, strerror (errno));
14898
14899 return (-1);
14900 }
14901
14902 char line_buf[BUFSIZ];
14903
14904 uint masks_avail = 1;
14905
14906 while (!feof (mask_fp))
14907 {
14908 memset (line_buf, 0, BUFSIZ);
14909
14910 int line_len = fgetl (mask_fp, line_buf);
14911
14912 if (line_len == 0) continue;
14913
14914 if (line_buf[0] == '#') continue;
14915
14916 if (masks_avail == maskcnt)
14917 {
14918 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14919
14920 masks_avail += INCR_MASKS;
14921 }
14922
14923 masks[maskcnt] = mystrdup (line_buf);
14924
14925 maskcnt++;
14926 }
14927
14928 fclose (mask_fp);
14929
14930 mask_from_file = 1;
14931 }
14932 else
14933 {
14934 maskcnt = 1;
14935
14936 masks[maskcnt - 1] = mystrdup (mask);
14937 }
14938 }
14939
14940 // base
14941
14942 int wls_left = myargc - (optind + 2);
14943
14944 for (int i = 0; i < wls_left; i++)
14945 {
14946 char *filename = myargv[optind + 1 + i];
14947
14948 struct stat file_stat;
14949
14950 if (stat (filename, &file_stat) == -1)
14951 {
14952 log_error ("ERROR: %s: %s", filename, strerror (errno));
14953
14954 return (-1);
14955 }
14956
14957 uint is_dir = S_ISDIR (file_stat.st_mode);
14958
14959 if (is_dir == 0)
14960 {
14961 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14962
14963 dictcnt++;
14964
14965 dictfiles[dictcnt - 1] = filename;
14966 }
14967 else
14968 {
14969 // do not allow --keyspace w/ a directory
14970
14971 if (keyspace == 1)
14972 {
14973 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14974
14975 return (-1);
14976 }
14977
14978 char **dictionary_files = NULL;
14979
14980 dictionary_files = scan_directory (filename);
14981
14982 if (dictionary_files != NULL)
14983 {
14984 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14985
14986 for (int d = 0; dictionary_files[d] != NULL; d++)
14987 {
14988 char *l1_filename = dictionary_files[d];
14989
14990 struct stat l1_stat;
14991
14992 if (stat (l1_filename, &l1_stat) == -1)
14993 {
14994 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14995
14996 return (-1);
14997 }
14998
14999 if (S_ISREG (l1_stat.st_mode))
15000 {
15001 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15002
15003 dictcnt++;
15004
15005 dictfiles[dictcnt - 1] = strdup (l1_filename);
15006 }
15007 }
15008 }
15009
15010 local_free (dictionary_files);
15011 }
15012 }
15013
15014 if (dictcnt < 1)
15015 {
15016 log_error ("ERROR: No usable dictionary file found.");
15017
15018 return (-1);
15019 }
15020
15021 if (increment)
15022 {
15023 maskcnt = 0;
15024
15025 uint mask_min = increment_min; // we can't reject smaller masks here
15026 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15027
15028 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15029 {
15030 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15031
15032 if (cur_mask == NULL) break;
15033
15034 masks[maskcnt] = cur_mask;
15035
15036 maskcnt++;
15037
15038 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15039 }
15040 }
15041 }
15042 else if (attack_mode == ATTACK_MODE_HYBRID2)
15043 {
15044 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15045
15046 // display
15047
15048 char *mask = myargv[optind + 1 + 0];
15049
15050 maskcnt = 0;
15051
15052 masks = (char **) mymalloc (1 * sizeof (char *));
15053
15054 // mod
15055
15056 struct stat file_stat;
15057
15058 if (stat (mask, &file_stat) == -1)
15059 {
15060 maskcnt = 1;
15061
15062 masks[maskcnt - 1] = mystrdup (mask);
15063 }
15064 else
15065 {
15066 uint is_file = S_ISREG (file_stat.st_mode);
15067
15068 if (is_file == 1)
15069 {
15070 FILE *mask_fp;
15071
15072 if ((mask_fp = fopen (mask, "r")) == NULL)
15073 {
15074 log_error ("ERROR: %s: %s", mask, strerror (errno));
15075
15076 return (-1);
15077 }
15078
15079 char line_buf[BUFSIZ];
15080
15081 uint masks_avail = 1;
15082
15083 while (!feof (mask_fp))
15084 {
15085 memset (line_buf, 0, BUFSIZ);
15086
15087 int line_len = fgetl (mask_fp, line_buf);
15088
15089 if (line_len == 0) continue;
15090
15091 if (line_buf[0] == '#') continue;
15092
15093 if (masks_avail == maskcnt)
15094 {
15095 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15096
15097 masks_avail += INCR_MASKS;
15098 }
15099
15100 masks[maskcnt] = mystrdup (line_buf);
15101
15102 maskcnt++;
15103 }
15104
15105 fclose (mask_fp);
15106
15107 mask_from_file = 1;
15108 }
15109 else
15110 {
15111 maskcnt = 1;
15112
15113 masks[maskcnt - 1] = mystrdup (mask);
15114 }
15115 }
15116
15117 // base
15118
15119 int wls_left = myargc - (optind + 2);
15120
15121 for (int i = 0; i < wls_left; i++)
15122 {
15123 char *filename = myargv[optind + 2 + i];
15124
15125 struct stat file_stat;
15126
15127 if (stat (filename, &file_stat) == -1)
15128 {
15129 log_error ("ERROR: %s: %s", filename, strerror (errno));
15130
15131 return (-1);
15132 }
15133
15134 uint is_dir = S_ISDIR (file_stat.st_mode);
15135
15136 if (is_dir == 0)
15137 {
15138 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15139
15140 dictcnt++;
15141
15142 dictfiles[dictcnt - 1] = filename;
15143 }
15144 else
15145 {
15146 // do not allow --keyspace w/ a directory
15147
15148 if (keyspace == 1)
15149 {
15150 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15151
15152 return (-1);
15153 }
15154
15155 char **dictionary_files = NULL;
15156
15157 dictionary_files = scan_directory (filename);
15158
15159 if (dictionary_files != NULL)
15160 {
15161 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15162
15163 for (int d = 0; dictionary_files[d] != NULL; d++)
15164 {
15165 char *l1_filename = dictionary_files[d];
15166
15167 struct stat l1_stat;
15168
15169 if (stat (l1_filename, &l1_stat) == -1)
15170 {
15171 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15172
15173 return (-1);
15174 }
15175
15176 if (S_ISREG (l1_stat.st_mode))
15177 {
15178 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15179
15180 dictcnt++;
15181
15182 dictfiles[dictcnt - 1] = strdup (l1_filename);
15183 }
15184 }
15185 }
15186
15187 local_free (dictionary_files);
15188 }
15189 }
15190
15191 if (dictcnt < 1)
15192 {
15193 log_error ("ERROR: No usable dictionary file found.");
15194
15195 return (-1);
15196 }
15197
15198 if (increment)
15199 {
15200 maskcnt = 0;
15201
15202 uint mask_min = increment_min; // we can't reject smaller masks here
15203 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15204
15205 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15206 {
15207 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15208
15209 if (cur_mask == NULL) break;
15210
15211 masks[maskcnt] = cur_mask;
15212
15213 maskcnt++;
15214
15215 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15216 }
15217 }
15218 }
15219
15220 data.pw_min = pw_min;
15221 data.pw_max = pw_max;
15222
15223 /**
15224 * weak hash check
15225 */
15226
15227 if (weak_hash_threshold >= salts_cnt)
15228 {
15229 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15230
15231 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15232 {
15233 weak_hash_check (&data.devices_param[0], salt_pos, kernel_loops);
15234 }
15235 }
15236
15237 // Display hack, guarantee that there is at least one \r before real start
15238
15239 if (data.quiet == 0) log_info_nn ("");
15240
15241 /**
15242 * status and monitor threads
15243 */
15244
15245 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15246
15247 hc_thread_t i_thread = 0;
15248
15249 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15250 {
15251 hc_thread_create (i_thread, thread_keypress, &benchmark);
15252 }
15253
15254 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15255
15256 uint ni_threads_cnt = 0;
15257
15258 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15259
15260 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15261
15262 ni_threads_cnt++;
15263
15264 /**
15265 * Outfile remove
15266 */
15267
15268 if (keyspace == 0)
15269 {
15270 if (outfile_check_timer != 0)
15271 {
15272 if (data.outfile_check_directory != NULL)
15273 {
15274 if ((hash_mode != 5200) &&
15275 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15276 (hash_mode != 9000))
15277 {
15278 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15279
15280 ni_threads_cnt++;
15281 }
15282 else
15283 {
15284 outfile_check_timer = 0;
15285 }
15286 }
15287 else
15288 {
15289 outfile_check_timer = 0;
15290 }
15291 }
15292 }
15293
15294 /**
15295 * Inform the user if we got some hashes remove because of the pot file remove feature
15296 */
15297
15298 if (data.quiet == 0)
15299 {
15300 if (potfile_remove_cracks > 0)
15301 {
15302 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15303 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15304 }
15305 }
15306
15307 data.outfile_check_timer = outfile_check_timer;
15308
15309 /**
15310 * main loop
15311 */
15312
15313 char **induction_dictionaries = NULL;
15314
15315 int induction_dictionaries_cnt = 0;
15316
15317 hcstat_table_t *root_table_buf = NULL;
15318 hcstat_table_t *markov_table_buf = NULL;
15319
15320 uint initial_restore_done = 0;
15321
15322 data.maskcnt = maskcnt;
15323
15324 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15325 {
15326 if (data.devices_status == STATUS_CRACKED) break;
15327
15328 data.devices_status = STATUS_INIT;
15329
15330 if (maskpos > rd->maskpos)
15331 {
15332 rd->dictpos = 0;
15333 }
15334
15335 rd->maskpos = maskpos;
15336 data.maskpos = maskpos;
15337
15338 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15339 {
15340 char *mask = masks[maskpos];
15341
15342 if (mask_from_file == 1)
15343 {
15344 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15345
15346 char *str_ptr;
15347 uint str_pos;
15348
15349 uint mask_offset = 0;
15350
15351 uint separator_cnt;
15352
15353 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15354 {
15355 str_ptr = strstr (mask + mask_offset, ",");
15356
15357 if (str_ptr == NULL) break;
15358
15359 str_pos = str_ptr - mask;
15360
15361 // escaped separator, i.e. "\,"
15362
15363 if (str_pos > 0)
15364 {
15365 if (mask[str_pos - 1] == '\\')
15366 {
15367 separator_cnt --;
15368
15369 mask_offset = str_pos + 1;
15370
15371 continue;
15372 }
15373 }
15374
15375 // reset the offset
15376
15377 mask_offset = 0;
15378
15379 mask[str_pos] = '\0';
15380
15381 switch (separator_cnt)
15382 {
15383 case 0:
15384 mp_reset_usr (mp_usr, 0);
15385
15386 custom_charset_1 = mask;
15387 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15388 break;
15389
15390 case 1:
15391 mp_reset_usr (mp_usr, 1);
15392
15393 custom_charset_2 = mask;
15394 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15395 break;
15396
15397 case 2:
15398 mp_reset_usr (mp_usr, 2);
15399
15400 custom_charset_3 = mask;
15401 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15402 break;
15403
15404 case 3:
15405 mp_reset_usr (mp_usr, 3);
15406
15407 custom_charset_4 = mask;
15408 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15409 break;
15410 }
15411
15412 mask = mask + str_pos + 1;
15413 }
15414 }
15415
15416 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15417 {
15418 if (maskpos > 0)
15419 {
15420 local_free (css_buf);
15421 local_free (data.root_css_buf);
15422 local_free (data.markov_css_buf);
15423
15424 local_free (masks[maskpos - 1]);
15425 }
15426
15427 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15428
15429 data.mask = mask;
15430 data.css_cnt = css_cnt;
15431 data.css_buf = css_buf;
15432
15433 uint uniq_tbls[SP_PW_MAX][CHARSIZ];
15434
15435 memset (uniq_tbls, 0, sizeof (uniq_tbls));
15436
15437 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15438
15439 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15440 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15441
15442 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15443
15444 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15445
15446 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15447 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15448
15449 data.root_css_buf = root_css_buf;
15450 data.markov_css_buf = markov_css_buf;
15451
15452 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15453
15454 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15455
15456 local_free (root_table_buf);
15457 local_free (markov_table_buf);
15458
15459 // args
15460
15461 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15462 {
15463 hc_device_param_t *device_param = &data.devices_param[device_id];
15464
15465 device_param->kernel_params_mp[0] = &device_param->d_combs;
15466 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15467 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15468
15469 device_param->kernel_params_mp_buf64[3] = 0;
15470 device_param->kernel_params_mp_buf32[4] = css_cnt;
15471 device_param->kernel_params_mp_buf32[5] = 0;
15472 device_param->kernel_params_mp_buf32[6] = 0;
15473 device_param->kernel_params_mp_buf32[7] = 0;
15474
15475 if (attack_mode == ATTACK_MODE_HYBRID1)
15476 {
15477 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15478 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15479 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15480 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15481 }
15482 else if (attack_mode == ATTACK_MODE_HYBRID2)
15483 {
15484 device_param->kernel_params_mp_buf32[5] = 0;
15485 device_param->kernel_params_mp_buf32[6] = 0;
15486 device_param->kernel_params_mp_buf32[7] = 0;
15487 }
15488
15489 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp[i]);
15490 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp[i]);
15491 for (uint i = 4; i < 8; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp[i]);
15492
15493 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);
15494 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);
15495 }
15496 }
15497 else if (attack_mode == ATTACK_MODE_BF)
15498 {
15499 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15500
15501 if (increment)
15502 {
15503 for (uint i = 0; i < dictcnt; i++)
15504 {
15505 local_free (dictfiles[i]);
15506 }
15507
15508 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15509 {
15510 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15511
15512 if (l1_filename == NULL) break;
15513
15514 dictcnt++;
15515
15516 dictfiles[dictcnt - 1] = l1_filename;
15517 }
15518 }
15519 else
15520 {
15521 dictcnt++;
15522
15523 dictfiles[dictcnt - 1] = mask;
15524 }
15525
15526 if (dictcnt == 0)
15527 {
15528 log_error ("ERROR: Mask is too small");
15529
15530 return (-1);
15531 }
15532 }
15533 }
15534
15535 free (induction_dictionaries);
15536
15537 // induction_dictionaries_cnt = 0; // implied
15538
15539 if (attack_mode != ATTACK_MODE_BF)
15540 {
15541 if (keyspace == 0)
15542 {
15543 induction_dictionaries = scan_directory (induction_directory);
15544
15545 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15546 }
15547 }
15548
15549 if (induction_dictionaries_cnt)
15550 {
15551 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15552 }
15553
15554 /**
15555 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15556 */
15557 if (keyspace == 1)
15558 {
15559 if ((maskcnt > 1) || (dictcnt > 1))
15560 {
15561 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15562
15563 return (-1);
15564 }
15565 }
15566
15567 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15568 {
15569 char *subid = logfile_generate_subid ();
15570
15571 data.subid = subid;
15572
15573 logfile_sub_msg ("START");
15574
15575 data.devices_status = STATUS_INIT;
15576
15577 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (uint64_t));
15578 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (uint64_t));
15579 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (uint64_t));
15580
15581 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15582
15583 data.cpt_pos = 0;
15584
15585 data.cpt_start = time (NULL);
15586
15587 data.cpt_total = 0;
15588
15589 if (data.restore == 0)
15590 {
15591 rd->words_cur = skip;
15592
15593 skip = 0;
15594
15595 data.skip = 0;
15596 }
15597
15598 data.ms_paused = 0;
15599
15600 data.words_cur = rd->words_cur;
15601
15602 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15603 {
15604 hc_device_param_t *device_param = &data.devices_param[device_id];
15605
15606 device_param->speed_pos = 0;
15607
15608 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (uint64_t));
15609 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15610 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15611
15612 device_param->kernel_power = device_param->kernel_power_user;
15613 device_param->kernel_blocks = device_param->kernel_blocks_user;
15614
15615 device_param->outerloop_pos = 0;
15616 device_param->outerloop_left = 0;
15617 device_param->innerloop_pos = 0;
15618 device_param->innerloop_left = 0;
15619
15620 // some more resets:
15621
15622 memset (device_param->pw_caches, 0, 64 * sizeof (pw_cache_t));
15623
15624 memset (device_param->pws_buf, 0, device_param->size_pws);
15625
15626 device_param->pw_cnt = 0;
15627 device_param->pws_cnt = 0;
15628
15629 device_param->words_off = 0;
15630 device_param->words_done = 0;
15631 }
15632
15633 data.kernel_blocks_div = 0;
15634
15635 // figure out some workload
15636
15637 if (attack_mode == ATTACK_MODE_STRAIGHT)
15638 {
15639 if (data.wordlist_mode == WL_MODE_FILE)
15640 {
15641 char *dictfile = NULL;
15642
15643 if (induction_dictionaries_cnt)
15644 {
15645 dictfile = induction_dictionaries[0];
15646 }
15647 else
15648 {
15649 dictfile = dictfiles[dictpos];
15650 }
15651
15652 data.dictfile = dictfile;
15653
15654 logfile_sub_string (dictfile);
15655
15656 for (uint i = 0; i < rp_files_cnt; i++)
15657 {
15658 logfile_sub_var_string ("rulefile", rp_files[i]);
15659 }
15660
15661 FILE *fd2 = fopen (dictfile, "rb");
15662
15663 if (fd2 == NULL)
15664 {
15665 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15666
15667 return (-1);
15668 }
15669
15670 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15671
15672 fclose (fd2);
15673
15674 if (data.words_cnt == 0)
15675 {
15676 if (data.devices_status == STATUS_CRACKED) break;
15677 if (data.devices_status == STATUS_ABORTED) break;
15678
15679 dictpos++;
15680
15681 continue;
15682 }
15683 }
15684 }
15685 else if (attack_mode == ATTACK_MODE_COMBI)
15686 {
15687 char *dictfile = data.dictfile;
15688 char *dictfile2 = data.dictfile2;
15689
15690 logfile_sub_string (dictfile);
15691 logfile_sub_string (dictfile2);
15692
15693 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
15694 {
15695 FILE *fd2 = fopen (dictfile, "rb");
15696
15697 if (fd2 == NULL)
15698 {
15699 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15700
15701 return (-1);
15702 }
15703
15704 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15705
15706 fclose (fd2);
15707 }
15708 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
15709 {
15710 FILE *fd2 = fopen (dictfile2, "rb");
15711
15712 if (fd2 == NULL)
15713 {
15714 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15715
15716 return (-1);
15717 }
15718
15719 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
15720
15721 fclose (fd2);
15722 }
15723
15724 if (data.words_cnt == 0)
15725 {
15726 if (data.devices_status == STATUS_CRACKED) break;
15727 if (data.devices_status == STATUS_ABORTED) break;
15728
15729 dictpos++;
15730
15731 continue;
15732 }
15733 }
15734 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15735 {
15736 char *dictfile = NULL;
15737
15738 if (induction_dictionaries_cnt)
15739 {
15740 dictfile = induction_dictionaries[0];
15741 }
15742 else
15743 {
15744 dictfile = dictfiles[dictpos];
15745 }
15746
15747 data.dictfile = dictfile;
15748
15749 char *mask = data.mask;
15750
15751 logfile_sub_string (dictfile);
15752 logfile_sub_string (mask);
15753
15754 FILE *fd2 = fopen (dictfile, "rb");
15755
15756 if (fd2 == NULL)
15757 {
15758 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15759
15760 return (-1);
15761 }
15762
15763 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15764
15765 fclose (fd2);
15766
15767 if (data.words_cnt == 0)
15768 {
15769 if (data.devices_status == STATUS_CRACKED) break;
15770 if (data.devices_status == STATUS_ABORTED) break;
15771
15772 dictpos++;
15773
15774 continue;
15775 }
15776 }
15777 else if (attack_mode == ATTACK_MODE_BF)
15778 {
15779 local_free (css_buf);
15780 local_free (data.root_css_buf);
15781 local_free (data.markov_css_buf);
15782
15783 char *mask = dictfiles[dictpos];
15784
15785 logfile_sub_string (mask);
15786
15787 // base
15788
15789 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15790
15791 if (opts_type & OPTS_TYPE_PT_UNICODE)
15792 {
15793 uint css_cnt_unicode = css_cnt * 2;
15794
15795 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
15796
15797 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
15798 {
15799 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
15800
15801 css_buf_unicode[j + 1].cs_buf[0] = 0;
15802 css_buf_unicode[j + 1].cs_len = 1;
15803 }
15804
15805 free (css_buf);
15806
15807 css_buf = css_buf_unicode;
15808 css_cnt = css_cnt_unicode;
15809 }
15810
15811 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
15812
15813 uint mask_min = pw_min;
15814 uint mask_max = pw_max;
15815
15816 if (opts_type & OPTS_TYPE_PT_UNICODE)
15817 {
15818 mask_min *= 2;
15819 mask_max *= 2;
15820 }
15821
15822 if ((css_cnt < mask_min) || (css_cnt > mask_max))
15823 {
15824 if (css_cnt < mask_min)
15825 {
15826 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
15827 }
15828
15829 if (css_cnt > mask_max)
15830 {
15831 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
15832 }
15833
15834 // skip to next mask
15835
15836 dictpos++;
15837
15838 rd->dictpos = dictpos;
15839
15840 logfile_sub_msg ("STOP");
15841
15842 continue;
15843 }
15844
15845 uint save_css_cnt = css_cnt;
15846
15847 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15848 {
15849 if (opti_type & OPTI_TYPE_APPENDED_SALT)
15850 {
15851 uint salt_len = (uint) data.salts_buf[0].salt_len;
15852 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
15853
15854 uint css_cnt_salt = css_cnt + salt_len;
15855
15856 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
15857
15858 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
15859
15860 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
15861 {
15862 css_buf_salt[j].cs_buf[0] = salt_buf[i];
15863 css_buf_salt[j].cs_len = 1;
15864 }
15865
15866 free (css_buf);
15867
15868 css_buf = css_buf_salt;
15869 css_cnt = css_cnt_salt;
15870 }
15871 }
15872
15873 data.mask = mask;
15874 data.css_cnt = css_cnt;
15875 data.css_buf = css_buf;
15876
15877 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
15878
15879 uint uniq_tbls[SP_PW_MAX][CHARSIZ];
15880
15881 memset (uniq_tbls, 0, sizeof (uniq_tbls));
15882
15883 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15884
15885 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15886 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15887
15888 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15889
15890 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15891
15892 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15893 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15894
15895 data.root_css_buf = root_css_buf;
15896 data.markov_css_buf = markov_css_buf;
15897
15898 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15899
15900 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15901
15902 local_free (root_table_buf);
15903 local_free (markov_table_buf);
15904
15905 // copy + args
15906
15907 uint css_cnt_l = css_cnt;
15908 uint css_cnt_r;
15909
15910 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15911 {
15912 if (save_css_cnt < 6)
15913 {
15914 css_cnt_r = 1;
15915 }
15916 else if (save_css_cnt == 6)
15917 {
15918 css_cnt_r = 2;
15919 }
15920 else
15921 {
15922 if (opts_type & OPTS_TYPE_PT_UNICODE)
15923 {
15924 if (save_css_cnt == 8 || save_css_cnt == 10)
15925 {
15926 css_cnt_r = 2;
15927 }
15928 else
15929 {
15930 css_cnt_r = 4;
15931 }
15932 }
15933 else
15934 {
15935 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
15936 {
15937 css_cnt_r = 3;
15938 }
15939 else
15940 {
15941 css_cnt_r = 4;
15942 }
15943 }
15944 }
15945 }
15946 else
15947 {
15948 css_cnt_r = 1;
15949
15950 /* unfinished code?
15951 int sum = css_buf[css_cnt_r - 1].cs_len;
15952
15953 for (uint i = 1; i < 4 && i < css_cnt; i++)
15954 {
15955 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
15956
15957 css_cnt_r++;
15958
15959 sum *= css_buf[css_cnt_r - 1].cs_len;
15960 }
15961 */
15962 }
15963
15964 css_cnt_l -= css_cnt_r;
15965
15966 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
15967
15968 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15969 {
15970 hc_device_param_t *device_param = &data.devices_param[device_id];
15971
15972 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
15973 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
15974 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
15975
15976 device_param->kernel_params_mp_l_buf64[3] = 0;
15977 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
15978 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
15979 device_param->kernel_params_mp_l_buf32[6] = 0;
15980 device_param->kernel_params_mp_l_buf32[7] = 0;
15981 device_param->kernel_params_mp_l_buf32[8] = 0;
15982
15983 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
15984 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
15985 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
15986 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
15987
15988 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
15989 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
15990 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
15991
15992 device_param->kernel_params_mp_r_buf64[3] = 0;
15993 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
15994 device_param->kernel_params_mp_r_buf32[5] = 0;
15995 device_param->kernel_params_mp_r_buf32[6] = 0;
15996 device_param->kernel_params_mp_r_buf32[7] = 0;
15997
15998 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]);
15999 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]);
16000 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]);
16001
16002 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]);
16003 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]);
16004 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]);
16005
16006 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);
16007 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);
16008 }
16009 }
16010
16011 uint64_t words_base = data.words_cnt;
16012
16013 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16014 {
16015 if (data.kernel_rules_cnt)
16016 {
16017 words_base /= data.kernel_rules_cnt;
16018 }
16019 }
16020 else if (data.attack_kern == ATTACK_KERN_COMBI)
16021 {
16022 if (data.combs_cnt)
16023 {
16024 words_base /= data.combs_cnt;
16025 }
16026 }
16027 else if (data.attack_kern == ATTACK_KERN_BF)
16028 {
16029 if (data.bfs_cnt)
16030 {
16031 words_base /= data.bfs_cnt;
16032 }
16033 }
16034
16035 data.words_base = words_base;
16036
16037 if (keyspace == 1)
16038 {
16039 log_info ("%llu", (unsigned long long int) words_base);
16040
16041 return (0);
16042 }
16043
16044 if (data.words_cur > data.words_base)
16045 {
16046 log_error ("ERROR: restore value greater keyspace");
16047
16048 return (-1);
16049 }
16050
16051 if (data.words_cur)
16052 {
16053 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16054 {
16055 for (uint i = 0; i < data.salts_cnt; i++)
16056 {
16057 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16058 }
16059 }
16060 else if (data.attack_kern == ATTACK_KERN_COMBI)
16061 {
16062 for (uint i = 0; i < data.salts_cnt; i++)
16063 {
16064 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16065 }
16066 }
16067 else if (data.attack_kern == ATTACK_KERN_BF)
16068 {
16069 for (uint i = 0; i < data.salts_cnt; i++)
16070 {
16071 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16072 }
16073 }
16074 }
16075
16076 /*
16077 * Inform user about possible slow speeds
16078 */
16079
16080 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16081 {
16082 if (data.words_base < kernel_blocks_all)
16083 {
16084 if (quiet == 0)
16085 {
16086 log_info ("");
16087 log_info ("ATTENTION!");
16088 log_info (" The wordlist or mask you are using is too small.");
16089 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16090 log_info (" The cracking speed will drop.");
16091 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16092 log_info ("");
16093 }
16094 }
16095 }
16096
16097 /*
16098 * Update loopback file
16099 */
16100
16101 if (loopback == 1)
16102 {
16103 time_t now;
16104
16105 time (&now);
16106
16107 uint random_num = get_random_num (0, 9999);
16108
16109 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16110
16111 data.loopback_file = loopback_file;
16112 }
16113
16114 /*
16115 * Update dictionary statistic
16116 */
16117
16118 if (keyspace == 0)
16119 {
16120 dictstat_fp = fopen (dictstat, "wb");
16121
16122 if (dictstat_fp)
16123 {
16124 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16125
16126 fclose (dictstat_fp);
16127 }
16128 }
16129
16130 data.devices_status = STATUS_RUNNING;
16131
16132 if (initial_restore_done == 0)
16133 {
16134 if (data.restore_disable == 0) cycle_restore ();
16135
16136 initial_restore_done = 1;
16137 }
16138
16139 hc_timer_set (&data.timer_running);
16140
16141 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16142 {
16143 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16144 {
16145 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16146 if (quiet == 0) fflush (stdout);
16147 }
16148 }
16149 else if (wordlist_mode == WL_MODE_STDIN)
16150 {
16151 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16152 if (data.quiet == 0) log_info ("");
16153 }
16154
16155 time_t runtime_start;
16156
16157 time (&runtime_start);
16158
16159 data.runtime_start = runtime_start;
16160
16161 /**
16162 * create cracker threads
16163 */
16164
16165 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (devices_cnt, sizeof (hc_thread_t));
16166
16167 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16168 {
16169 hc_device_param_t *device_param = &devices_param[device_id];
16170
16171 device_param->device_id = device_id;
16172
16173 if (wordlist_mode == WL_MODE_STDIN)
16174 {
16175 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16176 }
16177 else
16178 {
16179 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16180 }
16181 }
16182
16183 // wait for crack threads to exit
16184
16185 hc_thread_wait (devices_cnt, c_threads);
16186
16187 local_free (c_threads);
16188
16189 data.restore = 0;
16190
16191 // finalize task
16192
16193 logfile_sub_var_uint ("status-after-work", data.devices_status);
16194
16195 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16196
16197 if (data.devices_status == STATUS_CRACKED) break;
16198 if (data.devices_status == STATUS_ABORTED) break;
16199
16200 if (data.devices_status == STATUS_BYPASS)
16201 {
16202 data.devices_status = STATUS_RUNNING;
16203 }
16204
16205 if (induction_dictionaries_cnt)
16206 {
16207 unlink (induction_dictionaries[0]);
16208 }
16209
16210 free (induction_dictionaries);
16211
16212 if (attack_mode != ATTACK_MODE_BF)
16213 {
16214 induction_dictionaries = scan_directory (induction_directory);
16215
16216 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16217 }
16218
16219 if (benchmark == 0)
16220 {
16221 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16222 {
16223 if (quiet == 0) clear_prompt ();
16224
16225 if (quiet == 0) log_info ("");
16226
16227 if (status == 1)
16228 {
16229 status_display ();
16230 }
16231 else
16232 {
16233 if (quiet == 0) status_display ();
16234 }
16235
16236 if (quiet == 0) log_info ("");
16237 }
16238 }
16239
16240 if (attack_mode == ATTACK_MODE_BF)
16241 {
16242 dictpos++;
16243
16244 rd->dictpos = dictpos;
16245 }
16246 else
16247 {
16248 if (induction_dictionaries_cnt)
16249 {
16250 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16251 }
16252 else
16253 {
16254 dictpos++;
16255
16256 rd->dictpos = dictpos;
16257 }
16258 }
16259
16260 time_t runtime_stop;
16261
16262 time (&runtime_stop);
16263
16264 data.runtime_stop = runtime_stop;
16265
16266 logfile_sub_uint (runtime_start);
16267 logfile_sub_uint (runtime_stop);
16268
16269 logfile_sub_msg ("STOP");
16270
16271 global_free (subid);
16272 }
16273
16274 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16275
16276 if (data.devices_status == STATUS_CRACKED) break;
16277 if (data.devices_status == STATUS_ABORTED) break;
16278 if (data.devices_status == STATUS_QUIT) break;
16279
16280 if (data.devices_status == STATUS_BYPASS)
16281 {
16282 data.devices_status = STATUS_RUNNING;
16283 }
16284 }
16285
16286 // 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
16287
16288 if (attack_mode == ATTACK_MODE_STRAIGHT)
16289 {
16290 if (data.wordlist_mode == WL_MODE_FILE)
16291 {
16292 if (data.dictfile == NULL)
16293 {
16294 if (dictfiles != NULL)
16295 {
16296 data.dictfile = dictfiles[0];
16297
16298 hc_timer_set (&data.timer_running);
16299 }
16300 }
16301 }
16302 }
16303 // NOTE: combi is okay because it is already set beforehand
16304 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16305 {
16306 if (data.dictfile == NULL)
16307 {
16308 if (dictfiles != NULL)
16309 {
16310 hc_timer_set (&data.timer_running);
16311
16312 data.dictfile = dictfiles[0];
16313 }
16314 }
16315 }
16316 else if (attack_mode == ATTACK_MODE_BF)
16317 {
16318 if (data.mask == NULL)
16319 {
16320 hc_timer_set (&data.timer_running);
16321
16322 data.mask = masks[0];
16323 }
16324 }
16325
16326 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16327 {
16328 data.devices_status = STATUS_EXHAUSTED;
16329 }
16330
16331 // if cracked / aborted remove last induction dictionary
16332
16333 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16334 {
16335 struct stat induct_stat;
16336
16337 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16338 {
16339 unlink (induction_dictionaries[file_pos]);
16340 }
16341 }
16342
16343 // wait for non-interactive threads
16344
16345 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16346 {
16347 hc_thread_wait (1, &ni_threads[thread_idx]);
16348 }
16349
16350 local_free (ni_threads);
16351
16352 // wait for interactive threads
16353
16354 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16355 {
16356 hc_thread_wait (1, &i_thread);
16357 }
16358
16359 // we dont need restore file anymore
16360 if (data.restore_disable == 0)
16361 {
16362 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16363 {
16364 unlink (eff_restore_file);
16365 unlink (new_restore_file);
16366 }
16367 else
16368 {
16369 cycle_restore ();
16370 }
16371 }
16372
16373 // finally save left hashes
16374
16375 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16376 {
16377 save_hash ();
16378 }
16379
16380 /**
16381 * Clean up
16382 */
16383
16384 if (benchmark == 1)
16385 {
16386 status_benchmark ();
16387
16388 log_info ("");
16389 }
16390 else
16391 {
16392 if (quiet == 0) clear_prompt ();
16393
16394 if (quiet == 0) log_info ("");
16395
16396 if (status == 1)
16397 {
16398 status_display ();
16399 }
16400 else
16401 {
16402 if (quiet == 0) status_display ();
16403 }
16404
16405 if (quiet == 0) log_info ("");
16406 }
16407
16408 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16409 {
16410 hc_device_param_t *device_param = &data.devices_param[device_id];
16411
16412 local_free (device_param->result);
16413
16414 local_free (device_param->pw_caches);
16415
16416 local_free (device_param->combs_buf);
16417
16418 local_free (device_param->hooks_buf);
16419
16420 local_free (device_param->device_name);
16421
16422 local_free (device_param->device_name_chksum);
16423
16424 local_free (device_param->device_version);
16425
16426 local_free (device_param->driver_version);
16427
16428 if (device_param->pws_buf) myfree (device_param->pws_buf);
16429 if (device_param->d_pws_buf) hc_clReleaseMemObject (device_param->d_pws_buf);
16430 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (device_param->d_pws_amp_buf);
16431 if (device_param->d_rules) hc_clReleaseMemObject (device_param->d_rules);
16432 if (device_param->d_rules_c) hc_clReleaseMemObject (device_param->d_rules_c);
16433 if (device_param->d_combs) hc_clReleaseMemObject (device_param->d_combs);
16434 if (device_param->d_combs_c) hc_clReleaseMemObject (device_param->d_combs_c);
16435 if (device_param->d_bfs) hc_clReleaseMemObject (device_param->d_bfs);
16436 if (device_param->d_bfs_c) hc_clReleaseMemObject (device_param->d_bfs_c);
16437 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (device_param->d_bitmap_s1_a);
16438 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (device_param->d_bitmap_s1_b);
16439 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (device_param->d_bitmap_s1_c);
16440 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (device_param->d_bitmap_s1_d);
16441 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (device_param->d_bitmap_s2_a);
16442 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (device_param->d_bitmap_s2_b);
16443 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (device_param->d_bitmap_s2_c);
16444 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (device_param->d_bitmap_s2_d);
16445 if (device_param->d_plain_bufs) hc_clReleaseMemObject (device_param->d_plain_bufs);
16446 if (device_param->d_digests_buf) hc_clReleaseMemObject (device_param->d_digests_buf);
16447 if (device_param->d_digests_shown) hc_clReleaseMemObject (device_param->d_digests_shown);
16448 if (device_param->d_salt_bufs) hc_clReleaseMemObject (device_param->d_salt_bufs);
16449 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (device_param->d_esalt_bufs);
16450 if (device_param->d_tmps) hc_clReleaseMemObject (device_param->d_tmps);
16451 if (device_param->d_hooks) hc_clReleaseMemObject (device_param->d_hooks);
16452 if (device_param->d_result) hc_clReleaseMemObject (device_param->d_result);
16453 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (device_param->d_scryptV_buf);
16454 if (device_param->d_root_css_buf) hc_clReleaseMemObject (device_param->d_root_css_buf);
16455 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (device_param->d_markov_css_buf);
16456 if (device_param->d_tm_c) hc_clReleaseMemObject (device_param->d_tm_c);
16457
16458 if (device_param->kernel1) hc_clReleaseKernel (device_param->kernel1);
16459 if (device_param->kernel12) hc_clReleaseKernel (device_param->kernel12);
16460 if (device_param->kernel2) hc_clReleaseKernel (device_param->kernel2);
16461 if (device_param->kernel23) hc_clReleaseKernel (device_param->kernel23);
16462 if (device_param->kernel3) hc_clReleaseKernel (device_param->kernel3);
16463 if (device_param->kernel_mp) hc_clReleaseKernel (device_param->kernel_mp);
16464 if (device_param->kernel_mp_l) hc_clReleaseKernel (device_param->kernel_mp_l);
16465 if (device_param->kernel_mp_r) hc_clReleaseKernel (device_param->kernel_mp_r);
16466 if (device_param->kernel_tb) hc_clReleaseKernel (device_param->kernel_tb);
16467 if (device_param->kernel_tm) hc_clReleaseKernel (device_param->kernel_tm);
16468 if (device_param->kernel_amp) hc_clReleaseKernel (device_param->kernel_amp);
16469
16470 if (device_param->program) hc_clReleaseProgram (device_param->program);
16471 if (device_param->program_mp) hc_clReleaseProgram (device_param->program_mp);
16472 if (device_param->program_amp) hc_clReleaseProgram (device_param->program_amp);
16473 if (device_param->command_queue) hc_clReleaseCommandQueue (device_param->command_queue);
16474 if (device_param->context) hc_clReleaseContext (device_param->context);
16475 }
16476
16477 // reset default fan speed
16478
16479 if (gpu_temp_disable == 0)
16480 {
16481 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16482 {
16483 hc_thread_mutex_lock (mux_adl);
16484
16485 for (uint i = 0; i < data.devices_cnt; i++)
16486 {
16487 if (data.hm_device[i].fan_supported == 1)
16488 {
16489 int fanspeed = temp_retain_fanspeed_value[i];
16490
16491 if (fanspeed == -1) continue;
16492
16493 int rc = hm_set_fanspeed_with_device_id_amd (i, fanspeed);
16494
16495 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", i);
16496 }
16497 }
16498
16499 hc_thread_mutex_unlock (mux_adl);
16500 }
16501 }
16502
16503 // reset power tuning
16504
16505 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16506 {
16507 hc_thread_mutex_lock (mux_adl);
16508
16509 for (uint i = 0; i < data.devices_cnt; i++)
16510 {
16511 if (data.hm_device[i].od_version == 6)
16512 {
16513 // check powertune capabilities first, if not available then skip device
16514
16515 int powertune_supported = 0;
16516
16517 if ((hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll, data.hm_device[i].adapter_index.amd, &powertune_supported)) != ADL_OK)
16518 {
16519 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16520
16521 return (-1);
16522 }
16523
16524 if (powertune_supported != 0)
16525 {
16526 // powercontrol settings
16527
16528 if ((hc_ADL_Overdrive_PowerControl_Set (data.hm_dll, data.hm_device[i].adapter_index.amd, od_power_control_status[i])) != ADL_OK)
16529 {
16530 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16531
16532 return (-1);
16533 }
16534
16535 // clocks
16536
16537 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16538
16539 performance_state->iNumberOfPerformanceLevels = 2;
16540
16541 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[i].state.aLevels[0].iEngineClock;
16542 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[i].state.aLevels[1].iEngineClock;
16543 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[i].state.aLevels[0].iMemoryClock;
16544 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[i].state.aLevels[1].iMemoryClock;
16545
16546 if ((hc_ADL_Overdrive_State_Set (data.hm_dll, data.hm_device[i].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
16547 {
16548 log_info ("ERROR: Failed to restore ADL performance state");
16549
16550 return (-1);
16551 }
16552
16553 local_free (performance_state);
16554 }
16555 }
16556 }
16557
16558 hc_thread_mutex_unlock (mux_adl);
16559 }
16560
16561 if (gpu_temp_disable == 0)
16562 {
16563 if (vendor_id == VENDOR_ID_NV)
16564 {
16565 #ifdef LINUX
16566 hc_NVML_nvmlShutdown (data.hm_dll);
16567 #endif
16568
16569 #ifdef WIN
16570 NvAPI_Unload ();
16571 #endif
16572 }
16573
16574 if (vendor_id == VENDOR_ID_AMD)
16575 {
16576 hc_ADL_Main_Control_Destroy (data.hm_dll);
16577
16578 hm_close (data.hm_dll);
16579 }
16580
16581 #ifdef LINUX
16582 if (vendor_id == VENDOR_ID_NV)
16583 {
16584 hm_close (data.hm_dll);
16585 }
16586 #endif
16587 }
16588
16589 // free memory
16590
16591 local_free (masks);
16592
16593 local_free (dictstat_base);
16594
16595 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16596 {
16597 pot_t *pot_ptr = &pot[pot_pos];
16598
16599 hash_t *hash = &pot_ptr->hash;
16600
16601 local_free (hash->digest);
16602
16603 if (isSalted)
16604 {
16605 local_free (hash->salt);
16606 }
16607 }
16608
16609 local_free (pot);
16610
16611 local_free (all_kernel_rules_cnt);
16612 local_free (all_kernel_rules_buf);
16613
16614 local_free (wl_data->buf);
16615 local_free (wl_data);
16616
16617 local_free (bitmap_s1_a);
16618 local_free (bitmap_s1_b);
16619 local_free (bitmap_s1_c);
16620 local_free (bitmap_s1_d);
16621 local_free (bitmap_s2_a);
16622 local_free (bitmap_s2_b);
16623 local_free (bitmap_s2_c);
16624 local_free (bitmap_s2_d);
16625
16626 local_free (temp_retain_fanspeed_value);
16627 local_free (od_clock_mem_status);
16628 local_free (od_power_control_status);
16629
16630 global_free (devices_param);
16631
16632 global_free (kernel_rules_buf);
16633
16634 global_free (root_css_buf);
16635 global_free (markov_css_buf);
16636
16637 global_free (digests_buf);
16638 global_free (digests_shown);
16639 global_free (digests_shown_tmp);
16640
16641 global_free (salts_buf);
16642 global_free (salts_shown);
16643
16644 global_free (esalts_buf);
16645
16646 global_free (words_progress_done);
16647 global_free (words_progress_rejected);
16648 global_free (words_progress_restored);
16649
16650 if (pot_fp) fclose (pot_fp);
16651
16652 if (data.devices_status == STATUS_QUIT) break;
16653 }
16654
16655 // destroy others mutex
16656
16657 hc_thread_mutex_delete (mux_dispatcher);
16658 hc_thread_mutex_delete (mux_counter);
16659 hc_thread_mutex_delete (mux_display);
16660 hc_thread_mutex_delete (mux_adl);
16661
16662 // free memory
16663
16664 local_free (eff_restore_file);
16665 local_free (new_restore_file);
16666
16667 local_free (rd);
16668
16669 // loopback
16670
16671 local_free (loopback_file);
16672
16673 if (loopback == 1) unlink (loopback_file);
16674
16675 // induction directory
16676
16677 if (induction_dir == NULL)
16678 {
16679 if (attack_mode != ATTACK_MODE_BF)
16680 {
16681 if (rmdir (induction_directory) == -1)
16682 {
16683 if (errno == ENOENT)
16684 {
16685 // good, we can ignore
16686 }
16687 else if (errno == ENOTEMPTY)
16688 {
16689 // good, we can ignore
16690 }
16691 else
16692 {
16693 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
16694
16695 return (-1);
16696 }
16697 }
16698
16699 local_free (induction_directory);
16700 }
16701 }
16702
16703 // outfile-check directory
16704
16705 if (outfile_check_dir == NULL)
16706 {
16707 if (rmdir (outfile_check_directory) == -1)
16708 {
16709 if (errno == ENOENT)
16710 {
16711 // good, we can ignore
16712 }
16713 else if (errno == ENOTEMPTY)
16714 {
16715 // good, we can ignore
16716 }
16717 else
16718 {
16719 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
16720
16721 return (-1);
16722 }
16723 }
16724
16725 local_free (outfile_check_directory);
16726 }
16727
16728 time_t proc_stop;
16729
16730 time (&proc_stop);
16731
16732 logfile_top_uint (proc_start);
16733 logfile_top_uint (proc_stop);
16734
16735 logfile_top_msg ("STOP");
16736
16737 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
16738 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
16739
16740 if (data.devices_status == STATUS_ABORTED) return 2;
16741 if (data.devices_status == STATUS_QUIT) return 2;
16742 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
16743 if (data.devices_status == STATUS_EXHAUSTED) return 1;
16744 if (data.devices_status == STATUS_CRACKED) return 0;
16745
16746 return -1;
16747 }
Hashcat additions to support pwdhash