projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
We need an esalt to hold the unused IV otherwise the unique salt count becomes incorr...
[hashcat.git] / src / oclHashcat.c
1 /**
2 * Author......: Jens Steube <jens.steube@gmail.com>
3 * License.....: MIT
4 */
5
6 #include <common.h>
7 #include <shared.h>
8 #include <rp_kernel_on_cpu.h>
9 #include <getopt.h>
10
11 const char *PROGNAME = "oclHashcat";
12 const char *VERSION_TXT = "2.10";
13 const uint VERSION_BIN = 210;
14 const uint RESTORE_MIN = 210;
15
16 #define INCR_RULES 10000
17 #define INCR_SALTS 100000
18 #define INCR_MASKS 1000
19 #define INCR_POT 1000
20
21 #define USAGE 0
22 #define VERSION 0
23 #define QUIET 0
24 #define MARKOV_THRESHOLD 0
25 #define MARKOV_DISABLE 0
26 #define MARKOV_CLASSIC 0
27 #define BENCHMARK 0
28 #define BENCHMARK_MODE 1
29 #define RESTORE 0
30 #define RESTORE_TIMER 60
31 #define RESTORE_DISABLE 0
32 #define STATUS 0
33 #define STATUS_TIMER 10
34 #define STATUS_AUTOMAT 0
35 #define LOOPBACK 0
36 #define WEAK_HASH_THRESHOLD 100
37 #define SHOW 0
38 #define LEFT 0
39 #define USERNAME 0
40 #define REMOVE 0
41 #define REMOVE_TIMER 60
42 #define SKIP 0
43 #define LIMIT 0
44 #define KEYSPACE 0
45 #define POTFILE_DISABLE 0
46 #define DEBUG_MODE 0
47 #define RP_GEN 0
48 #define RP_GEN_FUNC_MIN 1
49 #define RP_GEN_FUNC_MAX 4
50 #define RP_GEN_SEED 0
51 #define RULE_BUF_L ":"
52 #define RULE_BUF_R ":"
53 #define FORCE 0
54 #define RUNTIME 0
55 #define HEX_CHARSET 0
56 #define HEX_SALT 0
57 #define HEX_WORDLIST 0
58 #define OUTFILE_FORMAT 3
59 #define OUTFILE_AUTOHEX 1
60 #define OUTFILE_CHECK_TIMER 5
61 #define ATTACK_MODE 0
62 #define HASH_MODE 0
63 #define SEGMENT_SIZE 32
64 #define INCREMENT 0
65 #define INCREMENT_MIN 1
66 #define INCREMENT_MAX PW_MAX
67 #define SEPARATOR ':'
68 #define BITMAP_MIN 16
69 #define BITMAP_MAX 24
70 #define GPU_TEMP_DISABLE 0
71 #define GPU_TEMP_ABORT 90
72 #define GPU_TEMP_RETAIN 80
73 #define WORKLOAD_PROFILE 2
74 #define KERNEL_ACCEL 0
75 #define KERNEL_LOOPS 0
76 #define KERNEL_RULES 1024
77 #define KERNEL_COMBS 1024
78 #define KERNEL_BFS 1024
79 #define KERNEL_THREADS 64
80 #define POWERTUNE_ENABLE 0
81 #define LOGFILE_DISABLE 0
82 #define SCRYPT_TMTO 0
83
84 #define WL_MODE_STDIN 1
85 #define WL_MODE_FILE 2
86 #define WL_MODE_MASK 3
87
88 #define HL_MODE_FILE 4
89 #define HL_MODE_ARG 5
90
91 #define HLFMT_HASHCAT 0
92 #define HLFMT_PWDUMP 1
93 #define HLFMT_PASSWD 2
94 #define HLFMT_SHADOW 3
95 #define HLFMT_DCC 4
96 #define HLFMT_DCC2 5
97 #define HLFMT_NETNTLM1 7
98 #define HLFMT_NETNTLM2 8
99 #define HLFMT_NSLDAP 9
100 #define HLFMT_NSLDAPS 10
101 #define HLFMTS_CNT 11
102
103 #define ATTACK_MODE_STRAIGHT 0
104 #define ATTACK_MODE_COMBI 1
105 #define ATTACK_MODE_TOGGLE 2
106 #define ATTACK_MODE_BF 3
107 #define ATTACK_MODE_PERM 4
108 #define ATTACK_MODE_TABLE 5
109 #define ATTACK_MODE_HYBRID1 6
110 #define ATTACK_MODE_HYBRID2 7
111 #define ATTACK_MODE_NONE 100
112
113 #define ATTACK_KERN_STRAIGHT 0
114 #define ATTACK_KERN_COMBI 1
115 #define ATTACK_KERN_BF 3
116 #define ATTACK_KERN_NONE 100
117
118 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
119 #define ATTACK_EXEC_INSIDE_KERNEL 11
120
121 #define COMBINATOR_MODE_BASE_LEFT 10001
122 #define COMBINATOR_MODE_BASE_RIGHT 10002
123
124 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
125 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
126
127 #define MAX_CUT_TRIES 4
128
129 #define MAX_DICTSTAT 10000
130
131 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 130
132
133 #define global_free(attr) \
134 { \
135 myfree ((void *) data.attr); \
136 \
137 data.attr = NULL; \
138 }
139
140 #define local_free(attr) \
141 { \
142 myfree ((void *) attr); \
143 \
144 attr = NULL; \
145 }
146
147 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
148 {
149 900,
150 0,
151 5100,
152 100,
153 1400,
154 10800,
155 1700,
156 5000,
157 10100,
158 6000,
159 6100,
160 6900,
161 11700,
162 11800,
163 400,
164 8900,
165 11900,
166 12000,
167 10900,
168 12100,
169 23,
170 2500,
171 5300,
172 5400,
173 5500,
174 5600,
175 7300,
176 7500,
177 8300,
178 11100,
179 11200,
180 11400,
181 121,
182 2611,
183 2711,
184 2811,
185 8400,
186 11,
187 2612,
188 7900,
189 21,
190 11000,
191 124,
192 10000,
193 3711,
194 7600,
195 12,
196 131,
197 132,
198 1731,
199 200,
200 300,
201 3100,
202 112,
203 12300,
204 8000,
205 141,
206 1441,
207 1600,
208 12600,
209 1421,
210 101,
211 111,
212 1711,
213 3000,
214 1000,
215 1100,
216 2100,
217 12800,
218 1500,
219 12400,
220 500,
221 3200,
222 7400,
223 1800,
224 122,
225 1722,
226 7100,
227 6300,
228 6700,
229 6400,
230 6500,
231 2400,
232 2410,
233 5700,
234 9200,
235 9300,
236 22,
237 501,
238 5800,
239 8100,
240 8500,
241 7200,
242 9900,
243 7700,
244 7800,
245 10300,
246 8600,
247 8700,
248 9100,
249 133,
250 11600,
251 12500,
252 13000,
253 6211,
254 6221,
255 6231,
256 6241,
257 8800,
258 12900,
259 12200,
260 9700,
261 9710,
262 9800,
263 9810,
264 9400,
265 9500,
266 9600,
267 10400,
268 10410,
269 10500,
270 10600,
271 10700,
272 9000,
273 5200,
274 6800,
275 6600,
276 8200,
277 11300,
278 12700
279 };
280
281 /**
282 * types
283 */
284
285 static void (*get_next_word_func) (char *, uint32_t, uint32_t *, uint32_t *);
286
287 /**
288 * globals
289 */
290
291 static unsigned int full01 = 0x01010101;
292 static unsigned int full80 = 0x80808080;
293
294 int SUPPRESS_OUTPUT = 0;
295
296 hc_thread_mutex_t mux_adl;
297 hc_thread_mutex_t mux_counter;
298 hc_thread_mutex_t mux_dispatcher;
299 hc_thread_mutex_t mux_display;
300
301 hc_global_data_t data;
302
303 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
304
305 const char *USAGE_MINI[] =
306 {
307 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
308 "",
309 "Try --help for more help.",
310 NULL
311 };
312
313 const char *USAGE_BIG[] =
314 {
315 "%s, advanced password recovery",
316 "",
317 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
318 "",
319 "=======",
320 "Options",
321 "=======",
322 "",
323 "* General:",
324 "",
325 " -m, --hash-type=NUM Hash-type, see references below",
326 " -a, --attack-mode=NUM Attack-mode, see references below",
327 " -V, --version Print version",
328 " -h, --help Print help",
329 " --quiet Suppress output",
330 "",
331 "* Benchmark:",
332 "",
333 " -b, --benchmark Run benchmark",
334 " --benchmark-mode=NUM Benchmark-mode, see references below",
335 "",
336 "* Misc:",
337 "",
338 " --hex-charset Assume charset is given in hex",
339 " --hex-salt Assume salt is given in hex",
340 " --hex-wordlist Assume words in wordlist is given in hex",
341 " --force Ignore warnings",
342 " --status Enable automatic update of the status-screen",
343 " --status-timer=NUM Seconds between status-screen update",
344 " --status-automat Display the status view in a machine readable format",
345 " --loopback Add new plains to induct directory",
346 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
347 "",
348 "* Markov:",
349 "",
350 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
351 " --markov-disable Disables markov-chains, emulates classic brute-force",
352 " --markov-classic Enables classic markov-chains, no per-position enhancement",
353 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
354 "",
355 "* Session:",
356 "",
357 " --runtime=NUM Abort session after NUM seconds of runtime",
358 " --session=STR Define specific session name",
359 " --restore Restore session from --session",
360 " --restore-disable Do not write restore file",
361 "",
362 "* Files:",
363 "",
364 " -o, --outfile=FILE Define outfile for recovered hash",
365 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
366 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
367 " --outfile-check-timer=NUM Seconds between outfile checks",
368 " -p, --separator=CHAR Separator char for hashlists and outfile",
369 " --show Show cracked passwords only",
370 " --left Show un-cracked passwords only",
371 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
372 " --remove Enable remove of hash once it is cracked",
373 " --remove-timer=NUM Update input hash file each NUM seconds",
374 " --potfile-disable Do not write potfile",
375 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
376 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
377 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
378 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
379 " --logfile-disable Disable the logfile",
380 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
381 "",
382 "* Resources:",
383 "",
384 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
385 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
386 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
387 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
388 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
389 " --opencl-platform=NUM OpenCL platform to use, in case multiple platforms are present",
390 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
391 " -n, --kernel-accel=NUM Workload tuning: 1, 8, 40, 80, 160",
392 " -u, --kernel-loops=NUM Workload fine-tuning: 8 - 1024",
393 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
394 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
395 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
396 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
397 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
398 "",
399 "* Distributed:",
400 "",
401 " -s, --skip=NUM Skip number of words",
402 " -l, --limit=NUM Limit number of words",
403 " --keyspace Show keyspace base:mod values and quit",
404 "",
405 "* Rules:",
406 "",
407 " -j, --rule-left=RULE Single rule applied to each word from left dict",
408 " -k, --rule-right=RULE Single rule applied to each word from right dict",
409 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
410 " -g, --generate-rules=NUM Generate NUM random rules",
411 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
412 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
413 " --generate-rules-seed=NUM Force RNG seed to NUM",
414 "",
415 "* Custom charsets:",
416 "",
417 " -1, --custom-charset1=CS User-defined charsets",
418 " -2, --custom-charset2=CS Example:",
419 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
420 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
421 "",
422 "* Increment:",
423 "",
424 " -i, --increment Enable increment mode",
425 " --increment-min=NUM Start incrementing at NUM",
426 " --increment-max=NUM Stop incrementing at NUM",
427 "",
428 "==========",
429 "References",
430 "==========",
431 "",
432 "* Workload Profile:",
433 "",
434 " 1 = Reduced performance profile (low latency desktop)",
435 " 2 = Default performance profile",
436 " 3 = Tuned performance profile (high latency desktop)",
437 "",
438 "* Benchmark Settings:",
439 "",
440 " 0 = Manual Tuning",
441 " 1 = Performance Tuning, default",
442 "",
443 "* Outfile Formats:",
444 "",
445 " 1 = hash[:salt]",
446 " 2 = plain",
447 " 3 = hash[:salt]:plain",
448 " 4 = hex_plain",
449 " 5 = hash[:salt]:hex_plain",
450 " 6 = plain:hex_plain",
451 " 7 = hash[:salt]:plain:hex_plain",
452 " 8 = crackpos",
453 " 9 = hash[:salt]:crackpos",
454 " 10 = plain:crackpos",
455 " 11 = hash[:salt]:plain:crackpos",
456 " 12 = hex_plain:crackpos",
457 " 13 = hash[:salt]:hex_plain:crackpos",
458 " 14 = plain:hex_plain:crackpos",
459 " 15 = hash[:salt]:plain:hex_plain:crackpos",
460 "",
461 "* Debug mode output formats (for hybrid mode only, by using rules):",
462 "",
463 " 1 = save finding rule",
464 " 2 = save original word",
465 " 3 = save original word and finding rule",
466 " 4 = save original word, finding rule and modified plain",
467 "",
468 "* Built-in charsets:",
469 "",
470 " ?l = abcdefghijklmnopqrstuvwxyz",
471 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
472 " ?d = 0123456789",
473 " ?s = !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~",
474 " ?a = ?l?u?d?s",
475 " ?b = 0x00 - 0xff",
476 "",
477 "* Attack modes:",
478 "",
479 " 0 = Straight",
480 " 1 = Combination",
481 " 3 = Brute-force",
482 " 6 = Hybrid dict + mask",
483 " 7 = Hybrid mask + dict",
484 "",
485 "* Hash types:",
486 "",
487 "[[ Roll-your-own: Raw Hashes ]]",
488 "",
489 " 900 = MD4",
490 " 0 = MD5",
491 " 5100 = Half MD5",
492 " 100 = SHA1",
493 " 10800 = SHA-384",
494 " 1400 = SHA-256",
495 " 1700 = SHA-512",
496 " 5000 = SHA-3(Keccak)",
497 " 10100 = SipHash",
498 " 6000 = RipeMD160",
499 " 6100 = Whirlpool",
500 " 6900 = GOST R 34.11-94",
501 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
502 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
503 "",
504 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
505 "",
506 " 10 = md5($pass.$salt)",
507 " 20 = md5($salt.$pass)",
508 " 30 = md5(unicode($pass).$salt)",
509 " 40 = md5($salt.unicode($pass))",
510 " 3800 = md5($salt.$pass.$salt)",
511 " 3710 = md5($salt.md5($pass))",
512 " 2600 = md5(md5($pass)",
513 " 4300 = md5(strtoupper(md5($pass)))",
514 " 4400 = md5(sha1($pass))",
515 " 110 = sha1($pass.$salt)",
516 " 120 = sha1($salt.$pass)",
517 " 130 = sha1(unicode($pass).$salt)",
518 " 140 = sha1($salt.unicode($pass))",
519 " 4500 = sha1(sha1($pass)",
520 " 4700 = sha1(md5($pass))",
521 " 4900 = sha1($salt.$pass.$salt)",
522 " 1410 = sha256($pass.$salt)",
523 " 1420 = sha256($salt.$pass)",
524 " 1430 = sha256(unicode($pass).$salt)",
525 " 1440 = sha256($salt.unicode($pass))",
526 " 1710 = sha512($pass.$salt)",
527 " 1720 = sha512($salt.$pass)",
528 " 1730 = sha512(unicode($pass).$salt)",
529 " 1740 = sha512($salt.unicode($pass))",
530 "",
531 "[[ Roll-your-own: Authenticated Hashes ]]",
532 "",
533 " 50 = HMAC-MD5 (key = $pass)",
534 " 60 = HMAC-MD5 (key = $salt)",
535 " 150 = HMAC-SHA1 (key = $pass)",
536 " 160 = HMAC-SHA1 (key = $salt)",
537 " 1450 = HMAC-SHA256 (key = $pass)",
538 " 1460 = HMAC-SHA256 (key = $salt)",
539 " 1750 = HMAC-SHA512 (key = $pass)",
540 " 1760 = HMAC-SHA512 (key = $salt)",
541 "",
542 "[[ Generic KDF ]]",
543 "",
544 " 400 = phpass",
545 " 8900 = scrypt",
546 " 11900 = PBKDF2-HMAC-MD5",
547 " 12000 = PBKDF2-HMAC-SHA1",
548 " 10900 = PBKDF2-HMAC-SHA256",
549 " 12100 = PBKDF2-HMAC-SHA512",
550 "",
551 "[[ Network protocols, Challenge-Response ]]",
552 "",
553 " 23 = Skype",
554 " 2500 = WPA/WPA2",
555 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
556 " 5300 = IKE-PSK MD5",
557 " 5400 = IKE-PSK SHA1",
558 " 5500 = NetNTLMv1",
559 " 5500 = NetNTLMv1 + ESS",
560 " 5600 = NetNTLMv2",
561 " 7300 = IPMI2 RAKP HMAC-SHA1",
562 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
563 " 8300 = DNSSEC (NSEC3)",
564 " 10200 = Cram MD5",
565 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
566 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
567 " 11400 = SIP digest authentication (MD5)",
568 "",
569 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
570 "",
571 " 121 = SMF (Simple Machines Forum)",
572 " 400 = phpBB3",
573 " 2611 = vBulletin < v3.8.5",
574 " 2711 = vBulletin > v3.8.5",
575 " 2811 = MyBB",
576 " 2811 = IPB (Invison Power Board)",
577 " 8400 = WBB3 (Woltlab Burning Board)",
578 " 11 = Joomla < 2.5.18",
579 " 400 = Joomla > 2.5.18",
580 " 400 = Wordpress",
581 " 2612 = PHPS",
582 " 7900 = Drupal7",
583 " 21 = osCommerce",
584 " 21 = xt:Commerce",
585 " 11000 = PrestaShop",
586 " 124 = Django (SHA-1)",
587 " 10000 = Django (PBKDF2-SHA256)",
588 " 3711 = Mediawiki B type",
589 " 7600 = Redmine",
590 "",
591 "[[ Database Server ]]",
592 "",
593 " 12 = PostgreSQL",
594 " 131 = MSSQL(2000)",
595 " 132 = MSSQL(2005)",
596 " 1731 = MSSQL(2012)",
597 " 1731 = MSSQL(2014)",
598 " 200 = MySQL323",
599 " 300 = MySQL4.1/MySQL5",
600 " 3100 = Oracle H: Type (Oracle 7+)",
601 " 112 = Oracle S: Type (Oracle 11+)",
602 " 12300 = Oracle T: Type (Oracle 12+)",
603 " 8000 = Sybase ASE",
604 "",
605 "[[ HTTP, SMTP, LDAP Server ]]",
606 "",
607 " 141 = EPiServer 6.x < v4",
608 " 1441 = EPiServer 6.x > v4",
609 " 1600 = Apache $apr1$",
610 " 12600 = ColdFusion 10+",
611 " 1421 = hMailServer",
612 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
613 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
614 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
615 "",
616 "[[ Checksums ]]",
617 "",
618 " 11500 = CRC32",
619 "",
620 "[[ Operating-Systems ]]",
621 "",
622 " 3000 = LM",
623 " 1000 = NTLM",
624 " 1100 = Domain Cached Credentials (DCC), MS Cache",
625 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
626 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
627 " 1500 = descrypt, DES(Unix), Traditional DES",
628 " 12400 = BSDiCrypt, Extended DES",
629 " 500 = md5crypt $1$, MD5(Unix)",
630 " 3200 = bcrypt $2*$, Blowfish(Unix)",
631 " 7400 = sha256crypt $5$, SHA256(Unix)",
632 " 1800 = sha512crypt $6$, SHA512(Unix)",
633 " 122 = OSX v10.4",
634 " 122 = OSX v10.5",
635 " 122 = OSX v10.6",
636 " 1722 = OSX v10.7",
637 " 7100 = OSX v10.8",
638 " 7100 = OSX v10.9",
639 " 7100 = OSX v10.10",
640 " 6300 = AIX {smd5}",
641 " 6700 = AIX {ssha1}",
642 " 6400 = AIX {ssha256}",
643 " 6500 = AIX {ssha512}",
644 " 2400 = Cisco-PIX",
645 " 2410 = Cisco-ASA",
646 " 500 = Cisco-IOS $1$",
647 " 5700 = Cisco-IOS $4$",
648 " 9200 = Cisco-IOS $8$",
649 " 9300 = Cisco-IOS $9$",
650 " 22 = Juniper Netscreen/SSG (ScreenOS)",
651 " 501 = Juniper IVE",
652 " 5800 = Android PIN",
653 " 8100 = Citrix Netscaler",
654 " 8500 = RACF",
655 " 7200 = GRUB 2",
656 " 9900 = Radmin2",
657 "",
658 "[[ Enterprise Application Software (EAS) ]]",
659 "",
660 " 7700 = SAP CODVN B (BCODE)",
661 " 7800 = SAP CODVN F/G (PASSCODE)",
662 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
663 " 8600 = Lotus Notes/Domino 5",
664 " 8700 = Lotus Notes/Domino 6",
665 " 9100 = Lotus Notes/Domino 8",
666 " 133 = PeopleSoft",
667 "",
668 "[[ Archives ]]",
669 "",
670 " 11600 = 7-Zip",
671 " 12500 = RAR3-hp",
672 " 13000 = RAR5",
673 "",
674 "[[ Full-Disk encryptions (FDE) ]]",
675 "",
676 " 62XY = TrueCrypt 5.0+",
677 " X = 1 = PBKDF2-HMAC-RipeMD160",
678 " X = 2 = PBKDF2-HMAC-SHA512",
679 " X = 3 = PBKDF2-HMAC-Whirlpool",
680 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
681 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
682 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
683 " Y = 3 = XTS 1536 bit (Ciphers: All)",
684 " 8800 = Android FDE < v4.3",
685 " 12900 = Android FDE (Samsung DEK)",
686 " 12200 = eCryptfs",
687 "",
688 "[[ Documents ]]",
689 "",
690 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
691 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
692 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
693 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
694 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
695 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
696 " 9400 = MS Office 2007",
697 " 9500 = MS Office 2010",
698 " 9600 = MS Office 2013",
699 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
700 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
701 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
702 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
703 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
704 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
705 "",
706 "[[ Password Managers ]]",
707 "",
708 " 9000 = Password Safe v2",
709 " 5200 = Password Safe v3",
710 " 6800 = Lastpass",
711 " 6600 = 1Password, agilekeychain",
712 " 8200 = 1Password, cloudkeychain",
713 " 11300 = Bitcoin/Litecoin wallet.dat",
714 " 12700 = Blockchain, My Wallet",
715 "",
716 NULL
717 };
718
719 /**
720 * oclHashcat specific functions
721 */
722
723 void status_display_automat ()
724 {
725 FILE *out = stdout;
726
727 fprintf (out, "STATUS\t%u\t", data.devices_status);
728
729 /**
730 * speed new
731 */
732
733 fprintf (out, "SPEED\t");
734
735 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
736 {
737 hc_device_param_t *device_param = &data.devices_param[device_id];
738
739 uint64_t speed_cnt = 0;
740 float speed_ms = 0;
741
742 for (int i = 0; i < SPEED_CACHE; i++)
743 {
744 float rec_ms;
745
746 hc_timer_get (device_param->speed_rec[i], rec_ms);
747
748 if (rec_ms > SPEED_MAXAGE) continue;
749
750 speed_cnt += device_param->speed_cnt[i];
751 speed_ms += device_param->speed_ms[i];
752 }
753
754 speed_cnt /= SPEED_CACHE;
755 speed_ms /= SPEED_CACHE;
756
757 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
758 }
759
760 /**
761 * words_cur
762 */
763
764 uint64_t words_cur = get_lowest_words_done ();
765
766 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
767
768 /**
769 * counter
770 */
771
772 uint salts_left = data.salts_cnt - data.salts_done;
773
774 if (salts_left == 0) salts_left = 1;
775
776 uint64_t progress_total = data.words_cnt * salts_left;
777
778 uint64_t all_done = 0;
779 uint64_t all_rejected = 0;
780 uint64_t all_restored = 0;
781
782 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
783 {
784 if (salts_left > 1)
785 {
786 // otherwise the final cracked status shows 0/XXX progress
787
788 if (data.salts_shown[salt_pos] == 1) continue;
789 }
790
791 all_done += data.words_progress_done[salt_pos];
792 all_rejected += data.words_progress_rejected[salt_pos];
793 all_restored += data.words_progress_restored[salt_pos];
794 }
795
796 uint64_t progress_cur = all_restored + all_done + all_rejected;
797 uint64_t progress_end = progress_total;
798
799 uint64_t progress_skip = 0;
800
801 if (data.skip)
802 {
803 progress_skip = MIN (data.skip, data.words_base) * salts_left;
804
805 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
806 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
807 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
808 }
809
810 if (data.limit)
811 {
812 progress_end = MIN (data.limit, data.words_base) * salts_left;
813
814 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
815 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
816 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
817 }
818
819 uint64_t progress_cur_relative_skip = progress_cur - progress_skip;
820 uint64_t progress_end_relative_skip = progress_end - progress_skip;
821
822 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
823
824 /**
825 * cracks
826 */
827
828 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
829 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
830
831 /**
832 * temperature
833 */
834
835 if (data.gpu_temp_disable == 0)
836 {
837 fprintf (out, "TEMP\t");
838
839 hc_thread_mutex_lock (mux_adl);
840
841 for (uint i = 0; i < data.devices_cnt; i++)
842 {
843 int temp = hm_get_temperature_with_device_id (i);
844
845 fprintf (out, "%d\t", temp);
846 }
847
848 hc_thread_mutex_unlock (mux_adl);
849 }
850
851 #ifdef _WIN
852 fputc ('\r', out);
853 fputc ('\n', out);
854 #endif
855
856 #ifdef _POSIX
857 fputc ('\n', out);
858 #endif
859
860 fflush (out);
861 }
862
863 void status_display ()
864 {
865 if (data.devices_status == STATUS_INIT) return;
866 if (data.devices_status == STATUS_STARTING) return;
867 if (data.devices_status == STATUS_BYPASS) return;
868
869 if (data.status_automat == 1)
870 {
871 status_display_automat ();
872
873 return;
874 }
875
876 char tmp_buf[1000];
877
878 uint tmp_len = 0;
879
880 log_info ("Session.Name...: %s", data.session);
881
882 char *status_type = strstatus (data.devices_status);
883
884 uint hash_mode = data.hash_mode;
885
886 char *hash_type = strhashtype (hash_mode); // not a bug
887
888 log_info ("Status.........: %s", status_type);
889
890 /**
891 * show rules
892 */
893
894 if (data.rp_files_cnt)
895 {
896 uint i;
897
898 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
899 {
900 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
901 }
902
903 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
904
905 log_info ("Rules.Type.....: %s", tmp_buf);
906
907 tmp_len = 0;
908 }
909
910 if (data.rp_gen)
911 {
912 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
913
914 if (data.rp_gen_seed)
915 {
916 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
917 }
918 }
919
920 /**
921 * show input
922 */
923
924 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
925 {
926 if (data.wordlist_mode == WL_MODE_FILE)
927 {
928 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
929 }
930 else if (data.wordlist_mode == WL_MODE_STDIN)
931 {
932 log_info ("Input.Mode.....: Pipe");
933 }
934 }
935 else if (data.attack_mode == ATTACK_MODE_COMBI)
936 {
937 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
938 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
939 }
940 else if (data.attack_mode == ATTACK_MODE_BF)
941 {
942 char *mask = data.mask;
943
944 if (mask != NULL)
945 {
946 uint mask_len = data.css_cnt;
947
948 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
949
950 if (mask_len > 0)
951 {
952 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
953 {
954 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
955 {
956 mask_len -= data.salts_buf[0].salt_len;
957 }
958 }
959
960 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
961
962 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
963 }
964
965 if (data.maskcnt > 1)
966 {
967 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
968
969 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
970 }
971
972 log_info ("Input.Mode.....: %s", tmp_buf);
973 }
974
975 tmp_len = 0;
976 }
977 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
978 {
979 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
980 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
981 }
982 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
983 {
984 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
985 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
986 }
987
988 if (data.digests_cnt == 1)
989 {
990 if (data.hash_mode == 2500)
991 {
992 wpa_t *wpa = (wpa_t *) data.esalts_buf;
993
994 uint pke[25];
995
996 char *pke_ptr = (char *) pke;
997
998 for (uint i = 0; i < 25; i++)
999 {
1000 pke[i] = byte_swap_32 (wpa->pke[i]);
1001 }
1002
1003 char mac1[6];
1004 char mac2[6];
1005
1006 memcpy (mac1, pke_ptr + 23, 6);
1007 memcpy (mac2, pke_ptr + 29, 6);
1008
1009 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1010 (char *) data.salts_buf[0].salt_buf,
1011 mac1[0] & 0xff,
1012 mac1[1] & 0xff,
1013 mac1[2] & 0xff,
1014 mac1[3] & 0xff,
1015 mac1[4] & 0xff,
1016 mac1[5] & 0xff,
1017 mac2[0] & 0xff,
1018 mac2[1] & 0xff,
1019 mac2[2] & 0xff,
1020 mac2[3] & 0xff,
1021 mac2[4] & 0xff,
1022 mac2[5] & 0xff);
1023 }
1024 else if (data.hash_mode == 5200)
1025 {
1026 log_info ("Hash.Target....: File (%s)", data.hashfile);
1027 }
1028 else if (data.hash_mode == 9000)
1029 {
1030 log_info ("Hash.Target....: File (%s)", data.hashfile);
1031 }
1032 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1033 {
1034 log_info ("Hash.Target....: File (%s)", data.hashfile);
1035 }
1036 else
1037 {
1038 char out_buf[4096];
1039
1040 ascii_digest (out_buf, 0, 0);
1041
1042 // limit length
1043 if (strlen (out_buf) > 40)
1044 {
1045 out_buf[41] = '.';
1046 out_buf[42] = '.';
1047 out_buf[43] = '.';
1048 out_buf[44] = 0;
1049 }
1050
1051 log_info ("Hash.Target....: %s", out_buf);
1052 }
1053 }
1054 else
1055 {
1056 if (data.hash_mode == 3000)
1057 {
1058 char out_buf1[4096];
1059 char out_buf2[4096];
1060
1061 ascii_digest (out_buf1, 0, 0);
1062 ascii_digest (out_buf2, 0, 1);
1063
1064 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1065 }
1066 else
1067 {
1068 log_info ("Hash.Target....: File (%s)", data.hashfile);
1069 }
1070 }
1071
1072 log_info ("Hash.Type......: %s", hash_type);
1073
1074 /**
1075 * speed new
1076 */
1077
1078 uint64_t speed_cnt[DEVICES_MAX];
1079 float speed_ms[DEVICES_MAX];
1080
1081 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1082 {
1083 hc_device_param_t *device_param = &data.devices_param[device_id];
1084
1085 // we need to clear values (set to 0) because in case the device does
1086 // not get new candidates it idles around but speed display would
1087 // show it as working.
1088 // if we instantly set it to 0 after reading it happens that the
1089 // speed can be shown as zero if the users refreshs to fast.
1090 // therefore, we add a timestamp when a stat was recorded and if its
1091 // to old we will not use it
1092
1093 speed_cnt[device_id] = 0;
1094 speed_ms[device_id] = 0;
1095
1096 for (int i = 0; i < SPEED_CACHE; i++)
1097 {
1098 float rec_ms;
1099
1100 hc_timer_get (device_param->speed_rec[i], rec_ms);
1101
1102 if (rec_ms > SPEED_MAXAGE) continue;
1103
1104 speed_cnt[device_id] += device_param->speed_cnt[i];
1105 speed_ms[device_id] += device_param->speed_ms[i];
1106 }
1107
1108 speed_cnt[device_id] /= SPEED_CACHE;
1109 speed_ms[device_id] /= SPEED_CACHE;
1110 }
1111
1112 float hashes_all_ms = 0;
1113
1114 float hashes_dev_ms[DEVICES_MAX];
1115
1116 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1117 {
1118 hashes_dev_ms[device_id] = 0;
1119
1120 if (speed_ms[device_id])
1121 {
1122 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1123
1124 hashes_all_ms += hashes_dev_ms[device_id];
1125 }
1126 }
1127
1128 /**
1129 * timers
1130 */
1131
1132 float ms_running = 0;
1133
1134 hc_timer_get (data.timer_running, ms_running);
1135
1136 float ms_paused = data.ms_paused;
1137
1138 if (data.devices_status == STATUS_PAUSED)
1139 {
1140 float ms_paused_tmp = 0;
1141
1142 hc_timer_get (data.timer_paused, ms_paused_tmp);
1143
1144 ms_paused += ms_paused_tmp;
1145 }
1146
1147 #ifdef WIN
1148
1149 __time64_t sec_run = ms_running / 1000;
1150
1151 #else
1152
1153 time_t sec_run = ms_running / 1000;
1154
1155 #endif
1156
1157 if (sec_run)
1158 {
1159 char display_run[32];
1160
1161 struct tm tm_run;
1162
1163 struct tm *tmp;
1164
1165 #ifdef WIN
1166
1167 tmp = _gmtime64 (&sec_run);
1168
1169 #else
1170
1171 tmp = gmtime (&sec_run);
1172
1173 #endif
1174
1175 if (tmp != NULL)
1176 {
1177 memcpy (&tm_run, tmp, sizeof (struct tm));
1178
1179 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1180
1181 char *start = ctime (&data.proc_start);
1182
1183 size_t start_len = strlen (start);
1184
1185 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1186 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1187
1188 log_info ("Time.Started...: %s (%s)", start, display_run);
1189 }
1190 }
1191 else
1192 {
1193 log_info ("Time.Started...: 0 secs");
1194 }
1195
1196 /**
1197 * counters
1198 */
1199
1200 uint salts_left = data.salts_cnt - data.salts_done;
1201
1202 if (salts_left == 0) salts_left = 1;
1203
1204 uint64_t progress_total = data.words_cnt * salts_left;
1205
1206 uint64_t all_done = 0;
1207 uint64_t all_rejected = 0;
1208 uint64_t all_restored = 0;
1209
1210 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1211 {
1212 if (salts_left > 1)
1213 {
1214 // otherwise the final cracked status shows 0/XXX progress
1215
1216 if (data.salts_shown[salt_pos] == 1) continue;
1217 }
1218
1219 all_done += data.words_progress_done[salt_pos];
1220 all_rejected += data.words_progress_rejected[salt_pos];
1221 all_restored += data.words_progress_restored[salt_pos];
1222 }
1223
1224 uint64_t progress_cur = all_restored + all_done + all_rejected;
1225 uint64_t progress_end = progress_total;
1226
1227 uint64_t progress_skip = 0;
1228
1229 if (data.skip)
1230 {
1231 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1232
1233 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1234 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1235 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1236 }
1237
1238 if (data.limit)
1239 {
1240 progress_end = MIN (data.limit, data.words_base) * salts_left;
1241
1242 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1243 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1244 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1245 }
1246
1247 uint64_t progress_cur_relative_skip = progress_cur - progress_skip;
1248 uint64_t progress_end_relative_skip = progress_end - progress_skip;
1249
1250 float speed_ms_real = ms_running - ms_paused;
1251 uint64_t speed_plains_real = all_done;
1252
1253 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1254 {
1255 if (data.devices_status != STATUS_CRACKED)
1256 {
1257 uint64_t words_per_ms = 0;
1258
1259 if (speed_plains_real && speed_ms_real)
1260 {
1261 words_per_ms = speed_plains_real / speed_ms_real;
1262 }
1263
1264 #ifdef WIN
1265 __time64_t sec_etc = 0;
1266 #else
1267 time_t sec_etc = 0;
1268 #endif
1269
1270 if (words_per_ms)
1271 {
1272 uint64_t progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1273
1274 uint64_t ms_left = progress_left_relative_skip / words_per_ms;
1275
1276 sec_etc = ms_left / 1000;
1277 }
1278
1279 if (sec_etc == 0)
1280 {
1281 log_info ("Time.Estimated.: 0 secs");
1282 }
1283 else if ((uint64_t) sec_etc > ETC_MAX)
1284 {
1285 log_info ("Time.Estimated.: > 10 Years");
1286 }
1287 else
1288 {
1289 char display_etc[32];
1290
1291 struct tm tm_etc;
1292
1293 struct tm *tmp;
1294
1295 #ifdef WIN
1296
1297 tmp = _gmtime64 (&sec_etc);
1298
1299 #else
1300
1301 tmp = gmtime (&sec_etc);
1302
1303 #endif
1304
1305 if (tmp != NULL)
1306 {
1307 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1308
1309 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1310
1311 time_t now;
1312
1313 time (&now);
1314
1315 now += sec_etc;
1316
1317 char *etc = ctime (&now);
1318
1319 size_t etc_len = strlen (etc);
1320
1321 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1322 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1323
1324 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1325 }
1326 }
1327 }
1328 }
1329
1330 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1331 {
1332 char display_dev_cur[16];
1333
1334 memset (display_dev_cur, 0, sizeof (display_dev_cur));
1335
1336 strncpy (display_dev_cur, "0.00", 4);
1337
1338 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1339
1340 log_info ("Speed.Dev.#%d...: %9sH/s", device_id + 1, display_dev_cur);
1341 }
1342
1343 char display_all_cur[16];
1344
1345 memset (display_all_cur, 0, sizeof (display_all_cur));
1346
1347 strncpy (display_all_cur, "0.00", 4);
1348
1349 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1350
1351 if (data.devices_cnt > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1352
1353 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1354 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1355
1356 log_info ("Recovered......: %u/%u (%.2f%%) Digests, %u/%u (%.2f%%) Salts", data.digests_done, data.digests_cnt, digests_percent * 100, data.salts_done, data.salts_cnt, salts_percent * 100);
1357
1358 // crack-per-time
1359
1360 if (data.digests_cnt > 100)
1361 {
1362 time_t now = time (NULL);
1363
1364 int cpt_cur_min = 0;
1365 int cpt_cur_hour = 0;
1366 int cpt_cur_day = 0;
1367
1368 for (int i = 0; i < CPT_BUF; i++)
1369 {
1370 const uint cracked = data.cpt_buf[i].cracked;
1371 const time_t timestamp = data.cpt_buf[i].timestamp;
1372
1373 if ((timestamp + 60) > now)
1374 {
1375 cpt_cur_min += cracked;
1376 }
1377
1378 if ((timestamp + 3600) > now)
1379 {
1380 cpt_cur_hour += cracked;
1381 }
1382
1383 if ((timestamp + 86400) > now)
1384 {
1385 cpt_cur_day += cracked;
1386 }
1387 }
1388
1389 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1390 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1391 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1392
1393 if ((data.cpt_start + 86400) < now)
1394 {
1395 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1396 cpt_cur_min,
1397 cpt_cur_hour,
1398 cpt_cur_day,
1399 cpt_avg_min,
1400 cpt_avg_hour,
1401 cpt_avg_day);
1402 }
1403 else if ((data.cpt_start + 3600) < now)
1404 {
1405 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1406 cpt_cur_min,
1407 cpt_cur_hour,
1408 cpt_avg_min,
1409 cpt_avg_hour,
1410 cpt_avg_day);
1411 }
1412 else if ((data.cpt_start + 60) < now)
1413 {
1414 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1415 cpt_cur_min,
1416 cpt_avg_min,
1417 cpt_avg_hour,
1418 cpt_avg_day);
1419 }
1420 else
1421 {
1422 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1423 cpt_avg_min,
1424 cpt_avg_hour,
1425 cpt_avg_day);
1426 }
1427 }
1428
1429 // Restore point
1430
1431 uint64_t restore_point = get_lowest_words_done ();
1432
1433 uint64_t restore_total = data.words_base;
1434
1435 float percent_restore = 0;
1436
1437 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1438
1439 if (progress_end_relative_skip)
1440 {
1441 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1442 {
1443 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1444 float percent_rejected = 0.0;
1445
1446 if (progress_cur)
1447 {
1448 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1449 }
1450
1451 log_info ("Progress.......: %llu/%llu (%.02f%%)", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip, percent_finished * 100);
1452 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1453
1454 if (data.restore_disable == 0)
1455 {
1456 if (percent_finished != 1)
1457 {
1458 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1459 }
1460 }
1461 }
1462 }
1463 else
1464 {
1465 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1466 {
1467 log_info ("Progress.......: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1468 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1469
1470 if (data.restore_disable == 0)
1471 {
1472 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1473 }
1474 }
1475 else
1476 {
1477 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1478 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1479
1480 // --restore not allowed if stdin is used -- really? why?
1481
1482 //if (data.restore_disable == 0)
1483 //{
1484 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1485 //}
1486 }
1487 }
1488
1489 if (data.gpu_temp_disable == 0)
1490 {
1491 hc_thread_mutex_lock (mux_adl);
1492
1493 for (uint i = 0; i < data.devices_cnt; i++)
1494 {
1495 if (data.hm_device[i].fan_supported == 1)
1496 {
1497 const int temperature = hm_get_temperature_with_device_id (i);
1498 const int utilization = hm_get_utilization_with_device_id (i);
1499 const int fanspeed = hm_get_fanspeed_with_device_id (i);
1500
1501 if (data.vendor_id == VENDOR_ID_AMD)
1502 {
1503 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, %2d%% Fan", i + 1, utilization, temperature, fanspeed);
1504 }
1505
1506 if (data.vendor_id == VENDOR_ID_NV)
1507 {
1508 #ifdef LINUX
1509 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, %2d%% Fan", i + 1, utilization, temperature, fanspeed);
1510 #else
1511 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, %2drpm Fan", i + 1, utilization, temperature, fanspeed);
1512 #endif
1513 }
1514 }
1515 else
1516 {
1517 const int temperature = hm_get_temperature_with_device_id (i);
1518 const int utilization = hm_get_utilization_with_device_id (i);
1519
1520 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, N/A Fan", i + 1, utilization, temperature);
1521 }
1522 }
1523
1524 hc_thread_mutex_unlock (mux_adl);
1525 }
1526 }
1527
1528 static void status_benchmark ()
1529 {
1530 if (data.devices_status == STATUS_INIT) return;
1531 if (data.devices_status == STATUS_STARTING) return;
1532
1533 if (data.words_cnt == 0) return;
1534
1535 uint64_t speed_cnt[DEVICES_MAX];
1536 float speed_ms[DEVICES_MAX];
1537
1538 uint device_id;
1539
1540 for (device_id = 0; device_id < data.devices_cnt; device_id++)
1541 {
1542 hc_device_param_t *device_param = &data.devices_param[device_id];
1543
1544 speed_cnt[device_id] = 0;
1545 speed_ms[device_id] = 0;
1546
1547 for (int i = 0; i < SPEED_CACHE; i++)
1548 {
1549 speed_cnt[device_id] += device_param->speed_cnt[i];
1550 speed_ms[device_id] += device_param->speed_ms[i];
1551 }
1552
1553 speed_cnt[device_id] /= SPEED_CACHE;
1554 speed_ms[device_id] /= SPEED_CACHE;
1555 }
1556
1557 float hashes_all_ms = 0;
1558
1559 float hashes_dev_ms[DEVICES_MAX];
1560
1561 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1562 {
1563 hashes_dev_ms[device_id] = 0;
1564
1565 if (speed_ms[device_id])
1566 {
1567 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1568
1569 hashes_all_ms += hashes_dev_ms[device_id];
1570 }
1571 }
1572
1573 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1574 {
1575 char display_dev_cur[16];
1576
1577 memset (display_dev_cur, 0, sizeof (display_dev_cur));
1578
1579 strncpy (display_dev_cur, "0.00", 4);
1580
1581 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1582
1583 log_info ("Speed.Dev.#%d.: %9sH/s", device_id + 1, display_dev_cur);
1584 }
1585
1586 char display_all_cur[16];
1587
1588 memset (display_all_cur, 0, sizeof (display_all_cur));
1589
1590 strncpy (display_all_cur, "0.00", 4);
1591
1592 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1593
1594 if (data.devices_cnt > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1595 }
1596
1597 /**
1598 * oclHashcat -only- functions
1599 */
1600
1601 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1602 {
1603 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1604 {
1605 if (attack_kern == ATTACK_KERN_STRAIGHT)
1606 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1607 else if (attack_kern == ATTACK_KERN_COMBI)
1608 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1609 else if (attack_kern == ATTACK_KERN_BF)
1610 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1611 }
1612 else
1613 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1614 }
1615
1616 static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *profile_dir, char *device_name_chksum, int vendor_id, char *cached_file)
1617 {
1618 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1619 {
1620 if (attack_kern == ATTACK_KERN_STRAIGHT)
1621 snprintf (cached_file, 255, "%s/kernels/%d/m%05d_a0.%s.kernel", profile_dir, vendor_id, (int) kern_type, device_name_chksum);
1622 else if (attack_kern == ATTACK_KERN_COMBI)
1623 snprintf (cached_file, 255, "%s/kernels/%d/m%05d_a1.%s.kernel", profile_dir, vendor_id, (int) kern_type, device_name_chksum);
1624 else if (attack_kern == ATTACK_KERN_BF)
1625 snprintf (cached_file, 255, "%s/kernels/%d/m%05d_a3.%s.kernel", profile_dir, vendor_id, (int) kern_type, device_name_chksum);
1626 }
1627 else
1628 {
1629 snprintf (cached_file, 255, "%s/kernels/%d/m%05d.%s.kernel", profile_dir, vendor_id, (int) kern_type, device_name_chksum);
1630 }
1631 }
1632
1633 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1634 {
1635 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1636 {
1637 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1638 }
1639 else
1640 {
1641 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1642 }
1643 }
1644
1645 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, char *device_name_chksum, int vendor_id, char *cached_file)
1646 {
1647 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1648 {
1649 snprintf (cached_file, 255, "%s/kernels/%d/markov_be.%s.kernel", profile_dir, vendor_id, device_name_chksum);
1650 }
1651 else
1652 {
1653 snprintf (cached_file, 255, "%s/kernels/%d/markov_le.%s.kernel", profile_dir, vendor_id, device_name_chksum);
1654 }
1655 }
1656
1657 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1658 {
1659 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1660 }
1661
1662 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, char *device_name_chksum, int vendor_id, char *cached_file)
1663 {
1664 snprintf (cached_file, 255, "%s/kernels/%d/amp_a%d.%s.kernel", profile_dir, vendor_id, attack_kern, device_name_chksum);
1665 }
1666
1667 static uint convert_from_hex (char *line_buf, const uint line_len)
1668 {
1669 if (line_len & 1) return (line_len); // not in hex
1670
1671 if (data.hex_wordlist == 1)
1672 {
1673 uint i;
1674 uint j;
1675
1676 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1677 {
1678 line_buf[i] = hex_to_char (&line_buf[j]);
1679 }
1680
1681 memset (line_buf + i, 0, line_len - i);
1682
1683 return (i);
1684 }
1685 else if (line_len >= 6) // $HEX[] = 6
1686 {
1687 if (line_buf[0] != '$') return (line_len);
1688 if (line_buf[1] != 'H') return (line_len);
1689 if (line_buf[2] != 'E') return (line_len);
1690 if (line_buf[3] != 'X') return (line_len);
1691 if (line_buf[4] != '[') return (line_len);
1692 if (line_buf[line_len - 1] != ']') return (line_len);
1693
1694 uint i;
1695 uint j;
1696
1697 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1698 {
1699 line_buf[i] = hex_to_char (&line_buf[j]);
1700 }
1701
1702 memset (line_buf + i, 0, line_len - i);
1703
1704 return (i);
1705 }
1706
1707 return (line_len);
1708 }
1709
1710 static uint count_lines (FILE *fd)
1711 {
1712 uint cnt = 0;
1713
1714 char *buf = (char *) mymalloc (BUFSIZ);
1715
1716 size_t nread_tmp = 0;
1717
1718 char *ptr = buf;
1719
1720 while (!feof (fd))
1721 {
1722 size_t nread = fread (buf, sizeof (char), BUFSIZ, fd);
1723 nread_tmp = nread;
1724
1725 if (nread < 1) continue;
1726
1727 ptr = buf;
1728
1729 do
1730 {
1731 if (*ptr++ == '\n') cnt++;
1732
1733 } while (nread--);
1734 }
1735
1736 // special case (if last line did not contain a newline char ... at the very end of the file)
1737
1738 if (nread_tmp > 3)
1739 {
1740 ptr -= 2;
1741
1742 if (*ptr != '\n')
1743 {
1744 ptr--;
1745
1746 if (*ptr != '\n') // needed ? different on windows systems?
1747 {
1748 cnt++;
1749 }
1750 }
1751 }
1752
1753 myfree (buf);
1754
1755 return cnt;
1756 }
1757
1758 static void clear_prompt ()
1759 {
1760 fputc ('\r', stdout);
1761
1762 for (size_t i = 0; i < strlen (PROMPT); i++)
1763 {
1764 fputc (' ', stdout);
1765 }
1766
1767 fputc ('\r', stdout);
1768
1769 fflush (stdout);
1770 }
1771
1772 static void gidd_to_pw_t (hc_device_param_t *device_param, const uint64_t gidd, pw_t *pw)
1773 {
1774 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1775 }
1776
1777 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1778 {
1779 char *outfile = data.outfile;
1780 uint quiet = data.quiet;
1781 FILE *pot_fp = data.pot_fp;
1782 uint loopback = data.loopback;
1783 uint debug_mode = data.debug_mode;
1784 char *debug_file = data.debug_file;
1785
1786 char debug_rule_buf[BLOCK_SIZE];
1787 int debug_rule_len = 0; // -1 error
1788 uint debug_plain_len = 0;
1789
1790 unsigned char debug_plain_ptr[BLOCK_SIZE];
1791
1792 // hash
1793
1794 char out_buf[4096]; memset (out_buf, 0, sizeof (out_buf));
1795
1796 ascii_digest (out_buf, salt_pos, digest_pos);
1797
1798 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1799
1800 // plain
1801
1802 plain_t plain;
1803
1804 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, idx * sizeof (plain_t), sizeof (plain_t), &plain, 0, NULL, NULL);
1805
1806 uint gidvid = plain.gidvid;
1807 uint il_pos = plain.il_pos;
1808
1809 uint64_t crackpos = device_param->words_off;
1810
1811 uint plain_buf[16];
1812
1813 unsigned char *plain_ptr = (unsigned char *) plain_buf;
1814 unsigned int plain_len = 0;
1815
1816 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1817 {
1818 uint64_t gidd = gidvid;
1819 uint64_t gidm = 0;
1820
1821 pw_t pw;
1822
1823 gidd_to_pw_t (device_param, gidd, &pw);
1824
1825 for (int i = 0, j = gidm; i < 16; i++, j++)
1826 {
1827 plain_buf[i] = pw.hi1[0][j];
1828 }
1829
1830 plain_len = pw.pw_len;
1831
1832 const uint off = device_param->innerloop_pos + il_pos;
1833
1834 if (debug_mode > 0)
1835 {
1836 debug_rule_len = 0;
1837
1838 // save rule
1839 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1840 {
1841 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1842
1843 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1844 }
1845
1846 // save plain
1847 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1848 {
1849 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1850
1851 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1852
1853 debug_plain_len = plain_len;
1854 }
1855 }
1856
1857 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1858
1859 crackpos += gidvid;
1860 crackpos *= data.kernel_rules_cnt;
1861 crackpos += device_param->innerloop_pos + il_pos;
1862
1863 if (plain_len > data.pw_max) plain_len = data.pw_max;
1864 }
1865 else if (data.attack_mode == ATTACK_MODE_COMBI)
1866 {
1867 uint64_t gidd = gidvid;
1868 uint64_t gidm = 0;
1869
1870 pw_t pw;
1871
1872 gidd_to_pw_t (device_param, gidd, &pw);
1873
1874 for (int i = 0, j = gidm; i < 16; i++, j++)
1875 {
1876 plain_buf[i] = pw.hi1[0][j];
1877 }
1878
1879 plain_len = pw.pw_len;
1880
1881 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1882 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1883
1884 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1885 {
1886 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1887 }
1888 else
1889 {
1890 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1891
1892 memcpy (plain_ptr, comb_buf, comb_len);
1893 }
1894
1895 plain_len += comb_len;
1896
1897 crackpos += gidvid;
1898 crackpos *= data.combs_cnt;
1899 crackpos += device_param->innerloop_pos + il_pos;
1900
1901 if (data.pw_max != PW_DICTMAX1)
1902 {
1903 if (plain_len > data.pw_max) plain_len = data.pw_max;
1904 }
1905 }
1906 else if (data.attack_mode == ATTACK_MODE_BF)
1907 {
1908 uint64_t l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1909 uint64_t r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1910
1911 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1912 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1913
1914 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1915 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1916
1917 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1918 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1919
1920 plain_len = data.css_cnt;
1921
1922 crackpos += gidvid;
1923 crackpos *= data.bfs_cnt;
1924 crackpos += device_param->innerloop_pos + il_pos;
1925 }
1926 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1927 {
1928 uint64_t gidd = gidvid;
1929 uint64_t gidm = 0;
1930
1931 pw_t pw;
1932
1933 gidd_to_pw_t (device_param, gidd, &pw);
1934
1935 for (int i = 0, j = gidm; i < 16; i++, j++)
1936 {
1937 plain_buf[i] = pw.hi1[0][j];
1938 }
1939
1940 plain_len = pw.pw_len;
1941
1942 uint64_t off = device_param->kernel_params_mp_buf64[3] + il_pos;
1943
1944 uint start = 0;
1945 uint stop = device_param->kernel_params_mp_buf32[4];
1946
1947 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
1948
1949 plain_len += start + stop;
1950
1951 crackpos += gidvid;
1952 crackpos *= data.combs_cnt;
1953 crackpos += device_param->innerloop_pos + il_pos;
1954
1955 if (data.pw_max != PW_DICTMAX1)
1956 {
1957 if (plain_len > data.pw_max) plain_len = data.pw_max;
1958 }
1959 }
1960 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1961 {
1962 uint64_t gidd = gidvid;
1963 uint64_t gidm = 0;
1964
1965 pw_t pw;
1966
1967 gidd_to_pw_t (device_param, gidd, &pw);
1968
1969 for (int i = 0, j = gidm; i < 16; i++, j++)
1970 {
1971 plain_buf[i] = pw.hi1[0][j];
1972 }
1973
1974 plain_len = pw.pw_len;
1975
1976 uint64_t off = device_param->kernel_params_mp_buf64[3] + il_pos;
1977
1978 uint start = 0;
1979 uint stop = device_param->kernel_params_mp_buf32[4];
1980
1981 memmove (plain_ptr + stop, plain_ptr, plain_len);
1982
1983 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
1984
1985 plain_len += start + stop;
1986
1987 crackpos += gidvid;
1988 crackpos *= data.combs_cnt;
1989 crackpos += device_param->innerloop_pos + il_pos;
1990
1991 if (data.pw_max != PW_DICTMAX1)
1992 {
1993 if (plain_len > data.pw_max) plain_len = data.pw_max;
1994 }
1995 }
1996
1997 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
1998 {
1999 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2000 {
2001 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2002 {
2003 plain_len = plain_len - data.salts_buf[0].salt_len;
2004 }
2005 }
2006
2007 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2008 {
2009 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2010 {
2011 plain_ptr[j] = plain_ptr[i];
2012 }
2013
2014 plain_len = plain_len / 2;
2015 }
2016 }
2017
2018 // if enabled, update also the potfile
2019
2020 if (pot_fp)
2021 {
2022 fprintf (pot_fp, "%s:", out_buf);
2023
2024 format_plain (pot_fp, plain_ptr, plain_len, 1);
2025
2026 fputc ('\n', pot_fp);
2027
2028 fflush (pot_fp);
2029 }
2030
2031 // outfile
2032
2033 FILE *out_fp = NULL;
2034
2035 if (outfile != NULL)
2036 {
2037 if ((out_fp = fopen (outfile, "ab")) == NULL)
2038 {
2039 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2040
2041 out_fp = stdout;
2042 }
2043 }
2044 else
2045 {
2046 out_fp = stdout;
2047
2048 if (quiet == 0) clear_prompt ();
2049 }
2050
2051 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2052
2053 if (outfile != NULL)
2054 {
2055 if (out_fp != stdout)
2056 {
2057 fclose (out_fp);
2058 }
2059 }
2060 else
2061 {
2062 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2063 {
2064 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2065 {
2066 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2067 if (quiet == 0) fflush (stdout);
2068 }
2069 }
2070 }
2071
2072 // loopback
2073
2074 if (loopback)
2075 {
2076 char *loopback_file = data.loopback_file;
2077
2078 FILE *fb_fp = NULL;
2079
2080 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2081 {
2082 format_plain (fb_fp, plain_ptr, plain_len, 1);
2083
2084 fputc ('\n', fb_fp);
2085
2086 fclose (fb_fp);
2087 }
2088 }
2089
2090 // (rule) debug mode
2091
2092 // the next check implies that:
2093 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2094 // - debug_mode > 0
2095
2096 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2097 {
2098 if (debug_rule_len < 0) debug_rule_len = 0;
2099
2100 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2101
2102 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2103
2104 if ((quiet == 0) && (debug_file == NULL))
2105 {
2106 fprintf (stdout, "%s", PROMPT);
2107 fflush (stdout);
2108 }
2109 }
2110 }
2111
2112 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2113 {
2114 salt_t *salt_buf = &data.salts_buf[salt_pos];
2115
2116 int found = 0;
2117
2118 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2119
2120 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2121
2122 if (found == 1)
2123 {
2124 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2125
2126 log_info_nn ("");
2127
2128 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2129
2130 uint cpt_cracked = 0;
2131
2132 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2133 {
2134 uint idx = salt_buf->digests_offset + digest_pos;
2135
2136 if (data.digests_shown_tmp[idx] == 0) continue;
2137
2138 if (data.digests_shown[idx] == 1) continue;
2139
2140 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2141 {
2142 data.digests_shown[idx] = 1;
2143
2144 data.digests_done++;
2145
2146 cpt_cracked++;
2147
2148 salt_buf->digests_done++;
2149
2150 if (salt_buf->digests_done == salt_buf->digests_cnt)
2151 {
2152 data.salts_shown[salt_pos] = 1;
2153
2154 data.salts_done++;
2155 }
2156 }
2157
2158 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2159
2160 check_hash (device_param, salt_pos, digest_pos);
2161 }
2162
2163 if (cpt_cracked > 0)
2164 {
2165 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2166 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2167
2168 data.cpt_pos++;
2169
2170 data.cpt_total += cpt_cracked;
2171
2172 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2173 }
2174
2175 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2176 {
2177 // we need to reset cracked state on the device
2178 // otherwise host thinks again and again the hash was cracked
2179 // and returns invalid password each time
2180
2181 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2182
2183 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2184 }
2185
2186 memset (device_param->result, 0, device_param->size_results);
2187
2188 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2189 }
2190 }
2191
2192 static void save_hash ()
2193 {
2194 char *hashfile = data.hashfile;
2195
2196 char new_hashfile[256];
2197 char old_hashfile[256];
2198
2199 memset (new_hashfile, 0, sizeof (new_hashfile));
2200 memset (old_hashfile, 0, sizeof (old_hashfile));
2201
2202 snprintf (new_hashfile, 255, "%s.new", hashfile);
2203 snprintf (old_hashfile, 255, "%s.old", hashfile);
2204
2205 unlink (new_hashfile);
2206
2207 char separator = data.separator;
2208
2209 FILE *fp = fopen (new_hashfile, "wb");
2210
2211 if (fp == NULL)
2212 {
2213 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2214
2215 exit (-1);
2216 }
2217
2218 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2219 {
2220 if (data.salts_shown[salt_pos] == 1) continue;
2221
2222 salt_t *salt_buf = &data.salts_buf[salt_pos];
2223
2224 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2225 {
2226 uint idx = salt_buf->digests_offset + digest_pos;
2227
2228 if (data.digests_shown[idx] == 1) continue;
2229
2230 if (data.hash_mode != 2500)
2231 {
2232 char out_buf[4096];
2233
2234 memset (out_buf, 0, sizeof (out_buf));
2235
2236 if (data.username == 1)
2237 {
2238 user_t *user = data.hash_info[idx]->user;
2239
2240 uint i;
2241
2242 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2243
2244 fputc (separator, fp);
2245 }
2246
2247 ascii_digest (out_buf, salt_pos, digest_pos);
2248
2249 fputs (out_buf, fp);
2250
2251 log_out (fp, "");
2252 }
2253 else
2254 {
2255 hccap_t hccap;
2256
2257 to_hccap_t (&hccap, salt_pos, digest_pos);
2258
2259 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2260 }
2261 }
2262 }
2263
2264 fflush (fp);
2265
2266 fclose (fp);
2267
2268 unlink (old_hashfile);
2269
2270 if (rename (hashfile, old_hashfile) != 0)
2271 {
2272 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2273
2274 exit (-1);
2275 }
2276
2277 unlink (hashfile);
2278
2279 if (rename (new_hashfile, hashfile) != 0)
2280 {
2281 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2282
2283 exit (-1);
2284 }
2285
2286 unlink (old_hashfile);
2287 }
2288
2289 static float find_kernel_blocks_div (const uint64_t total_left, const uint kernel_blocks_all)
2290 {
2291 // function called only in case kernel_blocks_all > words_left)
2292
2293 float kernel_blocks_div = (float) (total_left) / kernel_blocks_all;
2294
2295 kernel_blocks_div += kernel_blocks_div / 100;
2296
2297 uint32_t kernel_blocks_new = (uint32_t) (kernel_blocks_all * kernel_blocks_div);
2298
2299 while (kernel_blocks_new < total_left)
2300 {
2301 kernel_blocks_div += kernel_blocks_div / 100;
2302
2303 kernel_blocks_new = (uint32_t) (kernel_blocks_all * kernel_blocks_div);
2304 }
2305
2306 if (data.quiet == 0)
2307 {
2308 clear_prompt ();
2309
2310 log_info ("");
2311
2312 log_info ("INFO: approaching final keyspace, workload adjusted");
2313
2314 log_info ("");
2315
2316 fprintf (stdout, "%s", PROMPT);
2317
2318 fflush (stdout);
2319 }
2320
2321 if ((kernel_blocks_all * kernel_blocks_div) < 8) return 1;
2322
2323 return kernel_blocks_div;
2324 }
2325
2326 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num)
2327 {
2328 uint num_elements = num;
2329
2330 device_param->kernel_params_buf32[30] = data.combs_mode;
2331 device_param->kernel_params_buf32[31] = num;
2332
2333 uint kernel_threads = device_param->kernel_threads;
2334
2335 while (num_elements % kernel_threads) num_elements++;
2336
2337 cl_kernel kernel = NULL;
2338
2339 switch (kern_run)
2340 {
2341 case KERN_RUN_1: kernel = device_param->kernel1; break;
2342 case KERN_RUN_12: kernel = device_param->kernel12; break;
2343 case KERN_RUN_2: kernel = device_param->kernel2; break;
2344 case KERN_RUN_23: kernel = device_param->kernel23; break;
2345 case KERN_RUN_3: kernel = device_param->kernel3; break;
2346 }
2347
2348 hc_clSetKernelArg (kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2349 hc_clSetKernelArg (kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2350 hc_clSetKernelArg (kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2351 hc_clSetKernelArg (kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2352 hc_clSetKernelArg (kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2353 hc_clSetKernelArg (kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2354 hc_clSetKernelArg (kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2355 hc_clSetKernelArg (kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2356 hc_clSetKernelArg (kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2357 hc_clSetKernelArg (kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2358 hc_clSetKernelArg (kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2359
2360 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2361 {
2362 const size_t global_work_size[3] = { num_elements, 32, 1 };
2363 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2364
2365 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2366 }
2367 else
2368 {
2369 const size_t global_work_size[3] = { num_elements, 1, 1 };
2370 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2371
2372 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2373 }
2374
2375 hc_clFlush (device_param->command_queue);
2376
2377 hc_clFinish (device_param->command_queue);
2378 }
2379
2380 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2381 {
2382 uint num_elements = num;
2383
2384 switch (kern_run)
2385 {
2386 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2387 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2388 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2389 }
2390
2391 // causes problems with special threads like in bcrypt
2392 // const uint kernel_threads = device_param->kernel_threads;
2393
2394 const uint kernel_threads = KERNEL_THREADS;
2395
2396 while (num_elements % kernel_threads) num_elements++;
2397
2398 cl_kernel kernel = NULL;
2399
2400 switch (kern_run)
2401 {
2402 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2403 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2404 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2405 }
2406
2407 switch (kern_run)
2408 {
2409 case KERN_RUN_MP: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2410 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2411 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2412 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2413 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2414 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2415 break;
2416 case KERN_RUN_MP_R: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2417 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2418 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2419 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2420 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2421 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2422 break;
2423 case KERN_RUN_MP_L: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2424 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2425 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2426 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2427 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2428 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2429 hc_clSetKernelArg (kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2430 break;
2431 }
2432
2433 const size_t global_work_size[3] = { num_elements, 1, 1 };
2434 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2435
2436 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2437
2438 hc_clFlush (device_param->command_queue);
2439
2440 hc_clFinish (device_param->command_queue);
2441 }
2442
2443 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2444 {
2445 uint num_elements = num;
2446
2447 uint kernel_threads = device_param->kernel_threads;
2448
2449 while (num_elements % kernel_threads) num_elements++;
2450
2451 cl_kernel kernel = device_param->kernel_tb;
2452
2453 const size_t global_work_size[3] = { num_elements, 1, 1 };
2454 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2455
2456 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2457
2458 hc_clFlush (device_param->command_queue);
2459
2460 hc_clFinish (device_param->command_queue);
2461 }
2462
2463 static void run_kernel_tm (hc_device_param_t *device_param)
2464 {
2465 const uint num_elements = 1024; // fixed
2466
2467 const uint kernel_threads = 32;
2468
2469 cl_kernel kernel = device_param->kernel_tm;
2470
2471 const size_t global_work_size[3] = { num_elements, 1, 1 };
2472 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2473
2474 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2475
2476 hc_clFlush (device_param->command_queue);
2477
2478 hc_clFinish (device_param->command_queue);
2479 }
2480
2481 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2482 {
2483 uint num_elements = num;
2484
2485 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2486 device_param->kernel_params_amp_buf32[6] = num_elements;
2487
2488 // causes problems with special threads like in bcrypt
2489 // const uint kernel_threads = device_param->kernel_threads;
2490
2491 const uint kernel_threads = KERNEL_THREADS;
2492
2493 while (num_elements % kernel_threads) num_elements++;
2494
2495 cl_kernel kernel = device_param->kernel_amp;
2496
2497 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2498 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2499
2500 const size_t global_work_size[3] = { num_elements, 1, 1 };
2501 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2502
2503 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2504
2505 hc_clFlush (device_param->command_queue);
2506
2507 hc_clFinish (device_param->command_queue);
2508 }
2509
2510 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2511 {
2512 if (data.vendor_id == VENDOR_ID_AMD)
2513 {
2514 const cl_uchar zero = 0;
2515
2516 hc_clEnqueueFillBuffer (device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2517 }
2518
2519 if (data.vendor_id == VENDOR_ID_NV)
2520 {
2521 // NOTE: clEnqueueFillBuffer () always fails with -59
2522 // IOW, it's not supported by Nvidia ForceWare <= 352.21,
2523 // How's that possible, OpenCL 1.2 support is advertised??
2524 // We need to workaround...
2525
2526 #define FILLSZ 0x100000
2527
2528 char *tmp = (char *) mymalloc (FILLSZ);
2529
2530 memset (tmp, 0, FILLSZ);
2531
2532 for (uint i = 0; i < size; i += FILLSZ)
2533 {
2534 const int left = size - i;
2535
2536 const int fillsz = MIN (FILLSZ, left);
2537
2538 hc_clEnqueueWriteBuffer (device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2539 }
2540
2541 myfree (tmp);
2542 }
2543
2544 if (data.vendor_id == VENDOR_ID_GENERIC)
2545 {
2546 const cl_uchar zero = 0;
2547
2548 hc_clEnqueueFillBuffer (device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2549 }
2550 }
2551
2552 static int run_rule_engine (const int rule_len, const char *rule_buf)
2553 {
2554 if (rule_len == 0)
2555 {
2556 return 0;
2557 }
2558 else if (rule_len == 1)
2559 {
2560 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2561 }
2562
2563 return 1;
2564 }
2565
2566 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2567 {
2568 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2569 {
2570 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2571 }
2572 else if (data.attack_kern == ATTACK_KERN_COMBI)
2573 {
2574 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2575 }
2576 else if (data.attack_kern == ATTACK_KERN_BF)
2577 {
2578 const uint64_t off = device_param->words_off;
2579
2580 device_param->kernel_params_mp_l_buf64[3] = off;
2581
2582 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2583 }
2584 }
2585
2586 static void run_cracker (hc_device_param_t *device_param, const uint pw_cnt, const uint pws_cnt)
2587 {
2588 const uint kernel_loops = data.kernel_loops;
2589
2590 // init speed timer
2591
2592 uint speed_pos = device_param->speed_pos;
2593
2594 #ifdef _POSIX
2595 if (device_param->timer_speed.tv_sec == 0)
2596 {
2597 hc_timer_set (&device_param->timer_speed);
2598 }
2599 #endif
2600
2601 #ifdef _WIN
2602 if (device_param->timer_speed.QuadPart == 0)
2603 {
2604 hc_timer_set (&device_param->timer_speed);
2605 }
2606 #endif
2607
2608 // find higest password length, this is for optimization stuff
2609
2610 uint highest_pw_len = 0;
2611
2612 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2613 {
2614 }
2615 else if (data.attack_kern == ATTACK_KERN_COMBI)
2616 {
2617 }
2618 else if (data.attack_kern == ATTACK_KERN_BF)
2619 {
2620 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
2621 + device_param->kernel_params_mp_l_buf32[5];
2622 }
2623
2624 // bitslice optimization stuff
2625
2626 if (data.attack_mode == ATTACK_MODE_BF)
2627 {
2628 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2629 {
2630 run_kernel_tb (device_param, pws_cnt);
2631 }
2632 }
2633
2634 // iteration type
2635
2636 uint innerloop_step = 0;
2637 uint innerloop_cnt = 0;
2638
2639 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = kernel_loops;
2640 else innerloop_step = 1;
2641
2642 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
2643 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
2644 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
2645
2646 // loop start: most outer loop = salt iteration, then innerloops (if multi)
2647
2648 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2649 {
2650 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2651
2652 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2653
2654 if (data.devices_status == STATUS_CRACKED) break;
2655 if (data.devices_status == STATUS_ABORTED) break;
2656 if (data.devices_status == STATUS_QUIT) break;
2657 if (data.devices_status == STATUS_BYPASS) break;
2658
2659 if (data.salts_shown[salt_pos] == 1) continue;
2660
2661 salt_t *salt_buf = &data.salts_buf[salt_pos];
2662
2663 device_param->kernel_params_buf32[24] = salt_pos;
2664 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
2665 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
2666
2667 FILE *combs_fp = device_param->combs_fp;
2668
2669 if (data.attack_mode == ATTACK_MODE_COMBI)
2670 {
2671 rewind (combs_fp);
2672 }
2673
2674 // innerloops
2675
2676 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
2677 {
2678 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2679
2680 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2681
2682 if (data.devices_status == STATUS_CRACKED) break;
2683 if (data.devices_status == STATUS_ABORTED) break;
2684 if (data.devices_status == STATUS_QUIT) break;
2685 if (data.devices_status == STATUS_BYPASS) break;
2686
2687 uint innerloop_left = innerloop_cnt - innerloop_pos;
2688
2689 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
2690
2691 device_param->innerloop_pos = innerloop_pos;
2692 device_param->innerloop_left = innerloop_left;
2693
2694 device_param->kernel_params_buf32[27] = innerloop_left;
2695
2696 if (innerloop_left == 0) continue;
2697
2698 // initialize amplifiers
2699
2700 if (data.attack_mode == ATTACK_MODE_COMBI)
2701 {
2702 char line_buf[BUFSIZ];
2703
2704 uint i = 0;
2705
2706 while (i < innerloop_left)
2707 {
2708 if (feof (combs_fp)) break;
2709
2710 int line_len = fgetl (combs_fp, line_buf);
2711
2712 if (line_len >= PW_MAX1) continue;
2713
2714 line_len = convert_from_hex (line_buf, line_len);
2715
2716 char *line_buf_new = line_buf;
2717
2718 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
2719 {
2720 char rule_buf_out[BLOCK_SIZE];
2721
2722 memset (rule_buf_out, 0, sizeof (rule_buf_out));
2723
2724 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
2725
2726 if (rule_len_out < 0)
2727 {
2728 data.words_progress_rejected[salt_pos] += pw_cnt;
2729
2730 continue;
2731 }
2732
2733 line_len = rule_len_out;
2734
2735 line_buf_new = rule_buf_out;
2736 }
2737
2738 line_len = MIN (line_len, PW_DICTMAX);
2739
2740 char *ptr = (char *) device_param->combs_buf[i].i;
2741
2742 memcpy (ptr, line_buf_new, line_len);
2743
2744 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
2745
2746 if (data.opts_type & OPTS_TYPE_PT_UPPER)
2747 {
2748 uppercase (ptr, line_len);
2749 }
2750
2751 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2752 {
2753 if (data.opts_type & OPTS_TYPE_PT_ADD80)
2754 {
2755 ptr[line_len] = 0x80;
2756 }
2757
2758 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2759 {
2760 ptr[line_len] = 0x01;
2761 }
2762 }
2763
2764 device_param->combs_buf[i].pw_len = line_len;
2765
2766 i++;
2767 }
2768
2769 for (uint j = i; j < innerloop_left; j++)
2770 {
2771 device_param->combs_buf[j].i[0] = 0;
2772 device_param->combs_buf[j].i[1] = 0;
2773 device_param->combs_buf[j].i[2] = 0;
2774 device_param->combs_buf[j].i[3] = 0;
2775 device_param->combs_buf[j].i[4] = 0;
2776 device_param->combs_buf[j].i[5] = 0;
2777 device_param->combs_buf[j].i[6] = 0;
2778 device_param->combs_buf[j].i[7] = 0;
2779
2780 device_param->combs_buf[j].pw_len = 0;
2781 }
2782
2783 innerloop_left = i;
2784 }
2785 else if (data.attack_mode == ATTACK_MODE_BF)
2786 {
2787 uint64_t off = innerloop_pos;
2788
2789 device_param->kernel_params_mp_r_buf64[3] = off;
2790
2791 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
2792 }
2793 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2794 {
2795 uint64_t off = innerloop_pos;
2796
2797 device_param->kernel_params_mp_buf64[3] = off;
2798
2799 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2800 }
2801 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2802 {
2803 uint64_t off = innerloop_pos;
2804
2805 device_param->kernel_params_mp_buf64[3] = off;
2806
2807 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2808 }
2809
2810 // copy amplifiers
2811
2812 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2813 {
2814 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_rules, device_param->d_rules_c, innerloop_pos * sizeof (kernel_rule_t), 0, innerloop_left * sizeof (kernel_rule_t), 0, NULL, NULL);
2815 }
2816 else if (data.attack_mode == ATTACK_MODE_COMBI)
2817 {
2818 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_combs_c, CL_TRUE, 0, innerloop_left * sizeof (comb_t), device_param->combs_buf, 0, NULL, NULL);
2819 }
2820 else if (data.attack_mode == ATTACK_MODE_BF)
2821 {
2822 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_bfs, device_param->d_bfs_c, 0, 0, innerloop_left * sizeof (bf_t), 0, NULL, NULL);
2823 }
2824 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2825 {
2826 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
2827 }
2828 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2829 {
2830 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
2831 }
2832
2833 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2834 {
2835 if (data.attack_mode == ATTACK_MODE_BF)
2836 {
2837 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2838 {
2839 const uint size_tm = 32 * sizeof (bs_word_t);
2840
2841 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2842
2843 run_kernel_tm (device_param);
2844
2845 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2846 }
2847 }
2848
2849 if (highest_pw_len < 16)
2850 {
2851 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2852 }
2853 else if (highest_pw_len < 32)
2854 {
2855 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2856 }
2857 else
2858 {
2859 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2860 }
2861 }
2862 else
2863 {
2864 run_kernel_amp (device_param, pws_cnt);
2865
2866 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2867
2868 if (data.opts_type & OPTS_TYPE_HOOK12)
2869 {
2870 run_kernel (KERN_RUN_12, device_param, pws_cnt);
2871 }
2872
2873 uint iter = salt_buf->salt_iter;
2874
2875 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
2876 {
2877 uint loop_left = iter - loop_pos;
2878
2879 loop_left = MIN (loop_left, kernel_loops);
2880
2881 device_param->kernel_params_buf32[25] = loop_pos;
2882 device_param->kernel_params_buf32[26] = loop_left;
2883
2884 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2885
2886 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2887
2888 if (data.devices_status == STATUS_CRACKED) break;
2889 if (data.devices_status == STATUS_ABORTED) break;
2890 if (data.devices_status == STATUS_QUIT) break;
2891 }
2892
2893 if (data.opts_type & OPTS_TYPE_HOOK23)
2894 {
2895 run_kernel (KERN_RUN_23, device_param, pws_cnt);
2896
2897 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2898
2899 // do something with data
2900
2901 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2902 }
2903
2904 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2905 }
2906
2907 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2908
2909 if (data.devices_status == STATUS_CRACKED) break;
2910 if (data.devices_status == STATUS_ABORTED) break;
2911 if (data.devices_status == STATUS_QUIT) break;
2912
2913 /**
2914 * result
2915 */
2916
2917 hc_thread_mutex_lock (mux_display);
2918
2919 check_cracked (device_param, salt_pos);
2920
2921 hc_thread_mutex_unlock (mux_display);
2922
2923 /**
2924 * progress
2925 */
2926
2927 uint64_t perf_sum_all = (uint64_t) pw_cnt * (uint64_t) innerloop_left;
2928
2929 hc_thread_mutex_lock (mux_counter);
2930
2931 data.words_progress_done[salt_pos] += perf_sum_all;
2932
2933 hc_thread_mutex_unlock (mux_counter);
2934
2935 /**
2936 * speed
2937 */
2938
2939 float speed_ms;
2940
2941 hc_timer_get (device_param->timer_speed, speed_ms);
2942
2943 hc_timer_set (&device_param->timer_speed);
2944
2945 hc_thread_mutex_lock (mux_display);
2946
2947 device_param->speed_cnt[speed_pos] = perf_sum_all;
2948
2949 device_param->speed_ms[speed_pos] = speed_ms;
2950
2951 device_param->speed_rec[speed_pos] = device_param->timer_speed;
2952
2953 hc_thread_mutex_unlock (mux_display);
2954
2955 speed_pos++;
2956
2957 if (speed_pos == SPEED_CACHE)
2958 {
2959 speed_pos = 0;
2960 }
2961 }
2962 }
2963
2964 device_param->speed_pos = speed_pos;
2965 }
2966
2967 static void load_segment (wl_data_t *wl_data, FILE *fd)
2968 {
2969 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
2970
2971 wl_data->pos = 0;
2972
2973 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
2974
2975 wl_data->buf[wl_data->cnt] = 0;
2976
2977 if (wl_data->cnt == 0) return;
2978
2979 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
2980
2981 while (!feof (fd))
2982 {
2983 if (wl_data->cnt == wl_data->avail)
2984 {
2985 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
2986
2987 wl_data->avail += wl_data->incr;
2988 }
2989
2990 const int c = fgetc (fd);
2991
2992 if (c == EOF) break;
2993
2994 wl_data->buf[wl_data->cnt] = (char) c;
2995
2996 wl_data->cnt++;
2997
2998 if (c == '\n') break;
2999 }
3000
3001 // ensure stream ends with a newline
3002
3003 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3004 {
3005 wl_data->cnt++;
3006
3007 wl_data->buf[wl_data->cnt - 1] = '\n';
3008 }
3009
3010 return;
3011 }
3012
3013 static void get_next_word_lm (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
3014 {
3015 char *ptr = buf;
3016
3017 for (uint32_t i = 0; i < sz; i++, ptr++)
3018 {
3019 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3020
3021 if (i == 7)
3022 {
3023 *off = i;
3024 *len = i;
3025
3026 return;
3027 }
3028
3029 if (*ptr != '\n') continue;
3030
3031 *off = i + 1;
3032
3033 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3034
3035 *len = i;
3036
3037 return;
3038 }
3039
3040 *off = sz;
3041 *len = sz;
3042 }
3043
3044 static void get_next_word_uc (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
3045 {
3046 char *ptr = buf;
3047
3048 for (uint32_t i = 0; i < sz; i++, ptr++)
3049 {
3050 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3051
3052 if (*ptr != '\n') continue;
3053
3054 *off = i + 1;
3055
3056 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3057
3058 *len = i;
3059
3060 return;
3061 }
3062
3063 *off = sz;
3064 *len = sz;
3065 }
3066
3067 static void get_next_word_std (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
3068 {
3069 char *ptr = buf;
3070
3071 for (uint32_t i = 0; i < sz; i++, ptr++)
3072 {
3073 if (*ptr != '\n') continue;
3074
3075 *off = i + 1;
3076
3077 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3078
3079 *len = i;
3080
3081 return;
3082 }
3083
3084 *off = sz;
3085 *len = sz;
3086 }
3087
3088 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3089 {
3090 while (wl_data->pos < wl_data->cnt)
3091 {
3092 uint off;
3093 uint len;
3094
3095 char *ptr = wl_data->buf + wl_data->pos;
3096
3097 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3098
3099 wl_data->pos += off;
3100
3101 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3102 {
3103 char rule_buf_out[BLOCK_SIZE];
3104
3105 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3106
3107 int rule_len_out = -1;
3108
3109 if (len < BLOCK_SIZE)
3110 {
3111 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3112 }
3113
3114 if (rule_len_out < 0)
3115 {
3116 continue;
3117 }
3118
3119 if (rule_len_out > PW_MAX)
3120 {
3121 continue;
3122 }
3123 }
3124 else
3125 {
3126 if (len > PW_MAX)
3127 {
3128 continue;
3129 }
3130 }
3131
3132 *out_buf = ptr;
3133 *out_len = len;
3134
3135 return;
3136 }
3137
3138 if (feof (fd))
3139 {
3140 fprintf (stderr, "bug!!\n");
3141
3142 return;
3143 }
3144
3145 load_segment (wl_data, fd);
3146
3147 get_next_word (wl_data, fd, out_buf, out_len);
3148 }
3149
3150 #ifdef _POSIX
3151 static uint64_t count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3152 #endif
3153
3154 #ifdef _WIN
3155 static uint64_t count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3156 #endif
3157 {
3158 hc_signal (NULL);
3159
3160 dictstat_t d;
3161
3162 d.cnt = 0;
3163
3164 #ifdef _POSIX
3165 fstat (fileno (fd), &d.stat);
3166 #endif
3167
3168 #ifdef _WIN
3169 _fstat64 (fileno (fd), &d.stat);
3170 #endif
3171
3172 d.stat.st_mode = 0;
3173 d.stat.st_nlink = 0;
3174 d.stat.st_uid = 0;
3175 d.stat.st_gid = 0;
3176 d.stat.st_rdev = 0;
3177 d.stat.st_atime = 0;
3178
3179 #ifdef _POSIX
3180 d.stat.st_blksize = 0;
3181 d.stat.st_blocks = 0;
3182 #endif
3183
3184 if (d.stat.st_size == 0) return 0;
3185
3186 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3187
3188 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3189 {
3190 if (d_cache)
3191 {
3192 uint64_t cnt = d_cache->cnt;
3193
3194 uint64_t keyspace = cnt;
3195
3196 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3197 {
3198 keyspace *= data.kernel_rules_cnt;
3199 }
3200 else if (data.attack_kern == ATTACK_KERN_COMBI)
3201 {
3202 keyspace *= data.combs_cnt;
3203 }
3204
3205 if (data.quiet == 0) log_info ("Cache-hit dictionary stats %s: %llu bytes, %llu words, %llu keyspace", dictfile, (unsigned long long int) d.stat.st_size, (unsigned long long int) cnt, (unsigned long long int) keyspace);
3206 if (data.quiet == 0) log_info ("");
3207
3208 hc_signal (sigHandler_default);
3209
3210 return (keyspace);
3211 }
3212 }
3213
3214 time_t now = 0;
3215 time_t prev = 0;
3216
3217 uint64_t comp = 0;
3218 uint64_t cnt = 0;
3219 uint64_t cnt2 = 0;
3220
3221 while (!feof (fd))
3222 {
3223 load_segment (wl_data, fd);
3224
3225 comp += wl_data->cnt;
3226
3227 uint32_t i = 0;
3228
3229 while (i < wl_data->cnt)
3230 {
3231 uint32_t len;
3232 uint32_t off;
3233
3234 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3235
3236 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3237 {
3238 char rule_buf_out[BLOCK_SIZE];
3239
3240 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3241
3242 int rule_len_out = -1;
3243
3244 if (len < BLOCK_SIZE)
3245 {
3246 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3247 }
3248
3249 if (rule_len_out < 0)
3250 {
3251 len = PW_MAX1;
3252 }
3253 else
3254 {
3255 len = rule_len_out;
3256 }
3257 }
3258
3259 if (len < PW_MAX1)
3260 {
3261 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3262 {
3263 cnt += data.kernel_rules_cnt;
3264 }
3265 else if (data.attack_kern == ATTACK_KERN_COMBI)
3266 {
3267 cnt += data.combs_cnt;
3268 }
3269
3270 d.cnt++;
3271 }
3272
3273 i += off;
3274
3275 cnt2++;
3276 }
3277
3278 time (&now);
3279
3280 if ((now - prev) == 0) continue;
3281
3282 float percent = (float) comp / (float) d.stat.st_size;
3283
3284 if (data.quiet == 0) log_info_nn ("Generating dictionary stats for %s: %llu bytes (%.2f%%), %llu words, %llu keyspace", dictfile, (unsigned long long int) comp, percent * 100, (unsigned long long int) cnt2, (unsigned long long int) cnt);
3285
3286 time (&prev);
3287 }
3288
3289 if (data.quiet == 0) log_info ("Generated dictionary stats for %s: %llu bytes, %llu words, %llu keyspace", dictfile, (unsigned long long int) comp, (unsigned long long int) cnt2, (unsigned long long int) cnt);
3290 if (data.quiet == 0) log_info ("");
3291
3292 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3293
3294 hc_signal (sigHandler_default);
3295
3296 return (cnt);
3297 }
3298
3299 static void pw_transpose_to_hi1 (const pw_t *p1, pw_t *p2)
3300 {
3301 memcpy (p2->hi1, p1->hi1, 64 * sizeof (uint));
3302 }
3303
3304 static uint pw_add_to_hc1 (hc_device_param_t *device_param, const uint8_t *pw_buf, const uint pw_len)
3305 {
3306 if (data.devices_status == STATUS_BYPASS) return 0;
3307
3308 pw_cache_t *pw_cache = device_param->pw_caches + pw_len;
3309
3310 uint cache_cnt = pw_cache->cnt;
3311
3312 uint8_t *pw_hc1 = pw_cache->pw_buf.hc1[cache_cnt];
3313
3314 memcpy (pw_hc1, pw_buf, pw_len);
3315
3316 memset (pw_hc1 + pw_len, 0, 256 - pw_len);
3317
3318 uint pws_cnt = device_param->pws_cnt;
3319
3320 cache_cnt++;
3321
3322 pw_t *pw = device_param->pws_buf + pws_cnt;
3323
3324 device_param->pw_transpose (&pw_cache->pw_buf, pw);
3325
3326 pw->pw_len = pw_len;
3327
3328 pws_cnt++;
3329
3330 device_param->pws_cnt = pws_cnt;
3331 device_param->pw_cnt = pws_cnt * 1;
3332
3333 cache_cnt = 0;
3334
3335 pw_cache->cnt = cache_cnt;
3336
3337 return pws_cnt;
3338 }
3339
3340 static void *thread_monitor (void *p)
3341 {
3342 uint runtime_check = 0;
3343 uint remove_check = 0;
3344 uint status_check = 0;
3345 uint hwmon_check = 0;
3346 uint restore_check = 0;
3347
3348 uint restore_left = data.restore_timer;
3349 uint remove_left = data.remove_timer;
3350 uint status_left = data.status_timer;
3351
3352 // these variables are mainly used for fan control (AMD only)
3353
3354 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3355
3356 // temperature controller "loopback" values
3357
3358 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3359 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3360
3361 int temp_threshold = 1; // degrees celcius
3362
3363 int fan_speed_min = 15; // in percentage
3364 int fan_speed_max = 100;
3365
3366 time_t last_temp_check_time;
3367
3368 uint sleep_time = 1;
3369
3370 if (data.runtime)
3371 {
3372 runtime_check = 1;
3373 }
3374
3375 if (data.restore_timer)
3376 {
3377 restore_check = 1;
3378 }
3379
3380 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3381 {
3382 remove_check = 1;
3383 }
3384
3385 if (data.status == 1)
3386 {
3387 status_check = 1;
3388 }
3389
3390 if (data.gpu_temp_disable == 0)
3391 {
3392 time (&last_temp_check_time);
3393
3394 hwmon_check = 1;
3395 }
3396
3397 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (hwmon_check == 0) && (restore_check == 0))
3398 {
3399 return (p);
3400 }
3401
3402 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3403 {
3404 hc_sleep (sleep_time);
3405
3406 if (data.devices_status != STATUS_RUNNING) continue;
3407
3408 if (hwmon_check == 1)
3409 {
3410 hc_thread_mutex_lock (mux_adl);
3411
3412 time_t temp_check_time;
3413
3414 time (&temp_check_time);
3415
3416 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3417
3418 if (Ta == 0) Ta = 1;
3419
3420 for (uint i = 0; i < data.devices_cnt; i++)
3421 {
3422 const int temperature = hm_get_temperature_with_device_id (i);
3423
3424 if (temperature > (int) data.gpu_temp_abort)
3425 {
3426 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", i + 1);
3427
3428 if (data.devices_status != STATUS_QUIT) myabort ();
3429
3430 break;
3431 }
3432
3433 const int gpu_temp_retain = data.gpu_temp_retain;
3434
3435 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3436 {
3437 if (data.hm_device[i].fan_supported == 1)
3438 {
3439 int temp_cur = temperature;
3440
3441 int temp_diff_new = gpu_temp_retain - temp_cur;
3442
3443 temp_diff_sum[i] = temp_diff_sum[i] + temp_diff_new;
3444
3445 // calculate Ta value (time difference in seconds between the last check and this check)
3446
3447 last_temp_check_time = temp_check_time;
3448
3449 float Kp = 1.8;
3450 float Ki = 0.005;
3451 float Kd = 6;
3452
3453 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3454
3455 int fan_diff_required = (int) (Kp * (float)temp_diff_new + Ki * Ta * (float)temp_diff_sum[i] + Kd * ((float)(temp_diff_new - temp_diff_old[i])) / Ta);
3456
3457 if (abs (fan_diff_required) >= temp_threshold)
3458 {
3459 const int fan_speed_cur = hm_get_fanspeed_with_device_id (i);
3460
3461 int fan_speed_level = fan_speed_cur;
3462
3463 if (fan_speed_chgd[i] == 0) fan_speed_level = temp_cur;
3464
3465 int fan_speed_new = fan_speed_level - fan_diff_required;
3466
3467 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3468 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3469
3470 if (fan_speed_new != fan_speed_cur)
3471 {
3472 int freely_change_fan_speed = (fan_speed_chgd[i] == 1);
3473 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3474
3475 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3476 {
3477 hm_set_fanspeed_with_device_id_amd (i, fan_speed_new);
3478
3479 fan_speed_chgd[i] = 1;
3480 }
3481
3482 temp_diff_old[i] = temp_diff_new;
3483 }
3484 }
3485 }
3486 }
3487 }
3488
3489 hc_thread_mutex_unlock (mux_adl);
3490 }
3491
3492 if (restore_check == 1)
3493 {
3494 restore_left--;
3495
3496 if (restore_left == 0)
3497 {
3498 if (data.restore_disable == 0) cycle_restore ();
3499
3500 restore_left = data.restore_timer;
3501 }
3502 }
3503
3504 if ((runtime_check == 1) && (data.runtime_start > 0))
3505 {
3506 time_t runtime_cur;
3507
3508 time (&runtime_cur);
3509
3510 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3511
3512 if (runtime_left <= 0)
3513 {
3514 if (data.benchmark == 0)
3515 {
3516 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3517 }
3518
3519 if (data.devices_status != STATUS_QUIT) myabort ();
3520 }
3521 }
3522
3523 if (remove_check == 1)
3524 {
3525 remove_left--;
3526
3527 if (remove_left == 0)
3528 {
3529 if (data.digests_saved != data.digests_done)
3530 {
3531 data.digests_saved = data.digests_done;
3532
3533 save_hash ();
3534 }
3535
3536 remove_left = data.remove_timer;
3537 }
3538 }
3539
3540 if (status_check == 1)
3541 {
3542 status_left--;
3543
3544 if (status_left == 0)
3545 {
3546 hc_thread_mutex_lock (mux_display);
3547
3548 if (data.quiet == 0) clear_prompt ();
3549
3550 if (data.quiet == 0) log_info ("");
3551
3552 status_display ();
3553
3554 if (data.quiet == 0) log_info ("");
3555
3556 hc_thread_mutex_unlock (mux_display);
3557
3558 status_left = data.status_timer;
3559 }
3560 }
3561 }
3562
3563 myfree (fan_speed_chgd);
3564
3565 myfree (temp_diff_old);
3566 myfree (temp_diff_sum);
3567
3568 p = NULL;
3569
3570 return (p);
3571 }
3572
3573 static void *thread_outfile_remove (void *p)
3574 {
3575 // some hash-dependent constants
3576 char *outfile_dir = data.outfile_check_directory;
3577 uint dgst_size = data.dgst_size;
3578 uint isSalted = data.isSalted;
3579 uint esalt_size = data.esalt_size;
3580 uint hash_mode = data.hash_mode;
3581
3582 uint outfile_check_timer = data.outfile_check_timer;
3583
3584 char separator = data.separator;
3585
3586 // some hash-dependent functions
3587 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3588 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3589
3590 // buffers
3591 hash_t hash_buf;
3592
3593 memset (&hash_buf, 0, sizeof (hash_buf));
3594
3595 hash_buf.digest = mymalloc (dgst_size);
3596
3597 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3598
3599 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3600
3601 uint digest_buf[64];
3602
3603 outfile_data_t *out_info = NULL;
3604
3605 char **out_files = NULL;
3606
3607 time_t folder_mtime = 0;
3608
3609 int out_cnt = 0;
3610
3611 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3612
3613 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3614 {
3615 hc_sleep (1);
3616
3617 if (data.devices_status != STATUS_RUNNING) continue;
3618
3619 check_left--;
3620
3621 if (check_left == 0)
3622 {
3623 struct stat outfile_check_stat;
3624
3625 if (stat (outfile_dir, &outfile_check_stat) == 0)
3626 {
3627 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3628
3629 if (is_dir == 1)
3630 {
3631 if (outfile_check_stat.st_mtime > folder_mtime)
3632 {
3633 char **out_files_new = scan_directory (outfile_dir);
3634
3635 int out_cnt_new = count_dictionaries (out_files_new);
3636
3637 outfile_data_t *out_info_new = NULL;
3638
3639 if (out_cnt_new > 0)
3640 {
3641 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3642
3643 for (int i = 0; i < out_cnt_new; i++)
3644 {
3645 out_info_new[i].file_name = out_files_new[i];
3646
3647 // check if there are files that we have seen/checked before (and not changed)
3648
3649 for (int j = 0; j < out_cnt; j++)
3650 {
3651 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
3652 {
3653 struct stat outfile_stat;
3654
3655 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
3656 {
3657 if (outfile_stat.st_ctime == out_info[j].ctime)
3658 {
3659 out_info_new[i].ctime = out_info[j].ctime;
3660 out_info_new[i].seek = out_info[j].seek;
3661 }
3662 }
3663 }
3664 }
3665 }
3666 }
3667
3668 local_free (out_info);
3669 local_free (out_files);
3670
3671 out_files = out_files_new;
3672 out_cnt = out_cnt_new;
3673 out_info = out_info_new;
3674
3675 folder_mtime = outfile_check_stat.st_mtime;
3676 }
3677
3678 for (int j = 0; j < out_cnt; j++)
3679 {
3680 FILE *fp = fopen (out_info[j].file_name, "rb");
3681
3682 if (fp != NULL)
3683 {
3684 //hc_thread_mutex_lock (mux_display);
3685
3686 #ifdef _POSIX
3687 struct stat outfile_stat;
3688
3689 fstat (fileno (fp), &outfile_stat);
3690 #endif
3691
3692 #ifdef _WIN
3693 struct stat64 outfile_stat;
3694
3695 _fstat64 (fileno (fp), &outfile_stat);
3696 #endif
3697
3698 if (outfile_stat.st_ctime > out_info[j].ctime)
3699 {
3700 out_info[j].ctime = outfile_stat.st_ctime;
3701 out_info[j].seek = 0;
3702 }
3703
3704 fseek (fp, out_info[j].seek, SEEK_SET);
3705
3706 while (!feof (fp))
3707 {
3708 char line_buf[BUFSIZ];
3709
3710 memset (line_buf, 0, BUFSIZ);
3711
3712 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
3713
3714 if (ptr == NULL) break;
3715
3716 int line_len = strlen (line_buf);
3717
3718 if (line_len <= 0) continue;
3719
3720 int iter = MAX_CUT_TRIES;
3721
3722 for (uint i = line_len - 1; i && iter; i--, line_len--)
3723 {
3724 if (line_buf[i] != separator) continue;
3725
3726 int parser_status = PARSER_OK;
3727
3728 if ((hash_mode != 2500) && (hash_mode != 6800))
3729 {
3730 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
3731 }
3732
3733 uint found = 0;
3734
3735 if (parser_status == PARSER_OK)
3736 {
3737 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
3738 {
3739 if (data.salts_shown[salt_pos] == 1) continue;
3740
3741 salt_t *salt_buf = &data.salts_buf[salt_pos];
3742
3743 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
3744 {
3745 uint idx = salt_buf->digests_offset + digest_pos;
3746
3747 if (data.digests_shown[idx] == 1) continue;
3748
3749 uint cracked = 0;
3750
3751 if (hash_mode == 6800)
3752 {
3753 if (i == salt_buf->salt_len)
3754 {
3755 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3756 }
3757 }
3758 else if (hash_mode == 2500)
3759 {
3760 // BSSID : MAC1 : MAC2 (:plain)
3761 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
3762 {
3763 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3764
3765 if (!cracked) continue;
3766
3767 // now compare MAC1 and MAC2 too, since we have this additional info
3768 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
3769 char *mac2_pos = mac1_pos + 12 + 1;
3770
3771 wpa_t *wpas = (wpa_t *) data.esalts_buf;
3772 wpa_t *wpa = &wpas[salt_pos];
3773
3774 uint pke[25];
3775
3776 char *pke_ptr = (char *) pke;
3777
3778 for (uint i = 0; i < 25; i++)
3779 {
3780 pke[i] = byte_swap_32 (wpa->pke[i]);
3781 }
3782
3783 unsigned char mac1[6];
3784 unsigned char mac2[6];
3785
3786 memcpy (mac1, pke_ptr + 23, 6);
3787 memcpy (mac2, pke_ptr + 29, 6);
3788
3789 // compare hex string(s) vs binary MAC address(es)
3790
3791 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3792 {
3793 if (mac1[i] != (unsigned char) hex_to_char (&mac1_pos[j]))
3794 {
3795 cracked = 0;
3796 break;
3797 }
3798 }
3799
3800 // early skip ;)
3801 if (!cracked) continue;
3802
3803 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3804 {
3805 if (mac2[i] != (unsigned char) hex_to_char (&mac2_pos[j]))
3806 {
3807 cracked = 0;
3808 break;
3809 }
3810 }
3811 }
3812 }
3813 else
3814 {
3815 char *digests_buf_ptr = (char *) data.digests_buf;
3816
3817 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
3818
3819 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
3820 }
3821
3822 if (cracked == 1)
3823 {
3824 found = 1;
3825
3826 data.digests_shown[idx] = 1;
3827
3828 data.digests_done++;
3829
3830 salt_buf->digests_done++;
3831
3832 if (salt_buf->digests_done == salt_buf->digests_cnt)
3833 {
3834 data.salts_shown[salt_pos] = 1;
3835
3836 data.salts_done++;
3837
3838 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
3839 }
3840 }
3841 }
3842
3843 if (data.devices_status == STATUS_CRACKED) break;
3844 }
3845 }
3846
3847 if (found) break;
3848
3849 if (data.devices_status == STATUS_CRACKED) break;
3850
3851 iter--;
3852 }
3853
3854 if (data.devices_status == STATUS_CRACKED) break;
3855 }
3856
3857 out_info[j].seek = ftell (fp);
3858
3859 //hc_thread_mutex_unlock (mux_display);
3860
3861 fclose (fp);
3862 }
3863 }
3864 }
3865 }
3866
3867 check_left = outfile_check_timer;
3868 }
3869 }
3870
3871 if (esalt_size) local_free (hash_buf.esalt);
3872
3873 if (isSalted) local_free (hash_buf.salt);
3874
3875 local_free (hash_buf.digest);
3876
3877 local_free (out_info);
3878
3879 local_free (out_files);
3880
3881 p = NULL;
3882
3883 return (p);
3884 }
3885
3886 static uint get_work (hc_device_param_t *device_param, const uint64_t max)
3887 {
3888 hc_thread_mutex_lock (mux_dispatcher);
3889
3890 const uint64_t words_cur = data.words_cur;
3891 const uint64_t words_base = (data.limit == 0) ? data.words_base : data.limit;
3892
3893 device_param->words_off = words_cur;
3894
3895 const uint64_t words_left = words_base - words_cur;
3896
3897 if (data.kernel_blocks_all > words_left)
3898 {
3899 if (data.kernel_blocks_div == 0)
3900 {
3901 data.kernel_blocks_div = find_kernel_blocks_div (words_left, data.kernel_blocks_all);
3902 }
3903 }
3904
3905 if (data.kernel_blocks_div)
3906 {
3907 if (device_param->kernel_blocks == device_param->kernel_blocks_user)
3908 {
3909 const uint32_t kernel_blocks_new = (float) device_param->kernel_blocks * data.kernel_blocks_div;
3910 const uint32_t kernel_power_new = kernel_blocks_new;
3911
3912 if (kernel_blocks_new < device_param->kernel_blocks)
3913 {
3914 device_param->kernel_blocks = kernel_blocks_new;
3915 device_param->kernel_power = kernel_power_new;
3916 }
3917 }
3918 }
3919
3920 const uint kernel_blocks = device_param->kernel_blocks;
3921
3922 uint work = MIN (words_left, kernel_blocks);
3923
3924 work = MIN (work, max);
3925
3926 data.words_cur += work;
3927
3928 hc_thread_mutex_unlock (mux_dispatcher);
3929
3930 return work;
3931 }
3932
3933 static void *thread_calc_stdin (void *p)
3934 {
3935 hc_device_param_t *device_param = (hc_device_param_t *) p;
3936
3937 const uint attack_kern = data.attack_kern;
3938
3939 const uint kernel_blocks = device_param->kernel_blocks;
3940
3941 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3942 {
3943 hc_thread_mutex_lock (mux_dispatcher);
3944
3945 if (feof (stdin) != 0)
3946 {
3947 hc_thread_mutex_unlock (mux_dispatcher);
3948
3949 break;
3950 }
3951
3952 uint words_cur = 0;
3953
3954 while (words_cur < kernel_blocks)
3955 {
3956 char buf[BUFSIZ];
3957
3958 char *line_buf = fgets (buf, sizeof (buf), stdin);
3959
3960 if (line_buf == NULL) break;
3961
3962 uint line_len = in_superchop (line_buf);
3963
3964 line_len = convert_from_hex (line_buf, line_len);
3965
3966 // post-process rule engine
3967
3968 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3969 {
3970 char rule_buf_out[BLOCK_SIZE];
3971
3972 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3973
3974 int rule_len_out = -1;
3975
3976 if (line_len < BLOCK_SIZE)
3977 {
3978 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
3979 }
3980
3981 if (rule_len_out < 0) continue;
3982
3983 line_buf = rule_buf_out;
3984 line_len = rule_len_out;
3985 }
3986
3987 if (line_len > PW_MAX)
3988 {
3989 continue;
3990 }
3991
3992 if (attack_kern == ATTACK_KERN_STRAIGHT)
3993 {
3994 if ((line_len < data.pw_min) || (line_len > data.pw_max))
3995 {
3996 hc_thread_mutex_lock (mux_counter);
3997
3998 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3999 {
4000 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4001 }
4002
4003 hc_thread_mutex_unlock (mux_counter);
4004
4005 continue;
4006 }
4007 }
4008 else if (attack_kern == ATTACK_KERN_COMBI)
4009 {
4010 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4011 // since we still need to combine the plains
4012
4013 if (line_len > data.pw_max)
4014 {
4015 hc_thread_mutex_lock (mux_counter);
4016
4017 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4018 {
4019 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4020 }
4021
4022 hc_thread_mutex_unlock (mux_counter);
4023
4024 continue;
4025 }
4026 }
4027
4028 device_param->pw_add (device_param, (uint8_t *) line_buf, line_len);
4029
4030 words_cur++;
4031
4032 if (data.devices_status == STATUS_CRACKED) break;
4033 if (data.devices_status == STATUS_ABORTED) break;
4034 if (data.devices_status == STATUS_QUIT) break;
4035 if (data.devices_status == STATUS_BYPASS) break;
4036 }
4037
4038 hc_thread_mutex_unlock (mux_dispatcher);
4039
4040 if (data.devices_status == STATUS_CRACKED) break;
4041 if (data.devices_status == STATUS_ABORTED) break;
4042 if (data.devices_status == STATUS_QUIT) break;
4043 if (data.devices_status == STATUS_BYPASS) break;
4044
4045 // we need 2 flushing because we have two independant caches and it can occur
4046 // that one buffer is already at threshold plus for that length also exists
4047 // more data in the 2nd buffer so it would overflow
4048
4049 // flush session 1
4050
4051 {
4052 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4053 {
4054 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4055
4056 const uint pw_cache_cnt = pw_cache->cnt;
4057
4058 if (pw_cache_cnt == 0) continue;
4059
4060 pw_cache->cnt = 0;
4061
4062 uint pws_cnt = device_param->pws_cnt;
4063
4064 pw_t *pw = device_param->pws_buf + pws_cnt;
4065
4066 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4067
4068 pw->pw_len = pw_len;
4069
4070 uint pw_cnt = device_param->pw_cnt;
4071
4072 pw_cnt += pw_cache_cnt;
4073
4074 device_param->pw_cnt = pw_cnt;
4075
4076 pws_cnt++;
4077
4078 device_param->pws_cnt = pws_cnt;
4079
4080 if (pws_cnt == device_param->kernel_power_user) break;
4081 }
4082
4083 const uint pw_cnt = device_param->pw_cnt;
4084 const uint pws_cnt = device_param->pws_cnt;
4085
4086 if (pws_cnt)
4087 {
4088 run_copy (device_param, pws_cnt);
4089
4090 run_cracker (device_param, pw_cnt, pws_cnt);
4091
4092 device_param->pw_cnt = 0;
4093 device_param->pws_cnt = 0;
4094 }
4095 }
4096
4097 // flush session 2
4098
4099 {
4100 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4101 {
4102 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4103
4104 const uint pw_cache_cnt = pw_cache->cnt;
4105
4106 if (pw_cache_cnt == 0) continue;
4107
4108 pw_cache->cnt = 0;
4109
4110 uint pws_cnt = device_param->pws_cnt;
4111
4112 pw_t *pw = device_param->pws_buf + pws_cnt;
4113
4114 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4115
4116 pw->pw_len = pw_len;
4117
4118 uint pw_cnt = device_param->pw_cnt;
4119
4120 pw_cnt += pw_cache_cnt;
4121
4122 device_param->pw_cnt = pw_cnt;
4123
4124 pws_cnt++;
4125
4126 device_param->pws_cnt = pws_cnt;
4127 }
4128
4129 const uint pw_cnt = device_param->pw_cnt;
4130 const uint pws_cnt = device_param->pws_cnt;
4131
4132 if (pws_cnt)
4133 {
4134 run_copy (device_param, pws_cnt);
4135
4136 run_cracker (device_param, pw_cnt, pws_cnt);
4137
4138 device_param->pw_cnt = 0;
4139 device_param->pws_cnt = 0;
4140 }
4141 }
4142 }
4143
4144 return NULL;
4145 }
4146
4147 static void *thread_calc (void *p)
4148 {
4149 hc_device_param_t *device_param = (hc_device_param_t *) p;
4150
4151 const uint attack_mode = data.attack_mode;
4152 const uint attack_kern = data.attack_kern;
4153
4154 if (attack_mode == ATTACK_MODE_BF)
4155 {
4156 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4157 {
4158 const uint work = get_work (device_param, -1);
4159
4160 if (work == 0) break;
4161
4162 const uint64_t words_off = device_param->words_off;
4163 const uint64_t words_fin = words_off + work;
4164
4165 const uint pw_cnt = work;
4166 const uint pws_cnt = work;
4167
4168 device_param->pw_cnt = pw_cnt;
4169 device_param->pws_cnt = pws_cnt;
4170
4171 if (pws_cnt)
4172 {
4173 run_copy (device_param, pws_cnt);
4174
4175 run_cracker (device_param, pw_cnt, pws_cnt);
4176
4177 device_param->pw_cnt = 0;
4178 device_param->pws_cnt = 0;
4179 }
4180
4181 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4182
4183 if (data.devices_status == STATUS_CRACKED) break;
4184 if (data.devices_status == STATUS_ABORTED) break;
4185 if (data.devices_status == STATUS_QUIT) break;
4186 if (data.devices_status == STATUS_BYPASS) break;
4187
4188 device_param->words_done = words_fin;
4189 }
4190 }
4191 else
4192 {
4193 const uint segment_size = data.segment_size;
4194
4195 char *dictfile = data.dictfile;
4196
4197 if (attack_mode == ATTACK_MODE_COMBI)
4198 {
4199 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4200 {
4201 dictfile = data.dictfile2;
4202 }
4203 }
4204
4205 FILE *fd = fopen (dictfile, "rb");
4206
4207 if (fd == NULL)
4208 {
4209 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4210
4211 return NULL;
4212 }
4213
4214 if (attack_mode == ATTACK_MODE_COMBI)
4215 {
4216 const uint combs_mode = data.combs_mode;
4217
4218 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4219 {
4220 const char *dictfilec = data.dictfile2;
4221
4222 FILE *combs_fp = fopen (dictfilec, "rb");
4223
4224 if (combs_fp == NULL)
4225 {
4226 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4227
4228 fclose (fd);
4229
4230 return NULL;
4231 }
4232
4233 device_param->combs_fp = combs_fp;
4234 }
4235 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4236 {
4237 const char *dictfilec = data.dictfile;
4238
4239 FILE *combs_fp = fopen (dictfilec, "rb");
4240
4241 if (combs_fp == NULL)
4242 {
4243 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4244
4245 fclose (fd);
4246
4247 return NULL;
4248 }
4249
4250 device_param->combs_fp = combs_fp;
4251 }
4252 }
4253
4254 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4255
4256 wl_data->buf = (char *) mymalloc (segment_size);
4257 wl_data->avail = segment_size;
4258 wl_data->incr = segment_size;
4259 wl_data->cnt = 0;
4260 wl_data->pos = 0;
4261
4262 uint64_t words_cur = 0;
4263
4264 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4265 {
4266 uint64_t words_off = 0;
4267 uint64_t words_fin = 0;
4268
4269 uint64_t max = -1;
4270
4271 while (max)
4272 {
4273 const uint work = get_work (device_param, max);
4274
4275 if (work == 0) break;
4276
4277 words_off = device_param->words_off;
4278 words_fin = words_off + work;
4279
4280 char *line_buf;
4281 uint line_len;
4282
4283 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4284
4285 max = 0;
4286
4287 for ( ; words_cur < words_fin; words_cur++)
4288 {
4289 get_next_word (wl_data, fd, &line_buf, &line_len);
4290
4291 line_len = convert_from_hex (line_buf, line_len);
4292
4293 // post-process rule engine
4294
4295 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4296 {
4297 char rule_buf_out[BLOCK_SIZE];
4298
4299 memset (rule_buf_out, 0, sizeof (rule_buf_out));
4300
4301 int rule_len_out = -1;
4302
4303 if (line_len < BLOCK_SIZE)
4304 {
4305 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4306 }
4307
4308 if (rule_len_out < 0) continue;
4309
4310 line_buf = rule_buf_out;
4311 line_len = rule_len_out;
4312 }
4313
4314 if (attack_kern == ATTACK_KERN_STRAIGHT)
4315 {
4316 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4317 {
4318 max++;
4319
4320 hc_thread_mutex_lock (mux_counter);
4321
4322 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4323 {
4324 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4325 }
4326
4327 hc_thread_mutex_unlock (mux_counter);
4328
4329 continue;
4330 }
4331 }
4332 else if (attack_kern == ATTACK_KERN_COMBI)
4333 {
4334 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4335 // since we still need to combine the plains
4336
4337 if (line_len > data.pw_max)
4338 {
4339 max++;
4340
4341 hc_thread_mutex_lock (mux_counter);
4342
4343 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4344 {
4345 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4346 }
4347
4348 hc_thread_mutex_unlock (mux_counter);
4349
4350 continue;
4351 }
4352 }
4353
4354 device_param->pw_add (device_param, (uint8_t *) line_buf, line_len);
4355
4356 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4357
4358 if (data.devices_status == STATUS_CRACKED) break;
4359 if (data.devices_status == STATUS_ABORTED) break;
4360 if (data.devices_status == STATUS_QUIT) break;
4361 if (data.devices_status == STATUS_BYPASS) break;
4362 }
4363
4364 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4365
4366 if (data.devices_status == STATUS_CRACKED) break;
4367 if (data.devices_status == STATUS_ABORTED) break;
4368 if (data.devices_status == STATUS_QUIT) break;
4369 if (data.devices_status == STATUS_BYPASS) break;
4370 }
4371
4372 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4373
4374 if (data.devices_status == STATUS_CRACKED) break;
4375 if (data.devices_status == STATUS_ABORTED) break;
4376 if (data.devices_status == STATUS_QUIT) break;
4377 if (data.devices_status == STATUS_BYPASS) break;
4378
4379 // we need 2 flushing because we have two independant caches and it can occur
4380 // that one buffer is already at threshold plus for that length also exists
4381 // more data in the 2nd buffer so it would overflow
4382
4383 //
4384 // flush session 1
4385 //
4386
4387 {
4388 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4389 {
4390 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4391
4392 const uint pw_cache_cnt = pw_cache->cnt;
4393
4394 if (pw_cache_cnt == 0) continue;
4395
4396 pw_cache->cnt = 0;
4397
4398 uint pws_cnt = device_param->pws_cnt;
4399
4400 pw_t *pw = device_param->pws_buf + pws_cnt;
4401
4402 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4403
4404 pw->pw_len = pw_len;
4405
4406 uint pw_cnt = device_param->pw_cnt;
4407
4408 pw_cnt += pw_cache_cnt;
4409
4410 device_param->pw_cnt = pw_cnt;
4411
4412 pws_cnt++;
4413
4414 device_param->pws_cnt = pws_cnt;
4415
4416 if (pws_cnt == device_param->kernel_power_user) break;
4417 }
4418
4419 const uint pw_cnt = device_param->pw_cnt;
4420 const uint pws_cnt = device_param->pws_cnt;
4421
4422 if (pws_cnt)
4423 {
4424 run_copy (device_param, pws_cnt);
4425
4426 run_cracker (device_param, pw_cnt, pws_cnt);
4427
4428 device_param->pw_cnt = 0;
4429 device_param->pws_cnt = 0;
4430 }
4431
4432 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4433
4434 if (data.devices_status == STATUS_CRACKED) break;
4435 if (data.devices_status == STATUS_ABORTED) break;
4436 if (data.devices_status == STATUS_QUIT) break;
4437 if (data.devices_status == STATUS_BYPASS) break;
4438 }
4439
4440 //
4441 // flush session 2
4442 //
4443
4444 {
4445 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4446 {
4447 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4448
4449 const uint pw_cache_cnt = pw_cache->cnt;
4450
4451 if (pw_cache_cnt == 0) continue;
4452
4453 pw_cache->cnt = 0;
4454
4455 uint pws_cnt = device_param->pws_cnt;
4456
4457 pw_t *pw = device_param->pws_buf + pws_cnt;
4458
4459 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4460
4461 pw->pw_len = pw_len;
4462
4463 uint pw_cnt = device_param->pw_cnt;
4464
4465 pw_cnt += pw_cache_cnt;
4466
4467 device_param->pw_cnt = pw_cnt;
4468
4469 pws_cnt++;
4470
4471 device_param->pws_cnt = pws_cnt;
4472 }
4473
4474 const uint pw_cnt = device_param->pw_cnt;
4475 const uint pws_cnt = device_param->pws_cnt;
4476
4477 if (pws_cnt)
4478 {
4479 run_copy (device_param, pws_cnt);
4480
4481 run_cracker (device_param, pw_cnt, pws_cnt);
4482
4483 device_param->pw_cnt = 0;
4484 device_param->pws_cnt = 0;
4485 }
4486
4487 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4488
4489 if (data.devices_status == STATUS_CRACKED) break;
4490 if (data.devices_status == STATUS_ABORTED) break;
4491 if (data.devices_status == STATUS_QUIT) break;
4492 if (data.devices_status == STATUS_BYPASS) break;
4493 }
4494
4495 if (words_fin == 0) break;
4496
4497 device_param->words_done = words_fin;
4498 }
4499
4500 if (attack_mode == ATTACK_MODE_COMBI)
4501 {
4502 fclose (device_param->combs_fp);
4503 }
4504
4505 free (wl_data->buf);
4506 free (wl_data);
4507
4508 fclose (fd);
4509 }
4510
4511 return NULL;
4512 }
4513
4514 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos, const uint kernel_loops)
4515 {
4516 salt_t *salt_buf = &data.salts_buf[salt_pos];
4517
4518 device_param->kernel_params_buf32[24] = salt_pos;
4519 device_param->kernel_params_buf32[27] = 1;
4520 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4521 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4522 device_param->kernel_params_buf32[30] = 0;
4523 device_param->kernel_params_buf32[31] = 1;
4524
4525 char *dictfile_old = data.dictfile;
4526 char *dictfile2_old = data.dictfile2;
4527 char *mask_old = data.mask;
4528
4529 const char *weak_hash_check = "weak-hash-check";
4530
4531 data.dictfile = (char *) weak_hash_check;
4532 data.dictfile2 = (char *) weak_hash_check;
4533 data.mask = (char *) weak_hash_check;
4534
4535 /**
4536 * run the kernel
4537 */
4538
4539 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4540 {
4541 run_kernel (KERN_RUN_1, device_param, 1);
4542 }
4543 else
4544 {
4545 run_kernel (KERN_RUN_1, device_param, 1);
4546
4547 const uint iter = salt_buf->salt_iter;
4548
4549 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
4550 {
4551 uint loop_left = iter - loop_pos;
4552
4553 loop_left = MIN (loop_left, kernel_loops);
4554
4555 device_param->kernel_params_buf32[25] = loop_pos;
4556 device_param->kernel_params_buf32[26] = loop_left;
4557
4558 run_kernel (KERN_RUN_2, device_param, 1);
4559 }
4560
4561 run_kernel (KERN_RUN_3, device_param, 1);
4562 }
4563
4564 /**
4565 * result
4566 */
4567
4568 check_cracked (device_param, salt_pos);
4569
4570 /**
4571 * cleanup
4572 */
4573
4574 device_param->kernel_params_buf32[24] = 0;
4575 device_param->kernel_params_buf32[25] = 0;
4576 device_param->kernel_params_buf32[26] = 0;
4577 device_param->kernel_params_buf32[27] = 0;
4578 device_param->kernel_params_buf32[28] = 0;
4579 device_param->kernel_params_buf32[29] = 0;
4580 device_param->kernel_params_buf32[30] = 0;
4581 device_param->kernel_params_buf32[31] = 0;
4582
4583 data.dictfile = dictfile_old;
4584 data.dictfile2 = dictfile2_old;
4585 data.mask = mask_old;
4586 }
4587
4588 // hlfmt hashcat
4589
4590 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4591 {
4592 if (data.username == 0)
4593 {
4594 *hashbuf_pos = line_buf;
4595 *hashbuf_len = line_len;
4596 }
4597 else
4598 {
4599 char *pos = line_buf;
4600 int len = line_len;
4601
4602 for (int i = 0; i < line_len; i++, pos++, len--)
4603 {
4604 if (line_buf[i] == data.separator)
4605 {
4606 pos++;
4607
4608 len--;
4609
4610 break;
4611 }
4612 }
4613
4614 *hashbuf_pos = pos;
4615 *hashbuf_len = len;
4616 }
4617 }
4618
4619 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4620 {
4621 char *pos = NULL;
4622 int len = 0;
4623
4624 int sep_cnt = 0;
4625
4626 for (int i = 0; i < line_len; i++)
4627 {
4628 if (line_buf[i] == data.separator)
4629 {
4630 sep_cnt++;
4631
4632 continue;
4633 }
4634
4635 if (sep_cnt == 0)
4636 {
4637 if (pos == NULL) pos = line_buf + i;
4638
4639 len++;
4640 }
4641 }
4642
4643 *userbuf_pos = pos;
4644 *userbuf_len = len;
4645 }
4646
4647 // hlfmt pwdump
4648
4649 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
4650 {
4651 int sep_cnt = 0;
4652
4653 int sep2_len = 0;
4654 int sep3_len = 0;
4655
4656 for (int i = 0; i < line_len; i++)
4657 {
4658 if (line_buf[i] == ':')
4659 {
4660 sep_cnt++;
4661
4662 continue;
4663 }
4664
4665 if (sep_cnt == 2) sep2_len++;
4666 if (sep_cnt == 3) sep3_len++;
4667 }
4668
4669 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4670
4671 return 0;
4672 }
4673
4674 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4675 {
4676 char *pos = NULL;
4677 int len = 0;
4678
4679 int sep_cnt = 0;
4680
4681 for (int i = 0; i < line_len; i++)
4682 {
4683 if (line_buf[i] == ':')
4684 {
4685 sep_cnt++;
4686
4687 continue;
4688 }
4689
4690 if (data.hash_mode == 1000)
4691 {
4692 if (sep_cnt == 3)
4693 {
4694 if (pos == NULL) pos = line_buf + i;
4695
4696 len++;
4697 }
4698 }
4699 else if (data.hash_mode == 3000)
4700 {
4701 if (sep_cnt == 2)
4702 {
4703 if (pos == NULL) pos = line_buf + i;
4704
4705 len++;
4706 }
4707 }
4708 }
4709
4710 *hashbuf_pos = pos;
4711 *hashbuf_len = len;
4712 }
4713
4714 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4715 {
4716 char *pos = NULL;
4717 int len = 0;
4718
4719 int sep_cnt = 0;
4720
4721 for (int i = 0; i < line_len; i++)
4722 {
4723 if (line_buf[i] == ':')
4724 {
4725 sep_cnt++;
4726
4727 continue;
4728 }
4729
4730 if (sep_cnt == 0)
4731 {
4732 if (pos == NULL) pos = line_buf + i;
4733
4734 len++;
4735 }
4736 }
4737
4738 *userbuf_pos = pos;
4739 *userbuf_len = len;
4740 }
4741
4742 // hlfmt passwd
4743
4744 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
4745 {
4746 int sep_cnt = 0;
4747
4748 char sep5_first = 0;
4749 char sep6_first = 0;
4750
4751 for (int i = 0; i < line_len; i++)
4752 {
4753 if (line_buf[i] == ':')
4754 {
4755 sep_cnt++;
4756
4757 continue;
4758 }
4759
4760 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
4761 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
4762 }
4763
4764 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
4765
4766 return 0;
4767 }
4768
4769 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4770 {
4771 char *pos = NULL;
4772 int len = 0;
4773
4774 int sep_cnt = 0;
4775
4776 for (int i = 0; i < line_len; i++)
4777 {
4778 if (line_buf[i] == ':')
4779 {
4780 sep_cnt++;
4781
4782 continue;
4783 }
4784
4785 if (sep_cnt == 1)
4786 {
4787 if (pos == NULL) pos = line_buf + i;
4788
4789 len++;
4790 }
4791 }
4792
4793 *hashbuf_pos = pos;
4794 *hashbuf_len = len;
4795 }
4796
4797 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4798 {
4799 char *pos = NULL;
4800 int len = 0;
4801
4802 int sep_cnt = 0;
4803
4804 for (int i = 0; i < line_len; i++)
4805 {
4806 if (line_buf[i] == ':')
4807 {
4808 sep_cnt++;
4809
4810 continue;
4811 }
4812
4813 if (sep_cnt == 0)
4814 {
4815 if (pos == NULL) pos = line_buf + i;
4816
4817 len++;
4818 }
4819 }
4820
4821 *userbuf_pos = pos;
4822 *userbuf_len = len;
4823 }
4824
4825 // hlfmt shadow
4826
4827 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
4828 {
4829 int sep_cnt = 0;
4830
4831 for (int i = 0; i < line_len; i++)
4832 {
4833 if (line_buf[i] == ':') sep_cnt++;
4834 }
4835
4836 if (sep_cnt == 8) return 1;
4837
4838 return 0;
4839 }
4840
4841 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4842 {
4843 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
4844 }
4845
4846 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4847 {
4848 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
4849 }
4850
4851 // hlfmt main
4852
4853 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4854 {
4855 switch (hashfile_format)
4856 {
4857 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4858 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4859 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4860 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4861 }
4862 }
4863
4864 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4865 {
4866 switch (hashfile_format)
4867 {
4868 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
4869 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
4870 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
4871 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
4872 }
4873 }
4874
4875 static uint hlfmt_detect (FILE *fp, uint max_check)
4876 {
4877 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
4878
4879 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
4880 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
4881
4882 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
4883
4884 uint num_check = 0;
4885
4886 while (!feof (fp))
4887 {
4888 char line_buf[BUFSIZ];
4889
4890 int line_len = fgetl (fp, line_buf);
4891
4892 if (line_len == 0) continue;
4893
4894 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
4895 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
4896 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
4897
4898 if (num_check == max_check) break;
4899
4900 num_check++;
4901 }
4902
4903 uint hashlist_format = HLFMT_HASHCAT;
4904
4905 for (int i = 1; i < HLFMTS_CNT; i++)
4906 {
4907 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
4908
4909 hashlist_format = i;
4910 }
4911
4912 free (formats_cnt);
4913
4914 return hashlist_format;
4915 }
4916
4917 /**
4918 * some further helper function
4919 */
4920
4921 // wrapper around mymalloc for ADL
4922
4923 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
4924 {
4925 return mymalloc (iSize);
4926 }
4927
4928 static uint generate_bitmaps (const uint digests_cnt, const uint dgst_size, const uint dgst_shifts, char *digests_buf_ptr, const uint bitmap_mask, const uint bitmap_size, uint *bitmap_a, uint *bitmap_b, uint *bitmap_c, uint *bitmap_d, const uint64_t collisions_max)
4929 {
4930 uint64_t collisions = 0;
4931
4932 const uint dgst_pos0 = data.dgst_pos0;
4933 const uint dgst_pos1 = data.dgst_pos1;
4934 const uint dgst_pos2 = data.dgst_pos2;
4935 const uint dgst_pos3 = data.dgst_pos3;
4936
4937 memset (bitmap_a, 0, bitmap_size);
4938 memset (bitmap_b, 0, bitmap_size);
4939 memset (bitmap_c, 0, bitmap_size);
4940 memset (bitmap_d, 0, bitmap_size);
4941
4942 for (uint i = 0; i < digests_cnt; i++)
4943 {
4944 uint *digest_ptr = (uint *) digests_buf_ptr;
4945
4946 digests_buf_ptr += dgst_size;
4947
4948 const uint val0 = 1 << (digest_ptr[dgst_pos0] & 0x1f);
4949 const uint val1 = 1 << (digest_ptr[dgst_pos1] & 0x1f);
4950 const uint val2 = 1 << (digest_ptr[dgst_pos2] & 0x1f);
4951 const uint val3 = 1 << (digest_ptr[dgst_pos3] & 0x1f);
4952
4953 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
4954 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
4955 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
4956 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
4957
4958 if (bitmap_a[idx0] & val0) collisions++;
4959 if (bitmap_b[idx1] & val1) collisions++;
4960 if (bitmap_c[idx2] & val2) collisions++;
4961 if (bitmap_d[idx3] & val3) collisions++;
4962
4963 bitmap_a[idx0] |= val0;
4964 bitmap_b[idx1] |= val1;
4965 bitmap_c[idx2] |= val2;
4966 bitmap_d[idx3] |= val3;
4967
4968 if (collisions >= collisions_max) return 0x7fffffff;
4969 }
4970
4971 return collisions;
4972 }
4973
4974 /**
4975 * main
4976 */
4977
4978 int main (int argc, char **argv)
4979 {
4980 /**
4981 * To help users a bit
4982 */
4983
4984 char *compute = getenv ("COMPUTE");
4985
4986 if (compute)
4987 {
4988 char display[100];
4989
4990 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
4991
4992 putenv (display);
4993 }
4994 else
4995 {
4996 if (getenv ("DISPLAY") == NULL)
4997 putenv ((char *) "DISPLAY=:0");
4998 }
4999
5000 /*
5001 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5002 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5003
5004 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5005 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5006 */
5007
5008 /**
5009 * Real init
5010 */
5011
5012 memset (&data, 0, sizeof (hc_global_data_t));
5013
5014 time_t proc_start;
5015
5016 time (&proc_start);
5017
5018 data.proc_start = proc_start;
5019
5020 int myargc = argc;
5021 char **myargv = argv;
5022
5023 hc_thread_mutex_init (mux_dispatcher);
5024 hc_thread_mutex_init (mux_counter);
5025 hc_thread_mutex_init (mux_display);
5026 hc_thread_mutex_init (mux_adl);
5027
5028 /**
5029 * commandline parameters
5030 */
5031
5032 uint usage = USAGE;
5033 uint version = VERSION;
5034 uint quiet = QUIET;
5035 uint benchmark = BENCHMARK;
5036 uint benchmark_mode = BENCHMARK_MODE;
5037 uint show = SHOW;
5038 uint left = LEFT;
5039 uint username = USERNAME;
5040 uint remove = REMOVE;
5041 uint remove_timer = REMOVE_TIMER;
5042 uint64_t skip = SKIP;
5043 uint64_t limit = LIMIT;
5044 uint keyspace = KEYSPACE;
5045 uint potfile_disable = POTFILE_DISABLE;
5046 uint debug_mode = DEBUG_MODE;
5047 char *debug_file = NULL;
5048 char *induction_dir = NULL;
5049 char *outfile_check_dir = NULL;
5050 uint force = FORCE;
5051 uint runtime = RUNTIME;
5052 uint hash_mode = HASH_MODE;
5053 uint attack_mode = ATTACK_MODE;
5054 uint markov_disable = MARKOV_DISABLE;
5055 uint markov_classic = MARKOV_CLASSIC;
5056 uint markov_threshold = MARKOV_THRESHOLD;
5057 char *markov_hcstat = NULL;
5058 char *outfile = NULL;
5059 uint outfile_format = OUTFILE_FORMAT;
5060 uint outfile_autohex = OUTFILE_AUTOHEX;
5061 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5062 uint restore = RESTORE;
5063 uint restore_timer = RESTORE_TIMER;
5064 uint restore_disable = RESTORE_DISABLE;
5065 uint status = STATUS;
5066 uint status_timer = STATUS_TIMER;
5067 uint status_automat = STATUS_AUTOMAT;
5068 uint loopback = LOOPBACK;
5069 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5070 char *session = NULL;
5071 uint hex_charset = HEX_CHARSET;
5072 uint hex_salt = HEX_SALT;
5073 uint hex_wordlist = HEX_WORDLIST;
5074 uint rp_gen = RP_GEN;
5075 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5076 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5077 uint rp_gen_seed = RP_GEN_SEED;
5078 char *rule_buf_l = (char *) RULE_BUF_L;
5079 char *rule_buf_r = (char *) RULE_BUF_R;
5080 uint increment = INCREMENT;
5081 uint increment_min = INCREMENT_MIN;
5082 uint increment_max = INCREMENT_MAX;
5083 char *cpu_affinity = NULL;
5084 char *opencl_devices = NULL;
5085 char *opencl_platform = NULL;
5086 char *truecrypt_keyfiles = NULL;
5087 uint workload_profile = WORKLOAD_PROFILE;
5088 uint kernel_accel = KERNEL_ACCEL;
5089 uint kernel_loops = KERNEL_LOOPS;
5090 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5091 uint gpu_temp_abort = GPU_TEMP_ABORT;
5092 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5093 uint powertune_enable = POWERTUNE_ENABLE;
5094 uint logfile_disable = LOGFILE_DISABLE;
5095 uint segment_size = SEGMENT_SIZE;
5096 uint scrypt_tmto = SCRYPT_TMTO;
5097 char separator = SEPARATOR;
5098 uint bitmap_min = BITMAP_MIN;
5099 uint bitmap_max = BITMAP_MAX;
5100 char *custom_charset_1 = NULL;
5101 char *custom_charset_2 = NULL;
5102 char *custom_charset_3 = NULL;
5103 char *custom_charset_4 = NULL;
5104
5105 #define IDX_HELP 'h'
5106 #define IDX_VERSION 'V'
5107 #define IDX_VERSION_LOWER 'v'
5108 #define IDX_QUIET 0xff02
5109 #define IDX_SHOW 0xff03
5110 #define IDX_LEFT 0xff04
5111 #define IDX_REMOVE 0xff05
5112 #define IDX_REMOVE_TIMER 0xff37
5113 #define IDX_SKIP 's'
5114 #define IDX_LIMIT 'l'
5115 #define IDX_KEYSPACE 0xff35
5116 #define IDX_POTFILE_DISABLE 0xff06
5117 #define IDX_DEBUG_MODE 0xff43
5118 #define IDX_DEBUG_FILE 0xff44
5119 #define IDX_INDUCTION_DIR 0xff46
5120 #define IDX_OUTFILE_CHECK_DIR 0xff47
5121 #define IDX_USERNAME 0xff07
5122 #define IDX_FORCE 0xff08
5123 #define IDX_RUNTIME 0xff09
5124 #define IDX_BENCHMARK 'b'
5125 #define IDX_BENCHMARK_MODE 0xff32
5126 #define IDX_HASH_MODE 'm'
5127 #define IDX_ATTACK_MODE 'a'
5128 #define IDX_RP_FILE 'r'
5129 #define IDX_RP_GEN 'g'
5130 #define IDX_RP_GEN_FUNC_MIN 0xff10
5131 #define IDX_RP_GEN_FUNC_MAX 0xff11
5132 #define IDX_RP_GEN_SEED 0xff34
5133 #define IDX_RULE_BUF_L 'j'
5134 #define IDX_RULE_BUF_R 'k'
5135 #define IDX_INCREMENT 'i'
5136 #define IDX_INCREMENT_MIN 0xff12
5137 #define IDX_INCREMENT_MAX 0xff13
5138 #define IDX_OUTFILE 'o'
5139 #define IDX_OUTFILE_FORMAT 0xff14
5140 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5141 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5142 #define IDX_RESTORE 0xff15
5143 #define IDX_RESTORE_DISABLE 0xff27
5144 #define IDX_STATUS 0xff17
5145 #define IDX_STATUS_TIMER 0xff18
5146 #define IDX_STATUS_AUTOMAT 0xff50
5147 #define IDX_LOOPBACK 0xff38
5148 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5149 #define IDX_SESSION 0xff19
5150 #define IDX_HEX_CHARSET 0xff20
5151 #define IDX_HEX_SALT 0xff21
5152 #define IDX_HEX_WORDLIST 0xff40
5153 #define IDX_MARKOV_DISABLE 0xff22
5154 #define IDX_MARKOV_CLASSIC 0xff23
5155 #define IDX_MARKOV_THRESHOLD 't'
5156 #define IDX_MARKOV_HCSTAT 0xff24
5157 #define IDX_CPU_AFFINITY 0xff25
5158 #define IDX_OPENCL_DEVICES 'd'
5159 #define IDX_OPENCL_PLATFORM 0xff72
5160 #define IDX_WORKLOAD_PROFILE 'w'
5161 #define IDX_KERNEL_ACCEL 'n'
5162 #define IDX_KERNEL_LOOPS 'u'
5163 #define IDX_GPU_TEMP_DISABLE 0xff29
5164 #define IDX_GPU_TEMP_ABORT 0xff30
5165 #define IDX_GPU_TEMP_RETAIN 0xff31
5166 #define IDX_POWERTUNE_ENABLE 0xff41
5167 #define IDX_LOGFILE_DISABLE 0xff51
5168 #define IDX_TRUECRYPT_KEYFILES 0xff52
5169 #define IDX_SCRYPT_TMTO 0xff61
5170 #define IDX_SEGMENT_SIZE 'c'
5171 #define IDX_SEPARATOR 'p'
5172 #define IDX_BITMAP_MIN 0xff70
5173 #define IDX_BITMAP_MAX 0xff71
5174 #define IDX_CUSTOM_CHARSET_1 '1'
5175 #define IDX_CUSTOM_CHARSET_2 '2'
5176 #define IDX_CUSTOM_CHARSET_3 '3'
5177 #define IDX_CUSTOM_CHARSET_4 '4'
5178
5179 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5180
5181 struct option long_options[] =
5182 {
5183 {"help", no_argument, 0, IDX_HELP},
5184 {"version", no_argument, 0, IDX_VERSION},
5185 {"quiet", no_argument, 0, IDX_QUIET},
5186 {"show", no_argument, 0, IDX_SHOW},
5187 {"left", no_argument, 0, IDX_LEFT},
5188 {"username", no_argument, 0, IDX_USERNAME},
5189 {"remove", no_argument, 0, IDX_REMOVE},
5190 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5191 {"skip", required_argument, 0, IDX_SKIP},
5192 {"limit", required_argument, 0, IDX_LIMIT},
5193 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5194 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5195 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5196 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5197 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5198 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5199 {"force", no_argument, 0, IDX_FORCE},
5200 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5201 {"benchmark-mode", required_argument, 0, IDX_BENCHMARK_MODE},
5202 {"restore", no_argument, 0, IDX_RESTORE},
5203 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5204 {"status", no_argument, 0, IDX_STATUS},
5205 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5206 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5207 {"loopback", no_argument, 0, IDX_LOOPBACK},
5208 {"weak-hash-threshold",
5209 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5210 {"session", required_argument, 0, IDX_SESSION},
5211 {"runtime", required_argument, 0, IDX_RUNTIME},
5212 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5213 {"generate-rules-func-min",
5214 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5215 {"generate-rules-func-max",
5216 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5217 {"generate-rules-seed",
5218 required_argument, 0, IDX_RP_GEN_SEED},
5219 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5220 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5221 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5222 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5223 {"rules-file", required_argument, 0, IDX_RP_FILE},
5224 {"outfile", required_argument, 0, IDX_OUTFILE},
5225 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5226 {"outfile-autohex-disable",
5227 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5228 {"outfile-check-timer",
5229 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5230 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5231 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5232 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5233 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5234 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5235 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5236 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5237 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5238 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5239 {"opencl-platform", required_argument, 0, IDX_OPENCL_PLATFORM},
5240 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5241 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5242 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5243 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5244 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5245 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5246 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5247 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5248 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5249 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5250 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5251 // deprecated
5252 {"seperator", required_argument, 0, IDX_SEPARATOR},
5253 {"separator", required_argument, 0, IDX_SEPARATOR},
5254 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5255 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5256 {"increment", no_argument, 0, IDX_INCREMENT},
5257 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5258 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5259 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5260 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5261 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5262 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5263
5264 {0, 0, 0, 0}
5265 };
5266
5267 uint rp_files_cnt = 0;
5268
5269 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5270
5271 int option_index;
5272 int c;
5273
5274 optind = 1;
5275 optopt = 0;
5276 option_index = 0;
5277
5278 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5279 {
5280 switch (c)
5281 {
5282 case IDX_HELP: usage = 1; break;
5283 case IDX_VERSION:
5284 case IDX_VERSION_LOWER: version = 1; break;
5285 case IDX_RESTORE: restore = 1; break;
5286 case IDX_SESSION: session = optarg; break;
5287 case IDX_SHOW: show = 1; break;
5288 case IDX_LEFT: left = 1; break;
5289 case '?': return (-1);
5290 }
5291 }
5292
5293 if (optopt != 0)
5294 {
5295 log_error ("ERROR: Invalid argument specified");
5296
5297 return (-1);
5298 }
5299
5300 /**
5301 * exit functions
5302 */
5303
5304 if (version)
5305 {
5306 log_info (VERSION_TXT);
5307
5308 return (0);
5309 }
5310
5311 if (usage)
5312 {
5313 usage_big_print (PROGNAME);
5314
5315 return (0);
5316 }
5317
5318 /**
5319 * session needs to be set, always!
5320 */
5321
5322 if (session == NULL) session = (char *) PROGNAME;
5323
5324 /**
5325 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5326 */
5327
5328 char *exec_path = get_exec_path ();
5329
5330 #ifdef LINUX
5331
5332 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5333 char *resolved_exec_path = realpath (exec_path, NULL);
5334
5335 char *install_dir = get_install_dir (resolved_exec_path);
5336 char *profile_dir = NULL;
5337 char *session_dir = NULL;
5338 char *shared_dir = NULL;
5339
5340 if (strcmp (install_dir, resolved_install_folder) == 0)
5341 {
5342 struct passwd *pw = getpwuid (getuid ());
5343
5344 const char *homedir = pw->pw_dir;
5345
5346 profile_dir = get_profile_dir (homedir);
5347 session_dir = get_session_dir (profile_dir);
5348 shared_dir = strdup (SHARED_FOLDER);
5349
5350 mkdir (profile_dir, 0700);
5351 mkdir (session_dir, 0700);
5352 }
5353 else
5354 {
5355 profile_dir = install_dir;
5356 session_dir = install_dir;
5357 shared_dir = install_dir;
5358 }
5359
5360 myfree (resolved_install_folder);
5361 myfree (resolved_exec_path);
5362
5363 #else
5364
5365 char *install_dir = get_install_dir (exec_path);
5366 char *profile_dir = install_dir;
5367 char *session_dir = install_dir;
5368 char *shared_dir = install_dir;
5369
5370 #endif
5371
5372 data.install_dir = install_dir;
5373 data.profile_dir = profile_dir;
5374 data.session_dir = session_dir;
5375 data.shared_dir = shared_dir;
5376
5377 myfree (exec_path);
5378
5379 /**
5380 * session
5381 */
5382
5383 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5384
5385 data.session = session;
5386
5387 char *eff_restore_file = (char *) mymalloc (session_size);
5388 char *new_restore_file = (char *) mymalloc (session_size);
5389
5390 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5391 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5392
5393 data.eff_restore_file = eff_restore_file;
5394 data.new_restore_file = new_restore_file;
5395
5396 if (((show == 1) || (left == 1)) && (restore == 1))
5397 {
5398 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5399 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5400
5401 return (-1);
5402 }
5403
5404 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5405 if ((show == 1) || (left == 1))
5406 {
5407 restore_disable = 1;
5408
5409 restore = 0;
5410 }
5411
5412 data.restore_disable = restore_disable;
5413
5414 restore_data_t *rd = init_restore (argc, argv);
5415
5416 data.rd = rd;
5417
5418 /**
5419 * restore file
5420 */
5421
5422 if (restore == 1)
5423 {
5424 read_restore (eff_restore_file, rd);
5425
5426 if (rd->version_bin < RESTORE_MIN)
5427 {
5428 log_error ("ERROR: Incompatible restore-file version");
5429
5430 return (-1);
5431 }
5432
5433 myargc = rd->argc;
5434 myargv = rd->argv;
5435
5436 #ifdef _POSIX
5437 rd->pid = getpid ();
5438 #elif _WIN
5439 rd->pid = GetCurrentProcessId ();
5440 #endif
5441 }
5442
5443 uint hash_mode_chgd = 0;
5444 uint runtime_chgd = 0;
5445 uint kernel_loops_chgd = 0;
5446 uint kernel_accel_chgd = 0;
5447 uint attack_mode_chgd = 0;
5448 uint outfile_format_chgd = 0;
5449 uint rp_gen_seed_chgd = 0;
5450 uint remove_timer_chgd = 0;
5451 uint increment_min_chgd = 0;
5452 uint increment_max_chgd = 0;
5453 uint gpu_temp_abort_chgd = 0;
5454 uint gpu_temp_retain_chgd = 0;
5455
5456 optind = 1;
5457 optopt = 0;
5458 option_index = 0;
5459
5460 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5461 {
5462 switch (c)
5463 {
5464 //case IDX_HELP: usage = 1; break;
5465 //case IDX_VERSION: version = 1; break;
5466 //case IDX_RESTORE: restore = 1; break;
5467 case IDX_QUIET: quiet = 1; break;
5468 //case IDX_SHOW: show = 1; break;
5469 case IDX_SHOW: break;
5470 //case IDX_LEFT: left = 1; break;
5471 case IDX_LEFT: break;
5472 case IDX_USERNAME: username = 1; break;
5473 case IDX_REMOVE: remove = 1; break;
5474 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5475 remove_timer_chgd = 1; break;
5476 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5477 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5478 case IDX_DEBUG_FILE: debug_file = optarg; break;
5479 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5480 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5481 case IDX_FORCE: force = 1; break;
5482 case IDX_SKIP: skip = atoll (optarg); break;
5483 case IDX_LIMIT: limit = atoll (optarg); break;
5484 case IDX_KEYSPACE: keyspace = 1; break;
5485 case IDX_BENCHMARK: benchmark = 1; break;
5486 case IDX_BENCHMARK_MODE: benchmark_mode = atoi (optarg); break;
5487 case IDX_RESTORE: break;
5488 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5489 case IDX_STATUS: status = 1; break;
5490 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5491 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5492 case IDX_LOOPBACK: loopback = 1; break;
5493 case IDX_WEAK_HASH_THRESHOLD:
5494 weak_hash_threshold = atoi (optarg); break;
5495 //case IDX_SESSION: session = optarg; break;
5496 case IDX_SESSION: break;
5497 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5498 hash_mode_chgd = 1; break;
5499 case IDX_RUNTIME: runtime = atoi (optarg);
5500 runtime_chgd = 1; break;
5501 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5502 attack_mode_chgd = 1; break;
5503 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5504 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5505 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5506 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5507 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5508 rp_gen_seed_chgd = 1; break;
5509 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5510 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5511 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5512 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5513 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5514 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5515 case IDX_OUTFILE: outfile = optarg; break;
5516 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5517 outfile_format_chgd = 1; break;
5518 case IDX_OUTFILE_AUTOHEX_DISABLE:
5519 outfile_autohex = 0; break;
5520 case IDX_OUTFILE_CHECK_TIMER:
5521 outfile_check_timer = atoi (optarg); break;
5522 case IDX_HEX_CHARSET: hex_charset = 1; break;
5523 case IDX_HEX_SALT: hex_salt = 1; break;
5524 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5525 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5526 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5527 case IDX_OPENCL_PLATFORM: opencl_platform = optarg; break;
5528 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg); break;
5529 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5530 kernel_accel_chgd = 1; break;
5531 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5532 kernel_loops_chgd = 1; break;
5533 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5534 case IDX_GPU_TEMP_ABORT: gpu_temp_abort_chgd = 1;
5535 gpu_temp_abort = atoi (optarg); break;
5536 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain_chgd = 1;
5537 gpu_temp_retain = atoi (optarg); break;
5538 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5539 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5540 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5541 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5542 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5543 case IDX_SEPARATOR: separator = optarg[0]; break;
5544 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5545 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5546 case IDX_INCREMENT: increment = 1; break;
5547 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5548 increment_min_chgd = 1; break;
5549 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5550 increment_max_chgd = 1; break;
5551 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5552 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5553 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5554 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5555
5556 default:
5557 log_error ("ERROR: Invalid argument specified");
5558 return (-1);
5559 }
5560 }
5561
5562 if (optopt != 0)
5563 {
5564 log_error ("ERROR: Invalid argument specified");
5565
5566 return (-1);
5567 }
5568
5569 /**
5570 * Inform user things getting started,
5571 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5572 * - we do not need to check algorithm_pos
5573 */
5574
5575 if (quiet == 0)
5576 {
5577 if (benchmark == 1)
5578 {
5579 log_info ("%s v%.2f starting in benchmark-mode...", PROGNAME, (float) VERSION_BIN / 100);
5580
5581 log_info ("");
5582 }
5583 else if (restore == 1)
5584 {
5585 log_info ("%s v%.2f starting in restore-mode...", PROGNAME, (float) VERSION_BIN / 100);
5586
5587 log_info ("");
5588 }
5589 else
5590 {
5591 log_info ("%s v%.2f starting...", PROGNAME, (float) VERSION_BIN / 100);
5592
5593 log_info ("");
5594 }
5595 }
5596
5597 /**
5598 * sanity check
5599 */
5600
5601 if (attack_mode > 7)
5602 {
5603 log_error ("ERROR: Invalid attack-mode specified");
5604
5605 return (-1);
5606 }
5607
5608 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5609 {
5610 log_error ("ERROR: Invalid runtime specified");
5611
5612 return (-1);
5613 }
5614
5615 if (hash_mode_chgd && hash_mode > 13000) // just added to remove compiler warnings for hash_mode_chgd
5616 {
5617 log_error ("ERROR: Invalid hash-type specified");
5618
5619 return (-1);
5620 }
5621
5622 // renamed hash modes
5623
5624 if (hash_mode_chgd)
5625 {
5626 int n = -1;
5627
5628 switch (hash_mode)
5629 {
5630 case 123: n = 124;
5631 break;
5632 }
5633
5634 if (n >= 0)
5635 {
5636 log_error ("Old -m specified, use -m %d instead", n);
5637
5638 return (-1);
5639 }
5640 }
5641
5642 if (username == 1)
5643 {
5644 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5645 {
5646 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5647
5648 return (-1);
5649 }
5650 }
5651
5652 if (outfile_format > 16)
5653 {
5654 log_error ("ERROR: Invalid outfile-format specified");
5655
5656 return (-1);
5657 }
5658
5659 if (left == 1)
5660 {
5661 if (outfile_format_chgd == 1)
5662 {
5663 if (outfile_format > 1)
5664 {
5665 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5666
5667 return (-1);
5668 }
5669 }
5670 else
5671 {
5672 outfile_format = OUTFILE_FMT_HASH;
5673 }
5674 }
5675
5676 if (show == 1)
5677 {
5678 if (outfile_format_chgd == 1)
5679 {
5680 if ((outfile_format > 7) && (outfile_format < 16))
5681 {
5682 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
5683
5684 return (-1);
5685 }
5686 }
5687 }
5688
5689 if (increment_min < INCREMENT_MIN)
5690 {
5691 log_error ("ERROR: Invalid increment-min specified");
5692
5693 return (-1);
5694 }
5695
5696 if (increment_max > INCREMENT_MAX)
5697 {
5698 log_error ("ERROR: Invalid increment-max specified");
5699
5700 return (-1);
5701 }
5702
5703 if (increment_min > increment_max)
5704 {
5705 log_error ("ERROR: Invalid increment-min specified");
5706
5707 return (-1);
5708 }
5709
5710 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
5711 {
5712 log_error ("ERROR: increment is not allowed in attack-mode 0");
5713
5714 return (-1);
5715 }
5716
5717 if ((increment == 0) && (increment_min_chgd == 1))
5718 {
5719 log_error ("ERROR: increment-min is only supported together with increment switch");
5720
5721 return (-1);
5722 }
5723
5724 if ((increment == 0) && (increment_max_chgd == 1))
5725 {
5726 log_error ("ERROR: increment-max is only supported together with increment switch");
5727
5728 return (-1);
5729 }
5730
5731 if (rp_files_cnt && rp_gen)
5732 {
5733 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
5734
5735 return (-1);
5736 }
5737
5738 if (rp_files_cnt || rp_gen)
5739 {
5740 if (attack_mode != ATTACK_MODE_STRAIGHT)
5741 {
5742 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
5743
5744 return (-1);
5745 }
5746 }
5747
5748 if (rp_gen_func_min > rp_gen_func_max)
5749 {
5750 log_error ("ERROR: Invalid rp-gen-func-min specified");
5751
5752 return (-1);
5753 }
5754
5755 if (kernel_accel_chgd == 1)
5756 {
5757 if (workload_profile != WORKLOAD_PROFILE)
5758 {
5759 log_error ("ERROR: kernel-accel parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5760
5761 return (-1);
5762 }
5763
5764 if (kernel_accel < 1)
5765 {
5766 log_error ("ERROR: Invalid kernel-accel specified");
5767
5768 return (-1);
5769 }
5770
5771 if (kernel_accel > 800)
5772 {
5773 log_error ("ERROR: Invalid kernel-accel specified");
5774
5775 return (-1);
5776 }
5777 }
5778
5779 if (kernel_loops_chgd == 1)
5780 {
5781 if (workload_profile != WORKLOAD_PROFILE)
5782 {
5783 log_error ("ERROR: kernel-loops parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5784
5785 return (-1);
5786 }
5787
5788 if (kernel_loops < 1)
5789 {
5790 log_error ("ERROR: Invalid kernel-loops specified");
5791
5792 return (-1);
5793 }
5794
5795 if (kernel_loops > 1024)
5796 {
5797 log_error ("ERROR: Invalid kernel-loops specified");
5798
5799 return (-1);
5800 }
5801 }
5802
5803 if (benchmark == 1)
5804 {
5805 if (workload_profile != WORKLOAD_PROFILE)
5806 {
5807 log_error ("ERROR: Using the workload-profile in benchmark mode is not allowed");
5808
5809 return (-1);
5810 }
5811 }
5812
5813 if ((workload_profile < 1) || (workload_profile > 3))
5814 {
5815 log_error ("ERROR: workload-profile %i not available", workload_profile);
5816
5817 return (-1);
5818 }
5819
5820 if (show == 1 || left == 1)
5821 {
5822 attack_mode = ATTACK_MODE_NONE;
5823
5824 if (remove == 1)
5825 {
5826 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
5827
5828 return (-1);
5829 }
5830
5831 if (potfile_disable == 1)
5832 {
5833 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
5834
5835 return (-1);
5836 }
5837 }
5838
5839 uint attack_kern = ATTACK_KERN_NONE;
5840
5841 switch (attack_mode)
5842 {
5843 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
5844 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
5845 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
5846 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
5847 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
5848 }
5849
5850 if (benchmark == 0)
5851 {
5852 if (keyspace == 1)
5853 {
5854 int num_additional_params = 1;
5855
5856 if (attack_kern == ATTACK_KERN_COMBI)
5857 {
5858 num_additional_params = 2;
5859 }
5860
5861 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
5862
5863 if (keyspace_wordlist_specified == 0) optind--;
5864 }
5865
5866 if (attack_kern == ATTACK_KERN_NONE)
5867 {
5868 if ((optind + 1) != myargc)
5869 {
5870 usage_mini_print (myargv[0]);
5871
5872 return (-1);
5873 }
5874 }
5875 else if (attack_kern == ATTACK_KERN_STRAIGHT)
5876 {
5877 if ((optind + 1) > myargc)
5878 {
5879 usage_mini_print (myargv[0]);
5880
5881 return (-1);
5882 }
5883 }
5884 else if (attack_kern == ATTACK_KERN_COMBI)
5885 {
5886 if ((optind + 3) != myargc)
5887 {
5888 usage_mini_print (myargv[0]);
5889
5890 return (-1);
5891 }
5892 }
5893 else if (attack_kern == ATTACK_KERN_BF)
5894 {
5895 if ((optind + 1) > myargc)
5896 {
5897 usage_mini_print (myargv[0]);
5898
5899 return (-1);
5900 }
5901 }
5902 else
5903 {
5904 usage_mini_print (myargv[0]);
5905
5906 return (-1);
5907 }
5908 }
5909 else
5910 {
5911 if (myargv[optind] != 0)
5912 {
5913 log_error ("ERROR: Invalid argument for benchmark mode specified");
5914
5915 return (-1);
5916 }
5917
5918 if (attack_mode_chgd == 1)
5919 {
5920 if (attack_mode != ATTACK_MODE_BF)
5921 {
5922 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
5923
5924 return (-1);
5925 }
5926 }
5927
5928 if (benchmark_mode == 0)
5929 {
5930 // nothing to do
5931 }
5932 else if (benchmark_mode == 1)
5933 {
5934 if (kernel_accel_chgd == 1 || kernel_loops_chgd == 1)
5935 {
5936 log_error ("ERROR: Benchmark-mode 1 does not allow kernel-accel or kernel-loops changed");
5937
5938 return (-1);
5939 }
5940 }
5941 else
5942 {
5943 log_error ("ERROR: Benchmark-mode must be 0 or 1");
5944
5945 return (-1);
5946 }
5947 }
5948
5949 if (skip != 0 && limit != 0)
5950 {
5951 limit += skip;
5952 }
5953
5954 if (keyspace == 1)
5955 {
5956 if (show == 1)
5957 {
5958 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
5959
5960 return (-1);
5961 }
5962 else if (left == 1)
5963 {
5964 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
5965
5966 return (-1);
5967 }
5968
5969 potfile_disable = 1;
5970
5971 restore_disable = 1;
5972
5973 restore = 0;
5974
5975 weak_hash_threshold = 0;
5976
5977 quiet = 1;
5978 }
5979
5980 if (remove_timer_chgd == 1)
5981 {
5982 if (remove == 0)
5983 {
5984 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
5985
5986 return (-1);
5987 }
5988
5989 if (remove_timer < 1)
5990 {
5991 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
5992
5993 return (-1);
5994 }
5995 }
5996
5997 if (loopback == 1)
5998 {
5999 if (attack_mode == ATTACK_MODE_BF)
6000 {
6001 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6002
6003 return (-1);
6004 }
6005 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6006 {
6007 if ((rp_files_cnt == 0) && (rp_gen == 0))
6008 {
6009 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6010
6011 return (-1);
6012 }
6013 }
6014 }
6015
6016 if (debug_mode > 0)
6017 {
6018 if (attack_mode != ATTACK_MODE_STRAIGHT)
6019 {
6020 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6021
6022 return (-1);
6023 }
6024
6025 if ((rp_files_cnt == 0) && (rp_gen == 0))
6026 {
6027 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6028
6029 return (-1);
6030 }
6031 }
6032
6033 if (debug_mode > 4)
6034 {
6035 log_error ("ERROR: Invalid debug-mode specified");
6036
6037 return (-1);
6038 }
6039
6040 if (debug_file != NULL)
6041 {
6042 if (debug_mode < 1)
6043 {
6044 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6045
6046 return (-1);
6047 }
6048 }
6049
6050 if (induction_dir != NULL)
6051 {
6052 if (attack_mode == ATTACK_MODE_BF)
6053 {
6054 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6055
6056 return (-1);
6057 }
6058 }
6059
6060 /**
6061 * induction directory
6062 */
6063
6064 char *induction_directory = NULL;
6065
6066 if (attack_mode != ATTACK_MODE_BF)
6067 {
6068 if (induction_dir == NULL)
6069 {
6070 induction_directory = (char *) mymalloc (session_size);
6071
6072 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6073
6074 // create induction folder if it does not already exist
6075
6076 if (keyspace == 0)
6077 {
6078 if (rmdir (induction_directory) == -1)
6079 {
6080 if (errno == ENOENT)
6081 {
6082 // good, we can ignore
6083 }
6084 else if (errno == ENOTEMPTY)
6085 {
6086 char *induction_directory_mv = (char *) mymalloc (session_size);
6087
6088 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6089
6090 if (rename (induction_directory, induction_directory_mv) != 0)
6091 {
6092 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6093
6094 return (-1);
6095 }
6096 }
6097 else
6098 {
6099 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6100
6101 return (-1);
6102 }
6103 }
6104
6105 if (mkdir (induction_directory, 0700) == -1)
6106 {
6107 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6108
6109 return (-1);
6110 }
6111 }
6112 }
6113 else
6114 {
6115 induction_directory = induction_dir;
6116 }
6117 }
6118
6119 data.induction_directory = induction_directory;
6120
6121 /**
6122 * loopback
6123 */
6124
6125 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6126
6127 char *loopback_file = (char *) mymalloc (loopback_size);
6128
6129 /**
6130 * outfile-check directory
6131 */
6132
6133 char *outfile_check_directory = NULL;
6134
6135 if (outfile_check_dir == NULL)
6136 {
6137 outfile_check_directory = (char *) mymalloc (session_size);
6138
6139 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6140 }
6141 else
6142 {
6143 outfile_check_directory = outfile_check_dir;
6144 }
6145
6146 data.outfile_check_directory = outfile_check_directory;
6147
6148 if (keyspace == 0)
6149 {
6150 struct stat outfile_check_stat;
6151
6152 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6153 {
6154 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6155
6156 if (is_dir == 0)
6157 {
6158 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6159
6160 return (-1);
6161 }
6162 }
6163 else if (outfile_check_dir == NULL)
6164 {
6165 if (mkdir (outfile_check_directory, 0700) == -1)
6166 {
6167 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6168
6169 return (-1);
6170 }
6171 }
6172 }
6173
6174 /**
6175 * special other stuff
6176 */
6177
6178 if (hash_mode == 9710)
6179 {
6180 outfile_format = 5;
6181 outfile_format_chgd = 1;
6182 }
6183
6184 if (hash_mode == 9810)
6185 {
6186 outfile_format = 5;
6187 outfile_format_chgd = 1;
6188 }
6189
6190 if (hash_mode == 10410)
6191 {
6192 outfile_format = 5;
6193 outfile_format_chgd = 1;
6194 }
6195
6196 /**
6197 * store stuff
6198 */
6199
6200 data.hash_mode = hash_mode;
6201 data.restore = restore;
6202 data.restore_timer = restore_timer;
6203 data.restore_disable = restore_disable;
6204 data.status = status;
6205 data.status_timer = status_timer;
6206 data.status_automat = status_automat;
6207 data.loopback = loopback;
6208 data.runtime = runtime;
6209 data.remove = remove;
6210 data.remove_timer = remove_timer;
6211 data.debug_mode = debug_mode;
6212 data.debug_file = debug_file;
6213 data.username = username;
6214 data.quiet = quiet;
6215 data.outfile = outfile;
6216 data.outfile_format = outfile_format;
6217 data.outfile_autohex = outfile_autohex;
6218 data.hex_charset = hex_charset;
6219 data.hex_salt = hex_salt;
6220 data.hex_wordlist = hex_wordlist;
6221 data.separator = separator;
6222 data.rp_files = rp_files;
6223 data.rp_files_cnt = rp_files_cnt;
6224 data.rp_gen = rp_gen;
6225 data.rp_gen_seed = rp_gen_seed;
6226 data.force = force;
6227 data.benchmark = benchmark;
6228 data.skip = skip;
6229 data.limit = limit;
6230 data.powertune_enable = powertune_enable;
6231 data.logfile_disable = logfile_disable;
6232 data.truecrypt_keyfiles = truecrypt_keyfiles;
6233 data.scrypt_tmto = scrypt_tmto;
6234
6235 /**
6236 * cpu affinity
6237 */
6238
6239 if (cpu_affinity)
6240 {
6241 set_cpu_affinity (cpu_affinity);
6242 }
6243
6244 if (rp_gen_seed_chgd == 0)
6245 {
6246 srand (proc_start);
6247 }
6248 else
6249 {
6250 srand (rp_gen_seed);
6251 }
6252
6253 /**
6254 * logfile init
6255 */
6256
6257 if (logfile_disable == 0)
6258 {
6259 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6260
6261 char *logfile = (char *) mymalloc (logfile_size);
6262
6263 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6264
6265 data.logfile = logfile;
6266
6267 char *topid = logfile_generate_topid ();
6268
6269 data.topid = topid;
6270 }
6271
6272 // logfile_append() checks for logfile_disable internally to make it easier from here
6273
6274 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6275 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6276 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6277 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6278 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6279 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6280 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6281 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6282 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6283 #define logfile_sub_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s\t%s", data.topid, data.subid, (var), (val));
6284
6285 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6286 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6287 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6288 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6289 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6290 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6291 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6292 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6293
6294 logfile_top_msg ("START");
6295
6296 logfile_top_uint (attack_mode);
6297 logfile_top_uint (attack_kern);
6298 logfile_top_uint (benchmark);
6299 logfile_top_uint (benchmark_mode);
6300 logfile_top_uint (bitmap_min);
6301 logfile_top_uint (bitmap_max);
6302 logfile_top_uint (debug_mode);
6303 logfile_top_uint (force);
6304 logfile_top_uint (kernel_accel);
6305 logfile_top_uint (kernel_loops);
6306 logfile_top_uint (gpu_temp_abort);
6307 logfile_top_uint (gpu_temp_disable);
6308 logfile_top_uint (gpu_temp_retain);
6309 logfile_top_uint (hash_mode);
6310 logfile_top_uint (hex_charset);
6311 logfile_top_uint (hex_salt);
6312 logfile_top_uint (hex_wordlist);
6313 logfile_top_uint (increment);
6314 logfile_top_uint (increment_max);
6315 logfile_top_uint (increment_min);
6316 logfile_top_uint (keyspace);
6317 logfile_top_uint (left);
6318 logfile_top_uint (logfile_disable);
6319 logfile_top_uint (loopback);
6320 logfile_top_uint (markov_classic);
6321 logfile_top_uint (markov_disable);
6322 logfile_top_uint (markov_threshold);
6323 logfile_top_uint (outfile_autohex);
6324 logfile_top_uint (outfile_check_timer);
6325 logfile_top_uint (outfile_format);
6326 logfile_top_uint (potfile_disable);
6327 logfile_top_uint (powertune_enable);
6328 logfile_top_uint (scrypt_tmto);
6329 logfile_top_uint (quiet);
6330 logfile_top_uint (remove);
6331 logfile_top_uint (remove_timer);
6332 logfile_top_uint (restore);
6333 logfile_top_uint (restore_disable);
6334 logfile_top_uint (restore_timer);
6335 logfile_top_uint (rp_gen);
6336 logfile_top_uint (rp_gen_func_max);
6337 logfile_top_uint (rp_gen_func_min);
6338 logfile_top_uint (rp_gen_seed);
6339 logfile_top_uint (runtime);
6340 logfile_top_uint (segment_size);
6341 logfile_top_uint (show);
6342 logfile_top_uint (status);
6343 logfile_top_uint (status_automat);
6344 logfile_top_uint (status_timer);
6345 logfile_top_uint (usage);
6346 logfile_top_uint (username);
6347 logfile_top_uint (version);
6348 logfile_top_uint (weak_hash_threshold);
6349 logfile_top_uint (workload_profile);
6350 logfile_top_uint64 (limit);
6351 logfile_top_uint64 (skip);
6352 logfile_top_char (separator);
6353 logfile_top_string (cpu_affinity);
6354 logfile_top_string (custom_charset_1);
6355 logfile_top_string (custom_charset_2);
6356 logfile_top_string (custom_charset_3);
6357 logfile_top_string (custom_charset_4);
6358 logfile_top_string (debug_file);
6359 logfile_top_string (opencl_devices);
6360 logfile_top_string (opencl_platform);
6361 logfile_top_string (induction_dir);
6362 logfile_top_string (markov_hcstat);
6363 logfile_top_string (outfile);
6364 logfile_top_string (outfile_check_dir);
6365 logfile_top_string (rule_buf_l);
6366 logfile_top_string (rule_buf_r);
6367 logfile_top_string (session);
6368 logfile_top_string (truecrypt_keyfiles);
6369
6370 /**
6371 * devices
6372 */
6373
6374 uint opencl_devicemask = devices_to_devicemask (opencl_devices);
6375
6376 /**
6377 * benchmark
6378 */
6379
6380 if (benchmark == 1)
6381 {
6382 /**
6383 * disable useless stuff for benchmark
6384 */
6385
6386 restore_timer = 0;
6387 status_timer = 0;
6388 restore_disable = 1;
6389 potfile_disable = 1;
6390 weak_hash_threshold = 0;
6391
6392 data.restore_timer = restore_timer;
6393 data.status_timer = status_timer;
6394 data.restore_disable = restore_disable;
6395
6396 if (benchmark_mode == 1)
6397 {
6398 markov_disable = 1;
6399 }
6400
6401 /**
6402 * force attack mode to be bruteforce
6403 */
6404
6405 attack_mode = ATTACK_MODE_BF;
6406 attack_kern = ATTACK_KERN_BF;
6407
6408 if (runtime_chgd == 0)
6409 {
6410 runtime = 4;
6411
6412 if (benchmark_mode == 1) runtime = 17;
6413
6414 data.runtime = runtime;
6415 }
6416 }
6417
6418 /**
6419 * config
6420 */
6421
6422 uint hash_type = 0;
6423 uint salt_type = 0;
6424 uint attack_exec = 0;
6425 uint opts_type = 0;
6426 uint kern_type = 0;
6427 uint dgst_size = 0;
6428 uint esalt_size = 0;
6429 uint opti_type = 0;
6430 uint dgst_pos0 = -1;
6431 uint dgst_pos1 = -1;
6432 uint dgst_pos2 = -1;
6433 uint dgst_pos3 = -1;
6434
6435 int (*parse_func) (char *, uint, hash_t *);
6436 int (*sort_by_digest) (const void *, const void *);
6437
6438 uint algorithm_pos = 0;
6439 uint algorithm_max = 1;
6440
6441 uint *algorithms = default_benchmark_algorithms;
6442
6443 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6444
6445 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6446 {
6447 /*
6448 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6449 * the following algos are skipped entirely
6450 */
6451
6452 if (algorithm_pos > 0)
6453 {
6454 local_free (rd);
6455
6456 rd = init_restore (argc, argv);
6457
6458 data.rd = rd;
6459 }
6460
6461 /**
6462 * update hash_mode in case of multihash benchmark
6463 */
6464
6465 if (benchmark == 1)
6466 {
6467 if (hash_mode_chgd == 0)
6468 {
6469 hash_mode = algorithms[algorithm_pos];
6470
6471 data.hash_mode = hash_mode;
6472 }
6473
6474 quiet = 1;
6475
6476 data.quiet = quiet;
6477 }
6478
6479 switch (hash_mode)
6480 {
6481 case 0: hash_type = HASH_TYPE_MD5;
6482 salt_type = SALT_TYPE_NONE;
6483 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6484 opts_type = OPTS_TYPE_PT_GENERATE_LE
6485 | OPTS_TYPE_PT_ADD80
6486 | OPTS_TYPE_PT_ADDBITS14;
6487 kern_type = KERN_TYPE_MD5;
6488 dgst_size = DGST_SIZE_4_4;
6489 parse_func = md5_parse_hash;
6490 sort_by_digest = sort_by_digest_4_4;
6491 opti_type = OPTI_TYPE_ZERO_BYTE
6492 | OPTI_TYPE_PRECOMPUTE_INIT
6493 | OPTI_TYPE_PRECOMPUTE_MERKLE
6494 | OPTI_TYPE_MEET_IN_MIDDLE
6495 | OPTI_TYPE_EARLY_SKIP
6496 | OPTI_TYPE_NOT_ITERATED
6497 | OPTI_TYPE_NOT_SALTED
6498 | OPTI_TYPE_RAW_HASH;
6499 dgst_pos0 = 0;
6500 dgst_pos1 = 3;
6501 dgst_pos2 = 2;
6502 dgst_pos3 = 1;
6503 break;
6504
6505 case 10: hash_type = HASH_TYPE_MD5;
6506 salt_type = SALT_TYPE_INTERN;
6507 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6508 opts_type = OPTS_TYPE_PT_GENERATE_LE
6509 | OPTS_TYPE_ST_ADD80
6510 | OPTS_TYPE_ST_ADDBITS14;
6511 kern_type = KERN_TYPE_MD5_PWSLT;
6512 dgst_size = DGST_SIZE_4_4;
6513 parse_func = md5s_parse_hash;
6514 sort_by_digest = sort_by_digest_4_4;
6515 opti_type = OPTI_TYPE_ZERO_BYTE
6516 | OPTI_TYPE_PRECOMPUTE_INIT
6517 | OPTI_TYPE_PRECOMPUTE_MERKLE
6518 | OPTI_TYPE_MEET_IN_MIDDLE
6519 | OPTI_TYPE_EARLY_SKIP
6520 | OPTI_TYPE_NOT_ITERATED
6521 | OPTI_TYPE_APPENDED_SALT
6522 | OPTI_TYPE_RAW_HASH;
6523 dgst_pos0 = 0;
6524 dgst_pos1 = 3;
6525 dgst_pos2 = 2;
6526 dgst_pos3 = 1;
6527 break;
6528
6529 case 11: hash_type = HASH_TYPE_MD5;
6530 salt_type = SALT_TYPE_INTERN;
6531 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6532 opts_type = OPTS_TYPE_PT_GENERATE_LE
6533 | OPTS_TYPE_ST_ADD80
6534 | OPTS_TYPE_ST_ADDBITS14;
6535 kern_type = KERN_TYPE_MD5_PWSLT;
6536 dgst_size = DGST_SIZE_4_4;
6537 parse_func = joomla_parse_hash;
6538 sort_by_digest = sort_by_digest_4_4;
6539 opti_type = OPTI_TYPE_ZERO_BYTE
6540 | OPTI_TYPE_PRECOMPUTE_INIT
6541 | OPTI_TYPE_PRECOMPUTE_MERKLE
6542 | OPTI_TYPE_MEET_IN_MIDDLE
6543 | OPTI_TYPE_EARLY_SKIP
6544 | OPTI_TYPE_NOT_ITERATED
6545 | OPTI_TYPE_APPENDED_SALT
6546 | OPTI_TYPE_RAW_HASH;
6547 dgst_pos0 = 0;
6548 dgst_pos1 = 3;
6549 dgst_pos2 = 2;
6550 dgst_pos3 = 1;
6551 break;
6552
6553 case 12: hash_type = HASH_TYPE_MD5;
6554 salt_type = SALT_TYPE_INTERN;
6555 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6556 opts_type = OPTS_TYPE_PT_GENERATE_LE
6557 | OPTS_TYPE_ST_ADD80
6558 | OPTS_TYPE_ST_ADDBITS14;
6559 kern_type = KERN_TYPE_MD5_PWSLT;
6560 dgst_size = DGST_SIZE_4_4;
6561 parse_func = postgresql_parse_hash;
6562 sort_by_digest = sort_by_digest_4_4;
6563 opti_type = OPTI_TYPE_ZERO_BYTE
6564 | OPTI_TYPE_PRECOMPUTE_INIT
6565 | OPTI_TYPE_PRECOMPUTE_MERKLE
6566 | OPTI_TYPE_MEET_IN_MIDDLE
6567 | OPTI_TYPE_EARLY_SKIP
6568 | OPTI_TYPE_NOT_ITERATED
6569 | OPTI_TYPE_APPENDED_SALT
6570 | OPTI_TYPE_RAW_HASH;
6571 dgst_pos0 = 0;
6572 dgst_pos1 = 3;
6573 dgst_pos2 = 2;
6574 dgst_pos3 = 1;
6575 break;
6576
6577 case 20: hash_type = HASH_TYPE_MD5;
6578 salt_type = SALT_TYPE_INTERN;
6579 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6580 opts_type = OPTS_TYPE_PT_GENERATE_LE
6581 | OPTS_TYPE_PT_ADD80
6582 | OPTS_TYPE_PT_ADDBITS14;
6583 kern_type = KERN_TYPE_MD5_SLTPW;
6584 dgst_size = DGST_SIZE_4_4;
6585 parse_func = md5s_parse_hash;
6586 sort_by_digest = sort_by_digest_4_4;
6587 opti_type = OPTI_TYPE_ZERO_BYTE
6588 | OPTI_TYPE_PRECOMPUTE_INIT
6589 | OPTI_TYPE_PRECOMPUTE_MERKLE
6590 | OPTI_TYPE_EARLY_SKIP
6591 | OPTI_TYPE_NOT_ITERATED
6592 | OPTI_TYPE_PREPENDED_SALT
6593 | OPTI_TYPE_RAW_HASH;
6594 dgst_pos0 = 0;
6595 dgst_pos1 = 3;
6596 dgst_pos2 = 2;
6597 dgst_pos3 = 1;
6598 break;
6599
6600 case 21: hash_type = HASH_TYPE_MD5;
6601 salt_type = SALT_TYPE_INTERN;
6602 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6603 opts_type = OPTS_TYPE_PT_GENERATE_LE
6604 | OPTS_TYPE_PT_ADD80
6605 | OPTS_TYPE_PT_ADDBITS14;
6606 kern_type = KERN_TYPE_MD5_SLTPW;
6607 dgst_size = DGST_SIZE_4_4;
6608 parse_func = osc_parse_hash;
6609 sort_by_digest = sort_by_digest_4_4;
6610 opti_type = OPTI_TYPE_ZERO_BYTE
6611 | OPTI_TYPE_PRECOMPUTE_INIT
6612 | OPTI_TYPE_PRECOMPUTE_MERKLE
6613 | OPTI_TYPE_EARLY_SKIP
6614 | OPTI_TYPE_NOT_ITERATED
6615 | OPTI_TYPE_PREPENDED_SALT
6616 | OPTI_TYPE_RAW_HASH;
6617 dgst_pos0 = 0;
6618 dgst_pos1 = 3;
6619 dgst_pos2 = 2;
6620 dgst_pos3 = 1;
6621 break;
6622
6623 case 22: hash_type = HASH_TYPE_MD5;
6624 salt_type = SALT_TYPE_EMBEDDED;
6625 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6626 opts_type = OPTS_TYPE_PT_GENERATE_LE
6627 | OPTS_TYPE_PT_ADD80
6628 | OPTS_TYPE_PT_ADDBITS14;
6629 kern_type = KERN_TYPE_MD5_SLTPW;
6630 dgst_size = DGST_SIZE_4_4;
6631 parse_func = netscreen_parse_hash;
6632 sort_by_digest = sort_by_digest_4_4;
6633 opti_type = OPTI_TYPE_ZERO_BYTE
6634 | OPTI_TYPE_PRECOMPUTE_INIT
6635 | OPTI_TYPE_PRECOMPUTE_MERKLE
6636 | OPTI_TYPE_EARLY_SKIP
6637 | OPTI_TYPE_NOT_ITERATED
6638 | OPTI_TYPE_PREPENDED_SALT
6639 | OPTI_TYPE_RAW_HASH;
6640 dgst_pos0 = 0;
6641 dgst_pos1 = 3;
6642 dgst_pos2 = 2;
6643 dgst_pos3 = 1;
6644 break;
6645
6646 case 23: hash_type = HASH_TYPE_MD5;
6647 salt_type = SALT_TYPE_EMBEDDED;
6648 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6649 opts_type = OPTS_TYPE_PT_GENERATE_LE
6650 | OPTS_TYPE_PT_ADD80
6651 | OPTS_TYPE_PT_ADDBITS14;
6652 kern_type = KERN_TYPE_MD5_SLTPW;
6653 dgst_size = DGST_SIZE_4_4;
6654 parse_func = skype_parse_hash;
6655 sort_by_digest = sort_by_digest_4_4;
6656 opti_type = OPTI_TYPE_ZERO_BYTE
6657 | OPTI_TYPE_PRECOMPUTE_INIT
6658 | OPTI_TYPE_PRECOMPUTE_MERKLE
6659 | OPTI_TYPE_EARLY_SKIP
6660 | OPTI_TYPE_NOT_ITERATED
6661 | OPTI_TYPE_PREPENDED_SALT
6662 | OPTI_TYPE_RAW_HASH;
6663 dgst_pos0 = 0;
6664 dgst_pos1 = 3;
6665 dgst_pos2 = 2;
6666 dgst_pos3 = 1;
6667 break;
6668
6669 case 30: hash_type = HASH_TYPE_MD5;
6670 salt_type = SALT_TYPE_INTERN;
6671 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6672 opts_type = OPTS_TYPE_PT_GENERATE_LE
6673 | OPTS_TYPE_PT_UNICODE
6674 | OPTS_TYPE_ST_ADD80
6675 | OPTS_TYPE_ST_ADDBITS14;
6676 kern_type = KERN_TYPE_MD5_PWUSLT;
6677 dgst_size = DGST_SIZE_4_4;
6678 parse_func = md5s_parse_hash;
6679 sort_by_digest = sort_by_digest_4_4;
6680 opti_type = OPTI_TYPE_ZERO_BYTE
6681 | OPTI_TYPE_PRECOMPUTE_INIT
6682 | OPTI_TYPE_PRECOMPUTE_MERKLE
6683 | OPTI_TYPE_MEET_IN_MIDDLE
6684 | OPTI_TYPE_EARLY_SKIP
6685 | OPTI_TYPE_NOT_ITERATED
6686 | OPTI_TYPE_APPENDED_SALT
6687 | OPTI_TYPE_RAW_HASH;
6688 dgst_pos0 = 0;
6689 dgst_pos1 = 3;
6690 dgst_pos2 = 2;
6691 dgst_pos3 = 1;
6692 break;
6693
6694 case 40: hash_type = HASH_TYPE_MD5;
6695 salt_type = SALT_TYPE_INTERN;
6696 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6697 opts_type = OPTS_TYPE_PT_GENERATE_LE
6698 | OPTS_TYPE_PT_ADD80
6699 | OPTS_TYPE_PT_ADDBITS14
6700 | OPTS_TYPE_PT_UNICODE;
6701 kern_type = KERN_TYPE_MD5_SLTPWU;
6702 dgst_size = DGST_SIZE_4_4;
6703 parse_func = md5s_parse_hash;
6704 sort_by_digest = sort_by_digest_4_4;
6705 opti_type = OPTI_TYPE_ZERO_BYTE
6706 | OPTI_TYPE_PRECOMPUTE_INIT
6707 | OPTI_TYPE_PRECOMPUTE_MERKLE
6708 | OPTI_TYPE_EARLY_SKIP
6709 | OPTI_TYPE_NOT_ITERATED
6710 | OPTI_TYPE_PREPENDED_SALT
6711 | OPTI_TYPE_RAW_HASH;
6712 dgst_pos0 = 0;
6713 dgst_pos1 = 3;
6714 dgst_pos2 = 2;
6715 dgst_pos3 = 1;
6716 break;
6717
6718 case 50: hash_type = HASH_TYPE_MD5;
6719 salt_type = SALT_TYPE_INTERN;
6720 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6721 opts_type = OPTS_TYPE_PT_GENERATE_LE
6722 | OPTS_TYPE_ST_ADD80
6723 | OPTS_TYPE_ST_ADDBITS14;
6724 kern_type = KERN_TYPE_HMACMD5_PW;
6725 dgst_size = DGST_SIZE_4_4;
6726 parse_func = hmacmd5_parse_hash;
6727 sort_by_digest = sort_by_digest_4_4;
6728 opti_type = OPTI_TYPE_ZERO_BYTE
6729 | OPTI_TYPE_NOT_ITERATED;
6730 dgst_pos0 = 0;
6731 dgst_pos1 = 3;
6732 dgst_pos2 = 2;
6733 dgst_pos3 = 1;
6734 break;
6735
6736 case 60: hash_type = HASH_TYPE_MD5;
6737 salt_type = SALT_TYPE_INTERN;
6738 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6739 opts_type = OPTS_TYPE_PT_GENERATE_LE
6740 | OPTS_TYPE_PT_ADD80
6741 | OPTS_TYPE_PT_ADDBITS14;
6742 kern_type = KERN_TYPE_HMACMD5_SLT;
6743 dgst_size = DGST_SIZE_4_4;
6744 parse_func = hmacmd5_parse_hash;
6745 sort_by_digest = sort_by_digest_4_4;
6746 opti_type = OPTI_TYPE_ZERO_BYTE
6747 | OPTI_TYPE_NOT_ITERATED;
6748 dgst_pos0 = 0;
6749 dgst_pos1 = 3;
6750 dgst_pos2 = 2;
6751 dgst_pos3 = 1;
6752 break;
6753
6754 case 100: hash_type = HASH_TYPE_SHA1;
6755 salt_type = SALT_TYPE_NONE;
6756 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6757 opts_type = OPTS_TYPE_PT_GENERATE_BE
6758 | OPTS_TYPE_PT_ADD80
6759 | OPTS_TYPE_PT_ADDBITS15;
6760 kern_type = KERN_TYPE_SHA1;
6761 dgst_size = DGST_SIZE_4_5;
6762 parse_func = sha1_parse_hash;
6763 sort_by_digest = sort_by_digest_4_5;
6764 opti_type = OPTI_TYPE_ZERO_BYTE
6765 | OPTI_TYPE_PRECOMPUTE_INIT
6766 | OPTI_TYPE_PRECOMPUTE_MERKLE
6767 | OPTI_TYPE_EARLY_SKIP
6768 | OPTI_TYPE_NOT_ITERATED
6769 | OPTI_TYPE_NOT_SALTED
6770 | OPTI_TYPE_RAW_HASH;
6771 dgst_pos0 = 3;
6772 dgst_pos1 = 4;
6773 dgst_pos2 = 2;
6774 dgst_pos3 = 1;
6775 break;
6776
6777 case 101: hash_type = HASH_TYPE_SHA1;
6778 salt_type = SALT_TYPE_NONE;
6779 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6780 opts_type = OPTS_TYPE_PT_GENERATE_BE
6781 | OPTS_TYPE_PT_ADD80
6782 | OPTS_TYPE_PT_ADDBITS15;
6783 kern_type = KERN_TYPE_SHA1;
6784 dgst_size = DGST_SIZE_4_5;
6785 parse_func = sha1b64_parse_hash;
6786 sort_by_digest = sort_by_digest_4_5;
6787 opti_type = OPTI_TYPE_ZERO_BYTE
6788 | OPTI_TYPE_PRECOMPUTE_INIT
6789 | OPTI_TYPE_PRECOMPUTE_MERKLE
6790 | OPTI_TYPE_EARLY_SKIP
6791 | OPTI_TYPE_NOT_ITERATED
6792 | OPTI_TYPE_NOT_SALTED
6793 | OPTI_TYPE_RAW_HASH;
6794 dgst_pos0 = 3;
6795 dgst_pos1 = 4;
6796 dgst_pos2 = 2;
6797 dgst_pos3 = 1;
6798 break;
6799
6800 case 110: hash_type = HASH_TYPE_SHA1;
6801 salt_type = SALT_TYPE_INTERN;
6802 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6803 opts_type = OPTS_TYPE_PT_GENERATE_BE
6804 | OPTS_TYPE_ST_ADD80
6805 | OPTS_TYPE_ST_ADDBITS15;
6806 kern_type = KERN_TYPE_SHA1_PWSLT;
6807 dgst_size = DGST_SIZE_4_5;
6808 parse_func = sha1s_parse_hash;
6809 sort_by_digest = sort_by_digest_4_5;
6810 opti_type = OPTI_TYPE_ZERO_BYTE
6811 | OPTI_TYPE_PRECOMPUTE_INIT
6812 | OPTI_TYPE_PRECOMPUTE_MERKLE
6813 | OPTI_TYPE_EARLY_SKIP
6814 | OPTI_TYPE_NOT_ITERATED
6815 | OPTI_TYPE_APPENDED_SALT
6816 | OPTI_TYPE_RAW_HASH;
6817 dgst_pos0 = 3;
6818 dgst_pos1 = 4;
6819 dgst_pos2 = 2;
6820 dgst_pos3 = 1;
6821 break;
6822
6823 case 111: hash_type = HASH_TYPE_SHA1;
6824 salt_type = SALT_TYPE_EMBEDDED;
6825 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6826 opts_type = OPTS_TYPE_PT_GENERATE_BE
6827 | OPTS_TYPE_ST_ADD80
6828 | OPTS_TYPE_ST_ADDBITS15;
6829 kern_type = KERN_TYPE_SHA1_PWSLT;
6830 dgst_size = DGST_SIZE_4_5;
6831 parse_func = sha1b64s_parse_hash;
6832 sort_by_digest = sort_by_digest_4_5;
6833 opti_type = OPTI_TYPE_ZERO_BYTE
6834 | OPTI_TYPE_PRECOMPUTE_INIT
6835 | OPTI_TYPE_PRECOMPUTE_MERKLE
6836 | OPTI_TYPE_EARLY_SKIP
6837 | OPTI_TYPE_NOT_ITERATED
6838 | OPTI_TYPE_APPENDED_SALT
6839 | OPTI_TYPE_RAW_HASH;
6840 dgst_pos0 = 3;
6841 dgst_pos1 = 4;
6842 dgst_pos2 = 2;
6843 dgst_pos3 = 1;
6844 break;
6845
6846 case 112: hash_type = HASH_TYPE_SHA1;
6847 salt_type = SALT_TYPE_INTERN;
6848 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6849 opts_type = OPTS_TYPE_PT_GENERATE_BE
6850 | OPTS_TYPE_ST_ADD80
6851 | OPTS_TYPE_ST_ADDBITS15
6852 | OPTS_TYPE_ST_HEX;
6853 kern_type = KERN_TYPE_SHA1_PWSLT;
6854 dgst_size = DGST_SIZE_4_5;
6855 parse_func = oracles_parse_hash;
6856 sort_by_digest = sort_by_digest_4_5;
6857 opti_type = OPTI_TYPE_ZERO_BYTE
6858 | OPTI_TYPE_PRECOMPUTE_INIT
6859 | OPTI_TYPE_PRECOMPUTE_MERKLE
6860 | OPTI_TYPE_EARLY_SKIP
6861 | OPTI_TYPE_NOT_ITERATED
6862 | OPTI_TYPE_APPENDED_SALT
6863 | OPTI_TYPE_RAW_HASH;
6864 dgst_pos0 = 3;
6865 dgst_pos1 = 4;
6866 dgst_pos2 = 2;
6867 dgst_pos3 = 1;
6868 break;
6869
6870 case 120: hash_type = HASH_TYPE_SHA1;
6871 salt_type = SALT_TYPE_INTERN;
6872 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6873 opts_type = OPTS_TYPE_PT_GENERATE_BE
6874 | OPTS_TYPE_PT_ADD80
6875 | OPTS_TYPE_PT_ADDBITS15;
6876 kern_type = KERN_TYPE_SHA1_SLTPW;
6877 dgst_size = DGST_SIZE_4_5;
6878 parse_func = sha1s_parse_hash;
6879 sort_by_digest = sort_by_digest_4_5;
6880 opti_type = OPTI_TYPE_ZERO_BYTE
6881 | OPTI_TYPE_PRECOMPUTE_INIT
6882 | OPTI_TYPE_PRECOMPUTE_MERKLE
6883 | OPTI_TYPE_EARLY_SKIP
6884 | OPTI_TYPE_NOT_ITERATED
6885 | OPTI_TYPE_PREPENDED_SALT
6886 | OPTI_TYPE_RAW_HASH;
6887 dgst_pos0 = 3;
6888 dgst_pos1 = 4;
6889 dgst_pos2 = 2;
6890 dgst_pos3 = 1;
6891 break;
6892
6893 case 121: hash_type = HASH_TYPE_SHA1;
6894 salt_type = SALT_TYPE_INTERN;
6895 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6896 opts_type = OPTS_TYPE_PT_GENERATE_BE
6897 | OPTS_TYPE_PT_ADD80
6898 | OPTS_TYPE_PT_ADDBITS15
6899 | OPTS_TYPE_ST_LOWER;
6900 kern_type = KERN_TYPE_SHA1_SLTPW;
6901 dgst_size = DGST_SIZE_4_5;
6902 parse_func = smf_parse_hash;
6903 sort_by_digest = sort_by_digest_4_5;
6904 opti_type = OPTI_TYPE_ZERO_BYTE
6905 | OPTI_TYPE_PRECOMPUTE_INIT
6906 | OPTI_TYPE_PRECOMPUTE_MERKLE
6907 | OPTI_TYPE_EARLY_SKIP
6908 | OPTI_TYPE_NOT_ITERATED
6909 | OPTI_TYPE_PREPENDED_SALT
6910 | OPTI_TYPE_RAW_HASH;
6911 dgst_pos0 = 3;
6912 dgst_pos1 = 4;
6913 dgst_pos2 = 2;
6914 dgst_pos3 = 1;
6915 break;
6916
6917 case 122: hash_type = HASH_TYPE_SHA1;
6918 salt_type = SALT_TYPE_EMBEDDED;
6919 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6920 opts_type = OPTS_TYPE_PT_GENERATE_BE
6921 | OPTS_TYPE_PT_ADD80
6922 | OPTS_TYPE_PT_ADDBITS15
6923 | OPTS_TYPE_ST_HEX;
6924 kern_type = KERN_TYPE_SHA1_SLTPW;
6925 dgst_size = DGST_SIZE_4_5;
6926 parse_func = osx1_parse_hash;
6927 sort_by_digest = sort_by_digest_4_5;
6928 opti_type = OPTI_TYPE_ZERO_BYTE
6929 | OPTI_TYPE_PRECOMPUTE_INIT
6930 | OPTI_TYPE_PRECOMPUTE_MERKLE
6931 | OPTI_TYPE_EARLY_SKIP
6932 | OPTI_TYPE_NOT_ITERATED
6933 | OPTI_TYPE_PREPENDED_SALT
6934 | OPTI_TYPE_RAW_HASH;
6935 dgst_pos0 = 3;
6936 dgst_pos1 = 4;
6937 dgst_pos2 = 2;
6938 dgst_pos3 = 1;
6939 break;
6940
6941 case 124: hash_type = HASH_TYPE_SHA1;
6942 salt_type = SALT_TYPE_EMBEDDED;
6943 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6944 opts_type = OPTS_TYPE_PT_GENERATE_BE
6945 | OPTS_TYPE_PT_ADD80
6946 | OPTS_TYPE_PT_ADDBITS15;
6947 kern_type = KERN_TYPE_SHA1_SLTPW;
6948 dgst_size = DGST_SIZE_4_5;
6949 parse_func = djangosha1_parse_hash;
6950 sort_by_digest = sort_by_digest_4_5;
6951 opti_type = OPTI_TYPE_ZERO_BYTE
6952 | OPTI_TYPE_PRECOMPUTE_INIT
6953 | OPTI_TYPE_PRECOMPUTE_MERKLE
6954 | OPTI_TYPE_EARLY_SKIP
6955 | OPTI_TYPE_NOT_ITERATED
6956 | OPTI_TYPE_PREPENDED_SALT
6957 | OPTI_TYPE_RAW_HASH;
6958 dgst_pos0 = 3;
6959 dgst_pos1 = 4;
6960 dgst_pos2 = 2;
6961 dgst_pos3 = 1;
6962 break;
6963
6964 case 130: hash_type = HASH_TYPE_SHA1;
6965 salt_type = SALT_TYPE_INTERN;
6966 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6967 opts_type = OPTS_TYPE_PT_GENERATE_BE
6968 | OPTS_TYPE_PT_UNICODE
6969 | OPTS_TYPE_ST_ADD80
6970 | OPTS_TYPE_ST_ADDBITS15;
6971 kern_type = KERN_TYPE_SHA1_PWUSLT;
6972 dgst_size = DGST_SIZE_4_5;
6973 parse_func = sha1s_parse_hash;
6974 sort_by_digest = sort_by_digest_4_5;
6975 opti_type = OPTI_TYPE_ZERO_BYTE
6976 | OPTI_TYPE_PRECOMPUTE_INIT
6977 | OPTI_TYPE_PRECOMPUTE_MERKLE
6978 | OPTI_TYPE_EARLY_SKIP
6979 | OPTI_TYPE_NOT_ITERATED
6980 | OPTI_TYPE_APPENDED_SALT
6981 | OPTI_TYPE_RAW_HASH;
6982 dgst_pos0 = 3;
6983 dgst_pos1 = 4;
6984 dgst_pos2 = 2;
6985 dgst_pos3 = 1;
6986 break;
6987
6988 case 131: hash_type = HASH_TYPE_SHA1;
6989 salt_type = SALT_TYPE_EMBEDDED;
6990 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6991 opts_type = OPTS_TYPE_PT_GENERATE_BE
6992 | OPTS_TYPE_PT_UNICODE
6993 | OPTS_TYPE_PT_UPPER
6994 | OPTS_TYPE_ST_ADD80
6995 | OPTS_TYPE_ST_ADDBITS15
6996 | OPTS_TYPE_ST_HEX;
6997 kern_type = KERN_TYPE_SHA1_PWUSLT;
6998 dgst_size = DGST_SIZE_4_5;
6999 parse_func = mssql2000_parse_hash;
7000 sort_by_digest = sort_by_digest_4_5;
7001 opti_type = OPTI_TYPE_ZERO_BYTE
7002 | OPTI_TYPE_PRECOMPUTE_INIT
7003 | OPTI_TYPE_PRECOMPUTE_MERKLE
7004 | OPTI_TYPE_EARLY_SKIP
7005 | OPTI_TYPE_NOT_ITERATED
7006 | OPTI_TYPE_APPENDED_SALT
7007 | OPTI_TYPE_RAW_HASH;
7008 dgst_pos0 = 3;
7009 dgst_pos1 = 4;
7010 dgst_pos2 = 2;
7011 dgst_pos3 = 1;
7012 break;
7013
7014 case 132: hash_type = HASH_TYPE_SHA1;
7015 salt_type = SALT_TYPE_EMBEDDED;
7016 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7017 opts_type = OPTS_TYPE_PT_GENERATE_BE
7018 | OPTS_TYPE_PT_UNICODE
7019 | OPTS_TYPE_ST_ADD80
7020 | OPTS_TYPE_ST_ADDBITS15
7021 | OPTS_TYPE_ST_HEX;
7022 kern_type = KERN_TYPE_SHA1_PWUSLT;
7023 dgst_size = DGST_SIZE_4_5;
7024 parse_func = mssql2005_parse_hash;
7025 sort_by_digest = sort_by_digest_4_5;
7026 opti_type = OPTI_TYPE_ZERO_BYTE
7027 | OPTI_TYPE_PRECOMPUTE_INIT
7028 | OPTI_TYPE_PRECOMPUTE_MERKLE
7029 | OPTI_TYPE_EARLY_SKIP
7030 | OPTI_TYPE_NOT_ITERATED
7031 | OPTI_TYPE_APPENDED_SALT
7032 | OPTI_TYPE_RAW_HASH;
7033 dgst_pos0 = 3;
7034 dgst_pos1 = 4;
7035 dgst_pos2 = 2;
7036 dgst_pos3 = 1;
7037 break;
7038
7039 case 133: hash_type = HASH_TYPE_SHA1;
7040 salt_type = SALT_TYPE_EMBEDDED;
7041 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7042 opts_type = OPTS_TYPE_PT_GENERATE_BE
7043 | OPTS_TYPE_PT_UNICODE
7044 | OPTS_TYPE_ST_ADD80
7045 | OPTS_TYPE_ST_ADDBITS15;
7046 kern_type = KERN_TYPE_SHA1_PWUSLT;
7047 dgst_size = DGST_SIZE_4_5;
7048 parse_func = peoplesoft_parse_hash;
7049 sort_by_digest = sort_by_digest_4_5;
7050 opti_type = OPTI_TYPE_ZERO_BYTE
7051 | OPTI_TYPE_PRECOMPUTE_INIT
7052 | OPTI_TYPE_PRECOMPUTE_MERKLE
7053 | OPTI_TYPE_EARLY_SKIP
7054 | OPTI_TYPE_NOT_ITERATED
7055 | OPTI_TYPE_APPENDED_SALT
7056 | OPTI_TYPE_RAW_HASH;
7057 dgst_pos0 = 3;
7058 dgst_pos1 = 4;
7059 dgst_pos2 = 2;
7060 dgst_pos3 = 1;
7061 break;
7062
7063 case 140: hash_type = HASH_TYPE_SHA1;
7064 salt_type = SALT_TYPE_INTERN;
7065 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7066 opts_type = OPTS_TYPE_PT_GENERATE_BE
7067 | OPTS_TYPE_PT_ADD80
7068 | OPTS_TYPE_PT_ADDBITS15
7069 | OPTS_TYPE_PT_UNICODE;
7070 kern_type = KERN_TYPE_SHA1_SLTPWU;
7071 dgst_size = DGST_SIZE_4_5;
7072 parse_func = sha1s_parse_hash;
7073 sort_by_digest = sort_by_digest_4_5;
7074 opti_type = OPTI_TYPE_ZERO_BYTE
7075 | OPTI_TYPE_PRECOMPUTE_INIT
7076 | OPTI_TYPE_PRECOMPUTE_MERKLE
7077 | OPTI_TYPE_EARLY_SKIP
7078 | OPTI_TYPE_NOT_ITERATED
7079 | OPTI_TYPE_PREPENDED_SALT
7080 | OPTI_TYPE_RAW_HASH;
7081 dgst_pos0 = 3;
7082 dgst_pos1 = 4;
7083 dgst_pos2 = 2;
7084 dgst_pos3 = 1;
7085 break;
7086
7087 case 141: hash_type = HASH_TYPE_SHA1;
7088 salt_type = SALT_TYPE_EMBEDDED;
7089 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7090 opts_type = OPTS_TYPE_PT_GENERATE_BE
7091 | OPTS_TYPE_PT_ADD80
7092 | OPTS_TYPE_PT_ADDBITS15
7093 | OPTS_TYPE_PT_UNICODE
7094 | OPTS_TYPE_ST_BASE64;
7095 kern_type = KERN_TYPE_SHA1_SLTPWU;
7096 dgst_size = DGST_SIZE_4_5;
7097 parse_func = episerver_parse_hash;
7098 sort_by_digest = sort_by_digest_4_5;
7099 opti_type = OPTI_TYPE_ZERO_BYTE
7100 | OPTI_TYPE_PRECOMPUTE_INIT
7101 | OPTI_TYPE_PRECOMPUTE_MERKLE
7102 | OPTI_TYPE_EARLY_SKIP
7103 | OPTI_TYPE_NOT_ITERATED
7104 | OPTI_TYPE_PREPENDED_SALT
7105 | OPTI_TYPE_RAW_HASH;
7106 dgst_pos0 = 3;
7107 dgst_pos1 = 4;
7108 dgst_pos2 = 2;
7109 dgst_pos3 = 1;
7110 break;
7111
7112 case 150: hash_type = HASH_TYPE_SHA1;
7113 salt_type = SALT_TYPE_INTERN;
7114 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7115 opts_type = OPTS_TYPE_PT_GENERATE_BE
7116 | OPTS_TYPE_ST_ADD80
7117 | OPTS_TYPE_ST_ADDBITS15;
7118 kern_type = KERN_TYPE_HMACSHA1_PW;
7119 dgst_size = DGST_SIZE_4_5;
7120 parse_func = hmacsha1_parse_hash;
7121 sort_by_digest = sort_by_digest_4_5;
7122 opti_type = OPTI_TYPE_ZERO_BYTE
7123 | OPTI_TYPE_NOT_ITERATED;
7124 dgst_pos0 = 3;
7125 dgst_pos1 = 4;
7126 dgst_pos2 = 2;
7127 dgst_pos3 = 1;
7128 break;
7129
7130 case 160: hash_type = HASH_TYPE_SHA1;
7131 salt_type = SALT_TYPE_INTERN;
7132 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7133 opts_type = OPTS_TYPE_PT_GENERATE_BE
7134 | OPTS_TYPE_PT_ADD80
7135 | OPTS_TYPE_PT_ADDBITS15;
7136 kern_type = KERN_TYPE_HMACSHA1_SLT;
7137 dgst_size = DGST_SIZE_4_5;
7138 parse_func = hmacsha1_parse_hash;
7139 sort_by_digest = sort_by_digest_4_5;
7140 opti_type = OPTI_TYPE_ZERO_BYTE
7141 | OPTI_TYPE_NOT_ITERATED;
7142 dgst_pos0 = 3;
7143 dgst_pos1 = 4;
7144 dgst_pos2 = 2;
7145 dgst_pos3 = 1;
7146 break;
7147
7148 case 190: hash_type = HASH_TYPE_SHA1;
7149 salt_type = SALT_TYPE_NONE;
7150 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7151 opts_type = OPTS_TYPE_PT_GENERATE_BE
7152 | OPTS_TYPE_PT_ADD80
7153 | OPTS_TYPE_PT_ADDBITS15;
7154 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7155 dgst_size = DGST_SIZE_4_5;
7156 parse_func = sha1linkedin_parse_hash;
7157 sort_by_digest = sort_by_digest_4_5;
7158 opti_type = OPTI_TYPE_ZERO_BYTE
7159 | OPTI_TYPE_PRECOMPUTE_INIT
7160 | OPTI_TYPE_EARLY_SKIP
7161 | OPTI_TYPE_NOT_ITERATED
7162 | OPTI_TYPE_NOT_SALTED;
7163 dgst_pos0 = 0;
7164 dgst_pos1 = 4;
7165 dgst_pos2 = 3;
7166 dgst_pos3 = 2;
7167 break;
7168
7169 case 200: hash_type = HASH_TYPE_MYSQL;
7170 salt_type = SALT_TYPE_NONE;
7171 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7172 opts_type = 0;
7173 kern_type = KERN_TYPE_MYSQL;
7174 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7175 parse_func = mysql323_parse_hash;
7176 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7177 opti_type = OPTI_TYPE_ZERO_BYTE;
7178 dgst_pos0 = 0;
7179 dgst_pos1 = 1;
7180 dgst_pos2 = 2;
7181 dgst_pos3 = 3;
7182 break;
7183
7184 case 300: hash_type = HASH_TYPE_SHA1;
7185 salt_type = SALT_TYPE_NONE;
7186 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7187 opts_type = OPTS_TYPE_PT_GENERATE_BE
7188 | OPTS_TYPE_PT_ADD80
7189 | OPTS_TYPE_PT_ADDBITS15;
7190 kern_type = KERN_TYPE_MYSQL41;
7191 dgst_size = DGST_SIZE_4_5;
7192 parse_func = sha1_parse_hash;
7193 sort_by_digest = sort_by_digest_4_5;
7194 opti_type = OPTI_TYPE_ZERO_BYTE
7195 | OPTI_TYPE_PRECOMPUTE_INIT
7196 | OPTI_TYPE_PRECOMPUTE_MERKLE
7197 | OPTI_TYPE_EARLY_SKIP
7198 | OPTI_TYPE_NOT_ITERATED
7199 | OPTI_TYPE_NOT_SALTED;
7200 dgst_pos0 = 3;
7201 dgst_pos1 = 4;
7202 dgst_pos2 = 2;
7203 dgst_pos3 = 1;
7204 break;
7205
7206 case 400: hash_type = HASH_TYPE_MD5;
7207 salt_type = SALT_TYPE_EMBEDDED;
7208 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7209 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7210 kern_type = KERN_TYPE_PHPASS;
7211 dgst_size = DGST_SIZE_4_4;
7212 parse_func = phpass_parse_hash;
7213 sort_by_digest = sort_by_digest_4_4;
7214 opti_type = OPTI_TYPE_ZERO_BYTE;
7215 dgst_pos0 = 0;
7216 dgst_pos1 = 1;
7217 dgst_pos2 = 2;
7218 dgst_pos3 = 3;
7219 break;
7220
7221 case 500: hash_type = HASH_TYPE_MD5;
7222 salt_type = SALT_TYPE_EMBEDDED;
7223 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7224 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7225 kern_type = KERN_TYPE_MD5CRYPT;
7226 dgst_size = DGST_SIZE_4_4;
7227 parse_func = md5crypt_parse_hash;
7228 sort_by_digest = sort_by_digest_4_4;
7229 opti_type = OPTI_TYPE_ZERO_BYTE;
7230 dgst_pos0 = 0;
7231 dgst_pos1 = 1;
7232 dgst_pos2 = 2;
7233 dgst_pos3 = 3;
7234 break;
7235
7236 case 501: hash_type = HASH_TYPE_MD5;
7237 salt_type = SALT_TYPE_EMBEDDED;
7238 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7239 opts_type = OPTS_TYPE_PT_GENERATE_LE
7240 | OPTS_TYPE_HASH_COPY;
7241 kern_type = KERN_TYPE_MD5CRYPT;
7242 dgst_size = DGST_SIZE_4_4;
7243 parse_func = juniper_parse_hash;
7244 sort_by_digest = sort_by_digest_4_4;
7245 opti_type = OPTI_TYPE_ZERO_BYTE;
7246 dgst_pos0 = 0;
7247 dgst_pos1 = 1;
7248 dgst_pos2 = 2;
7249 dgst_pos3 = 3;
7250 break;
7251
7252 case 900: hash_type = HASH_TYPE_MD4;
7253 salt_type = SALT_TYPE_NONE;
7254 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7255 opts_type = OPTS_TYPE_PT_GENERATE_LE
7256 | OPTS_TYPE_PT_ADD80
7257 | OPTS_TYPE_PT_ADDBITS14;
7258 kern_type = KERN_TYPE_MD4;
7259 dgst_size = DGST_SIZE_4_4;
7260 parse_func = md4_parse_hash;
7261 sort_by_digest = sort_by_digest_4_4;
7262 opti_type = OPTI_TYPE_ZERO_BYTE
7263 | OPTI_TYPE_PRECOMPUTE_INIT
7264 | OPTI_TYPE_PRECOMPUTE_MERKLE
7265 | OPTI_TYPE_MEET_IN_MIDDLE
7266 | OPTI_TYPE_EARLY_SKIP
7267 | OPTI_TYPE_NOT_ITERATED
7268 | OPTI_TYPE_NOT_SALTED
7269 | OPTI_TYPE_RAW_HASH;
7270 dgst_pos0 = 0;
7271 dgst_pos1 = 3;
7272 dgst_pos2 = 2;
7273 dgst_pos3 = 1;
7274 break;
7275
7276 case 1000: hash_type = HASH_TYPE_MD4;
7277 salt_type = SALT_TYPE_NONE;
7278 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7279 opts_type = OPTS_TYPE_PT_GENERATE_LE
7280 | OPTS_TYPE_PT_ADD80
7281 | OPTS_TYPE_PT_ADDBITS14
7282 | OPTS_TYPE_PT_UNICODE;
7283 kern_type = KERN_TYPE_MD4_PWU;
7284 dgst_size = DGST_SIZE_4_4;
7285 parse_func = md4_parse_hash;
7286 sort_by_digest = sort_by_digest_4_4;
7287 opti_type = OPTI_TYPE_ZERO_BYTE
7288 | OPTI_TYPE_PRECOMPUTE_INIT
7289 | OPTI_TYPE_PRECOMPUTE_MERKLE
7290 | OPTI_TYPE_MEET_IN_MIDDLE
7291 | OPTI_TYPE_EARLY_SKIP
7292 | OPTI_TYPE_NOT_ITERATED
7293 | OPTI_TYPE_NOT_SALTED
7294 | OPTI_TYPE_RAW_HASH;
7295 dgst_pos0 = 0;
7296 dgst_pos1 = 3;
7297 dgst_pos2 = 2;
7298 dgst_pos3 = 1;
7299 break;
7300
7301 case 1100: hash_type = HASH_TYPE_MD4;
7302 salt_type = SALT_TYPE_INTERN;
7303 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7304 opts_type = OPTS_TYPE_PT_GENERATE_LE
7305 | OPTS_TYPE_PT_ADD80
7306 | OPTS_TYPE_PT_ADDBITS14
7307 | OPTS_TYPE_PT_UNICODE
7308 | OPTS_TYPE_ST_ADD80
7309 | OPTS_TYPE_ST_UNICODE
7310 | OPTS_TYPE_ST_LOWER;
7311 kern_type = KERN_TYPE_MD44_PWUSLT;
7312 dgst_size = DGST_SIZE_4_4;
7313 parse_func = dcc_parse_hash;
7314 sort_by_digest = sort_by_digest_4_4;
7315 opti_type = OPTI_TYPE_ZERO_BYTE
7316 | OPTI_TYPE_PRECOMPUTE_INIT
7317 | OPTI_TYPE_PRECOMPUTE_MERKLE
7318 | OPTI_TYPE_EARLY_SKIP
7319 | OPTI_TYPE_NOT_ITERATED;
7320 dgst_pos0 = 0;
7321 dgst_pos1 = 3;
7322 dgst_pos2 = 2;
7323 dgst_pos3 = 1;
7324 break;
7325
7326 case 1400: hash_type = HASH_TYPE_SHA256;
7327 salt_type = SALT_TYPE_NONE;
7328 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7329 opts_type = OPTS_TYPE_PT_GENERATE_BE
7330 | OPTS_TYPE_PT_ADD80
7331 | OPTS_TYPE_PT_ADDBITS15;
7332 kern_type = KERN_TYPE_SHA256;
7333 dgst_size = DGST_SIZE_4_8;
7334 parse_func = sha256_parse_hash;
7335 sort_by_digest = sort_by_digest_4_8;
7336 opti_type = OPTI_TYPE_ZERO_BYTE
7337 | OPTI_TYPE_PRECOMPUTE_INIT
7338 | OPTI_TYPE_PRECOMPUTE_MERKLE
7339 | OPTI_TYPE_EARLY_SKIP
7340 | OPTI_TYPE_NOT_ITERATED
7341 | OPTI_TYPE_NOT_SALTED
7342 | OPTI_TYPE_RAW_HASH;
7343 dgst_pos0 = 3;
7344 dgst_pos1 = 7;
7345 dgst_pos2 = 2;
7346 dgst_pos3 = 6;
7347 break;
7348
7349 case 1410: hash_type = HASH_TYPE_SHA256;
7350 salt_type = SALT_TYPE_INTERN;
7351 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7352 opts_type = OPTS_TYPE_PT_GENERATE_BE
7353 | OPTS_TYPE_ST_ADD80
7354 | OPTS_TYPE_ST_ADDBITS15;
7355 kern_type = KERN_TYPE_SHA256_PWSLT;
7356 dgst_size = DGST_SIZE_4_8;
7357 parse_func = sha256s_parse_hash;
7358 sort_by_digest = sort_by_digest_4_8;
7359 opti_type = OPTI_TYPE_ZERO_BYTE
7360 | OPTI_TYPE_PRECOMPUTE_INIT
7361 | OPTI_TYPE_PRECOMPUTE_MERKLE
7362 | OPTI_TYPE_EARLY_SKIP
7363 | OPTI_TYPE_NOT_ITERATED
7364 | OPTI_TYPE_APPENDED_SALT
7365 | OPTI_TYPE_RAW_HASH;
7366 dgst_pos0 = 3;
7367 dgst_pos1 = 7;
7368 dgst_pos2 = 2;
7369 dgst_pos3 = 6;
7370 break;
7371
7372 case 1420: hash_type = HASH_TYPE_SHA256;
7373 salt_type = SALT_TYPE_INTERN;
7374 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7375 opts_type = OPTS_TYPE_PT_GENERATE_BE
7376 | OPTS_TYPE_PT_ADD80
7377 | OPTS_TYPE_PT_ADDBITS15;
7378 kern_type = KERN_TYPE_SHA256_SLTPW;
7379 dgst_size = DGST_SIZE_4_8;
7380 parse_func = sha256s_parse_hash;
7381 sort_by_digest = sort_by_digest_4_8;
7382 opti_type = OPTI_TYPE_ZERO_BYTE
7383 | OPTI_TYPE_PRECOMPUTE_INIT
7384 | OPTI_TYPE_PRECOMPUTE_MERKLE
7385 | OPTI_TYPE_EARLY_SKIP
7386 | OPTI_TYPE_NOT_ITERATED
7387 | OPTI_TYPE_PREPENDED_SALT
7388 | OPTI_TYPE_RAW_HASH;
7389 dgst_pos0 = 3;
7390 dgst_pos1 = 7;
7391 dgst_pos2 = 2;
7392 dgst_pos3 = 6;
7393 break;
7394
7395 case 1421: hash_type = HASH_TYPE_SHA256;
7396 salt_type = SALT_TYPE_EMBEDDED;
7397 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7398 opts_type = OPTS_TYPE_PT_GENERATE_BE
7399 | OPTS_TYPE_PT_ADD80
7400 | OPTS_TYPE_PT_ADDBITS15;
7401 kern_type = KERN_TYPE_SHA256_SLTPW;
7402 dgst_size = DGST_SIZE_4_8;
7403 parse_func = hmailserver_parse_hash;
7404 sort_by_digest = sort_by_digest_4_8;
7405 opti_type = OPTI_TYPE_ZERO_BYTE
7406 | OPTI_TYPE_PRECOMPUTE_INIT
7407 | OPTI_TYPE_PRECOMPUTE_MERKLE
7408 | OPTI_TYPE_EARLY_SKIP
7409 | OPTI_TYPE_NOT_ITERATED
7410 | OPTI_TYPE_PREPENDED_SALT
7411 | OPTI_TYPE_RAW_HASH;
7412 dgst_pos0 = 3;
7413 dgst_pos1 = 7;
7414 dgst_pos2 = 2;
7415 dgst_pos3 = 6;
7416 break;
7417
7418 case 1430: hash_type = HASH_TYPE_SHA256;
7419 salt_type = SALT_TYPE_INTERN;
7420 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7421 opts_type = OPTS_TYPE_PT_GENERATE_BE
7422 | OPTS_TYPE_PT_UNICODE
7423 | OPTS_TYPE_ST_ADD80
7424 | OPTS_TYPE_ST_ADDBITS15;
7425 kern_type = KERN_TYPE_SHA256_PWUSLT;
7426 dgst_size = DGST_SIZE_4_8;
7427 parse_func = sha256s_parse_hash;
7428 sort_by_digest = sort_by_digest_4_8;
7429 opti_type = OPTI_TYPE_ZERO_BYTE
7430 | OPTI_TYPE_PRECOMPUTE_INIT
7431 | OPTI_TYPE_PRECOMPUTE_MERKLE
7432 | OPTI_TYPE_EARLY_SKIP
7433 | OPTI_TYPE_NOT_ITERATED
7434 | OPTI_TYPE_APPENDED_SALT
7435 | OPTI_TYPE_RAW_HASH;
7436 dgst_pos0 = 3;
7437 dgst_pos1 = 7;
7438 dgst_pos2 = 2;
7439 dgst_pos3 = 6;
7440 break;
7441
7442 case 1440: hash_type = HASH_TYPE_SHA256;
7443 salt_type = SALT_TYPE_INTERN;
7444 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7445 opts_type = OPTS_TYPE_PT_GENERATE_BE
7446 | OPTS_TYPE_PT_ADD80
7447 | OPTS_TYPE_PT_ADDBITS15
7448 | OPTS_TYPE_PT_UNICODE;
7449 kern_type = KERN_TYPE_SHA256_SLTPWU;
7450 dgst_size = DGST_SIZE_4_8;
7451 parse_func = sha256s_parse_hash;
7452 sort_by_digest = sort_by_digest_4_8;
7453 opti_type = OPTI_TYPE_ZERO_BYTE
7454 | OPTI_TYPE_PRECOMPUTE_INIT
7455 | OPTI_TYPE_PRECOMPUTE_MERKLE
7456 | OPTI_TYPE_EARLY_SKIP
7457 | OPTI_TYPE_NOT_ITERATED
7458 | OPTI_TYPE_PREPENDED_SALT
7459 | OPTI_TYPE_RAW_HASH;
7460 dgst_pos0 = 3;
7461 dgst_pos1 = 7;
7462 dgst_pos2 = 2;
7463 dgst_pos3 = 6;
7464 break;
7465
7466 case 1441: hash_type = HASH_TYPE_SHA256;
7467 salt_type = SALT_TYPE_EMBEDDED;
7468 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7469 opts_type = OPTS_TYPE_PT_GENERATE_BE
7470 | OPTS_TYPE_PT_ADD80
7471 | OPTS_TYPE_PT_ADDBITS15
7472 | OPTS_TYPE_PT_UNICODE
7473 | OPTS_TYPE_ST_BASE64;
7474 kern_type = KERN_TYPE_SHA256_SLTPWU;
7475 dgst_size = DGST_SIZE_4_8;
7476 parse_func = episerver4_parse_hash;
7477 sort_by_digest = sort_by_digest_4_8;
7478 opti_type = OPTI_TYPE_ZERO_BYTE
7479 | OPTI_TYPE_PRECOMPUTE_INIT
7480 | OPTI_TYPE_PRECOMPUTE_MERKLE
7481 | OPTI_TYPE_EARLY_SKIP
7482 | OPTI_TYPE_NOT_ITERATED
7483 | OPTI_TYPE_PREPENDED_SALT
7484 | OPTI_TYPE_RAW_HASH;
7485 dgst_pos0 = 3;
7486 dgst_pos1 = 7;
7487 dgst_pos2 = 2;
7488 dgst_pos3 = 6;
7489 break;
7490
7491 case 1450: hash_type = HASH_TYPE_SHA256;
7492 salt_type = SALT_TYPE_INTERN;
7493 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7494 opts_type = OPTS_TYPE_PT_GENERATE_BE
7495 | OPTS_TYPE_ST_ADD80;
7496 kern_type = KERN_TYPE_HMACSHA256_PW;
7497 dgst_size = DGST_SIZE_4_8;
7498 parse_func = hmacsha256_parse_hash;
7499 sort_by_digest = sort_by_digest_4_8;
7500 opti_type = OPTI_TYPE_ZERO_BYTE
7501 | OPTI_TYPE_NOT_ITERATED;
7502 dgst_pos0 = 3;
7503 dgst_pos1 = 7;
7504 dgst_pos2 = 2;
7505 dgst_pos3 = 6;
7506 break;
7507
7508 case 1460: hash_type = HASH_TYPE_SHA256;
7509 salt_type = SALT_TYPE_INTERN;
7510 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7511 opts_type = OPTS_TYPE_PT_GENERATE_BE
7512 | OPTS_TYPE_PT_ADD80
7513 | OPTS_TYPE_PT_ADDBITS15;
7514 kern_type = KERN_TYPE_HMACSHA256_SLT;
7515 dgst_size = DGST_SIZE_4_8;
7516 parse_func = hmacsha256_parse_hash;
7517 sort_by_digest = sort_by_digest_4_8;
7518 opti_type = OPTI_TYPE_ZERO_BYTE
7519 | OPTI_TYPE_NOT_ITERATED;
7520 dgst_pos0 = 3;
7521 dgst_pos1 = 7;
7522 dgst_pos2 = 2;
7523 dgst_pos3 = 6;
7524 break;
7525
7526 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7527 salt_type = SALT_TYPE_EMBEDDED;
7528 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7529 opts_type = OPTS_TYPE_PT_GENERATE_LE
7530 | OPTS_TYPE_PT_BITSLICE;
7531 kern_type = KERN_TYPE_DESCRYPT;
7532 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7533 parse_func = descrypt_parse_hash;
7534 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7535 opti_type = OPTI_TYPE_ZERO_BYTE
7536 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7537 dgst_pos0 = 0;
7538 dgst_pos1 = 1;
7539 dgst_pos2 = 2;
7540 dgst_pos3 = 3;
7541 break;
7542
7543 case 1600: hash_type = HASH_TYPE_MD5;
7544 salt_type = SALT_TYPE_EMBEDDED;
7545 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7546 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7547 kern_type = KERN_TYPE_APR1CRYPT;
7548 dgst_size = DGST_SIZE_4_4;
7549 parse_func = md5apr1_parse_hash;
7550 sort_by_digest = sort_by_digest_4_4;
7551 opti_type = OPTI_TYPE_ZERO_BYTE;
7552 dgst_pos0 = 0;
7553 dgst_pos1 = 1;
7554 dgst_pos2 = 2;
7555 dgst_pos3 = 3;
7556 break;
7557
7558 case 1700: hash_type = HASH_TYPE_SHA512;
7559 salt_type = SALT_TYPE_NONE;
7560 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7561 opts_type = OPTS_TYPE_PT_GENERATE_BE
7562 | OPTS_TYPE_PT_ADD80
7563 | OPTS_TYPE_PT_ADDBITS15;
7564 kern_type = KERN_TYPE_SHA512;
7565 dgst_size = DGST_SIZE_8_8;
7566 parse_func = sha512_parse_hash;
7567 sort_by_digest = sort_by_digest_8_8;
7568 opti_type = OPTI_TYPE_ZERO_BYTE
7569 | OPTI_TYPE_PRECOMPUTE_INIT
7570 | OPTI_TYPE_PRECOMPUTE_MERKLE
7571 | OPTI_TYPE_EARLY_SKIP
7572 | OPTI_TYPE_NOT_ITERATED
7573 | OPTI_TYPE_NOT_SALTED
7574 | OPTI_TYPE_RAW_HASH;
7575 dgst_pos0 = 14;
7576 dgst_pos1 = 15;
7577 dgst_pos2 = 6;
7578 dgst_pos3 = 7;
7579 break;
7580
7581 case 1710: hash_type = HASH_TYPE_SHA512;
7582 salt_type = SALT_TYPE_INTERN;
7583 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7584 opts_type = OPTS_TYPE_PT_GENERATE_BE
7585 | OPTS_TYPE_ST_ADD80
7586 | OPTS_TYPE_ST_ADDBITS15;
7587 kern_type = KERN_TYPE_SHA512_PWSLT;
7588 dgst_size = DGST_SIZE_8_8;
7589 parse_func = sha512s_parse_hash;
7590 sort_by_digest = sort_by_digest_8_8;
7591 opti_type = OPTI_TYPE_ZERO_BYTE
7592 | OPTI_TYPE_PRECOMPUTE_INIT
7593 | OPTI_TYPE_PRECOMPUTE_MERKLE
7594 | OPTI_TYPE_EARLY_SKIP
7595 | OPTI_TYPE_NOT_ITERATED
7596 | OPTI_TYPE_APPENDED_SALT
7597 | OPTI_TYPE_RAW_HASH;
7598 dgst_pos0 = 14;
7599 dgst_pos1 = 15;
7600 dgst_pos2 = 6;
7601 dgst_pos3 = 7;
7602 break;
7603
7604 case 1711: hash_type = HASH_TYPE_SHA512;
7605 salt_type = SALT_TYPE_EMBEDDED;
7606 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7607 opts_type = OPTS_TYPE_PT_GENERATE_BE
7608 | OPTS_TYPE_ST_ADD80
7609 | OPTS_TYPE_ST_ADDBITS15;
7610 kern_type = KERN_TYPE_SHA512_PWSLT;
7611 dgst_size = DGST_SIZE_8_8;
7612 parse_func = sha512b64s_parse_hash;
7613 sort_by_digest = sort_by_digest_8_8;
7614 opti_type = OPTI_TYPE_ZERO_BYTE
7615 | OPTI_TYPE_PRECOMPUTE_INIT
7616 | OPTI_TYPE_PRECOMPUTE_MERKLE
7617 | OPTI_TYPE_EARLY_SKIP
7618 | OPTI_TYPE_NOT_ITERATED
7619 | OPTI_TYPE_APPENDED_SALT
7620 | OPTI_TYPE_RAW_HASH;
7621 dgst_pos0 = 14;
7622 dgst_pos1 = 15;
7623 dgst_pos2 = 6;
7624 dgst_pos3 = 7;
7625 break;
7626
7627 case 1720: hash_type = HASH_TYPE_SHA512;
7628 salt_type = SALT_TYPE_INTERN;
7629 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7630 opts_type = OPTS_TYPE_PT_GENERATE_BE
7631 | OPTS_TYPE_PT_ADD80
7632 | OPTS_TYPE_PT_ADDBITS15;
7633 kern_type = KERN_TYPE_SHA512_SLTPW;
7634 dgst_size = DGST_SIZE_8_8;
7635 parse_func = sha512s_parse_hash;
7636 sort_by_digest = sort_by_digest_8_8;
7637 opti_type = OPTI_TYPE_ZERO_BYTE
7638 | OPTI_TYPE_PRECOMPUTE_INIT
7639 | OPTI_TYPE_PRECOMPUTE_MERKLE
7640 | OPTI_TYPE_EARLY_SKIP
7641 | OPTI_TYPE_NOT_ITERATED
7642 | OPTI_TYPE_PREPENDED_SALT
7643 | OPTI_TYPE_RAW_HASH;
7644 dgst_pos0 = 14;
7645 dgst_pos1 = 15;
7646 dgst_pos2 = 6;
7647 dgst_pos3 = 7;
7648 break;
7649
7650 case 1722: hash_type = HASH_TYPE_SHA512;
7651 salt_type = SALT_TYPE_EMBEDDED;
7652 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7653 opts_type = OPTS_TYPE_PT_GENERATE_BE
7654 | OPTS_TYPE_PT_ADD80
7655 | OPTS_TYPE_PT_ADDBITS15
7656 | OPTS_TYPE_ST_HEX;
7657 kern_type = KERN_TYPE_SHA512_SLTPW;
7658 dgst_size = DGST_SIZE_8_8;
7659 parse_func = osx512_parse_hash;
7660 sort_by_digest = sort_by_digest_8_8;
7661 opti_type = OPTI_TYPE_ZERO_BYTE
7662 | OPTI_TYPE_PRECOMPUTE_INIT
7663 | OPTI_TYPE_PRECOMPUTE_MERKLE
7664 | OPTI_TYPE_EARLY_SKIP
7665 | OPTI_TYPE_NOT_ITERATED
7666 | OPTI_TYPE_PREPENDED_SALT
7667 | OPTI_TYPE_RAW_HASH;
7668 dgst_pos0 = 14;
7669 dgst_pos1 = 15;
7670 dgst_pos2 = 6;
7671 dgst_pos3 = 7;
7672 break;
7673
7674 case 1730: hash_type = HASH_TYPE_SHA512;
7675 salt_type = SALT_TYPE_INTERN;
7676 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7677 opts_type = OPTS_TYPE_PT_GENERATE_BE
7678 | OPTS_TYPE_PT_UNICODE
7679 | OPTS_TYPE_ST_ADD80
7680 | OPTS_TYPE_ST_ADDBITS15;
7681 kern_type = KERN_TYPE_SHA512_PWSLTU;
7682 dgst_size = DGST_SIZE_8_8;
7683 parse_func = sha512s_parse_hash;
7684 sort_by_digest = sort_by_digest_8_8;
7685 opti_type = OPTI_TYPE_ZERO_BYTE
7686 | OPTI_TYPE_PRECOMPUTE_INIT
7687 | OPTI_TYPE_PRECOMPUTE_MERKLE
7688 | OPTI_TYPE_EARLY_SKIP
7689 | OPTI_TYPE_NOT_ITERATED
7690 | OPTI_TYPE_APPENDED_SALT
7691 | OPTI_TYPE_RAW_HASH;
7692 dgst_pos0 = 14;
7693 dgst_pos1 = 15;
7694 dgst_pos2 = 6;
7695 dgst_pos3 = 7;
7696 break;
7697
7698 case 1731: hash_type = HASH_TYPE_SHA512;
7699 salt_type = SALT_TYPE_EMBEDDED;
7700 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7701 opts_type = OPTS_TYPE_PT_GENERATE_BE
7702 | OPTS_TYPE_PT_UNICODE
7703 | OPTS_TYPE_ST_ADD80
7704 | OPTS_TYPE_ST_ADDBITS15
7705 | OPTS_TYPE_ST_HEX;
7706 kern_type = KERN_TYPE_SHA512_PWSLTU;
7707 dgst_size = DGST_SIZE_8_8;
7708 parse_func = mssql2012_parse_hash;
7709 sort_by_digest = sort_by_digest_8_8;
7710 opti_type = OPTI_TYPE_ZERO_BYTE
7711 | OPTI_TYPE_PRECOMPUTE_INIT
7712 | OPTI_TYPE_PRECOMPUTE_MERKLE
7713 | OPTI_TYPE_EARLY_SKIP
7714 | OPTI_TYPE_NOT_ITERATED
7715 | OPTI_TYPE_APPENDED_SALT
7716 | OPTI_TYPE_RAW_HASH;
7717 dgst_pos0 = 14;
7718 dgst_pos1 = 15;
7719 dgst_pos2 = 6;
7720 dgst_pos3 = 7;
7721 break;
7722
7723 case 1740: hash_type = HASH_TYPE_SHA512;
7724 salt_type = SALT_TYPE_INTERN;
7725 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7726 opts_type = OPTS_TYPE_PT_GENERATE_BE
7727 | OPTS_TYPE_PT_ADD80
7728 | OPTS_TYPE_PT_ADDBITS15
7729 | OPTS_TYPE_PT_UNICODE;
7730 kern_type = KERN_TYPE_SHA512_SLTPWU;
7731 dgst_size = DGST_SIZE_8_8;
7732 parse_func = sha512s_parse_hash;
7733 sort_by_digest = sort_by_digest_8_8;
7734 opti_type = OPTI_TYPE_ZERO_BYTE
7735 | OPTI_TYPE_PRECOMPUTE_INIT
7736 | OPTI_TYPE_PRECOMPUTE_MERKLE
7737 | OPTI_TYPE_EARLY_SKIP
7738 | OPTI_TYPE_NOT_ITERATED
7739 | OPTI_TYPE_PREPENDED_SALT
7740 | OPTI_TYPE_RAW_HASH;
7741 dgst_pos0 = 14;
7742 dgst_pos1 = 15;
7743 dgst_pos2 = 6;
7744 dgst_pos3 = 7;
7745 break;
7746
7747 case 1750: hash_type = HASH_TYPE_SHA512;
7748 salt_type = SALT_TYPE_INTERN;
7749 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7750 opts_type = OPTS_TYPE_PT_GENERATE_BE
7751 | OPTS_TYPE_ST_ADD80;
7752 kern_type = KERN_TYPE_HMACSHA512_PW;
7753 dgst_size = DGST_SIZE_8_8;
7754 parse_func = hmacsha512_parse_hash;
7755 sort_by_digest = sort_by_digest_8_8;
7756 opti_type = OPTI_TYPE_ZERO_BYTE
7757 | OPTI_TYPE_NOT_ITERATED;
7758 dgst_pos0 = 14;
7759 dgst_pos1 = 15;
7760 dgst_pos2 = 6;
7761 dgst_pos3 = 7;
7762 break;
7763
7764 case 1760: hash_type = HASH_TYPE_SHA512;
7765 salt_type = SALT_TYPE_INTERN;
7766 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7767 opts_type = OPTS_TYPE_PT_GENERATE_BE
7768 | OPTS_TYPE_PT_ADD80
7769 | OPTS_TYPE_PT_ADDBITS15;
7770 kern_type = KERN_TYPE_HMACSHA512_SLT;
7771 dgst_size = DGST_SIZE_8_8;
7772 parse_func = hmacsha512_parse_hash;
7773 sort_by_digest = sort_by_digest_8_8;
7774 opti_type = OPTI_TYPE_ZERO_BYTE
7775 | OPTI_TYPE_NOT_ITERATED;
7776 dgst_pos0 = 14;
7777 dgst_pos1 = 15;
7778 dgst_pos2 = 6;
7779 dgst_pos3 = 7;
7780 break;
7781
7782 case 1800: hash_type = HASH_TYPE_SHA512;
7783 salt_type = SALT_TYPE_EMBEDDED;
7784 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7785 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7786 kern_type = KERN_TYPE_SHA512CRYPT;
7787 dgst_size = DGST_SIZE_8_8;
7788 parse_func = sha512crypt_parse_hash;
7789 sort_by_digest = sort_by_digest_8_8;
7790 opti_type = OPTI_TYPE_ZERO_BYTE;
7791 dgst_pos0 = 0;
7792 dgst_pos1 = 1;
7793 dgst_pos2 = 2;
7794 dgst_pos3 = 3;
7795 break;
7796
7797 case 2100: hash_type = HASH_TYPE_DCC2;
7798 salt_type = SALT_TYPE_EMBEDDED;
7799 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7800 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
7801 | OPTS_TYPE_ST_LOWER
7802 | OPTS_TYPE_ST_UNICODE;
7803 kern_type = KERN_TYPE_DCC2;
7804 dgst_size = DGST_SIZE_4_4;
7805 parse_func = dcc2_parse_hash;
7806 sort_by_digest = sort_by_digest_4_4;
7807 opti_type = OPTI_TYPE_ZERO_BYTE;
7808 dgst_pos0 = 0;
7809 dgst_pos1 = 1;
7810 dgst_pos2 = 2;
7811 dgst_pos3 = 3;
7812 break;
7813
7814 case 2400: hash_type = HASH_TYPE_MD5;
7815 salt_type = SALT_TYPE_NONE;
7816 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7817 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7818 kern_type = KERN_TYPE_MD5PIX;
7819 dgst_size = DGST_SIZE_4_4;
7820 parse_func = md5pix_parse_hash;
7821 sort_by_digest = sort_by_digest_4_4;
7822 opti_type = OPTI_TYPE_ZERO_BYTE
7823 | OPTI_TYPE_PRECOMPUTE_INIT
7824 | OPTI_TYPE_PRECOMPUTE_MERKLE
7825 | OPTI_TYPE_EARLY_SKIP
7826 | OPTI_TYPE_NOT_ITERATED
7827 | OPTI_TYPE_NOT_SALTED;
7828 dgst_pos0 = 0;
7829 dgst_pos1 = 3;
7830 dgst_pos2 = 2;
7831 dgst_pos3 = 1;
7832 break;
7833
7834 case 2410: hash_type = HASH_TYPE_MD5;
7835 salt_type = SALT_TYPE_INTERN;
7836 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7837 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7838 kern_type = KERN_TYPE_MD5ASA;
7839 dgst_size = DGST_SIZE_4_4;
7840 parse_func = md5asa_parse_hash;
7841 sort_by_digest = sort_by_digest_4_4;
7842 opti_type = OPTI_TYPE_ZERO_BYTE
7843 | OPTI_TYPE_PRECOMPUTE_INIT
7844 | OPTI_TYPE_PRECOMPUTE_MERKLE
7845 | OPTI_TYPE_EARLY_SKIP
7846 | OPTI_TYPE_NOT_ITERATED;
7847 dgst_pos0 = 0;
7848 dgst_pos1 = 3;
7849 dgst_pos2 = 2;
7850 dgst_pos3 = 1;
7851 break;
7852
7853 case 2500: hash_type = HASH_TYPE_WPA;
7854 salt_type = SALT_TYPE_EMBEDDED;
7855 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7856 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7857 kern_type = KERN_TYPE_WPA;
7858 dgst_size = DGST_SIZE_4_4;
7859 parse_func = wpa_parse_hash;
7860 sort_by_digest = sort_by_digest_4_4;
7861 opti_type = OPTI_TYPE_ZERO_BYTE;
7862 dgst_pos0 = 0;
7863 dgst_pos1 = 1;
7864 dgst_pos2 = 2;
7865 dgst_pos3 = 3;
7866 break;
7867
7868 case 2600: hash_type = HASH_TYPE_MD5;
7869 salt_type = SALT_TYPE_VIRTUAL;
7870 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7871 opts_type = OPTS_TYPE_PT_GENERATE_LE
7872 | OPTS_TYPE_PT_ADD80
7873 | OPTS_TYPE_PT_ADDBITS14
7874 | OPTS_TYPE_ST_ADD80;
7875 kern_type = KERN_TYPE_MD55_PWSLT1;
7876 dgst_size = DGST_SIZE_4_4;
7877 parse_func = md5md5_parse_hash;
7878 sort_by_digest = sort_by_digest_4_4;
7879 opti_type = OPTI_TYPE_ZERO_BYTE
7880 | OPTI_TYPE_PRECOMPUTE_INIT
7881 | OPTI_TYPE_PRECOMPUTE_MERKLE
7882 | OPTI_TYPE_EARLY_SKIP;
7883 dgst_pos0 = 0;
7884 dgst_pos1 = 3;
7885 dgst_pos2 = 2;
7886 dgst_pos3 = 1;
7887 break;
7888
7889 case 2611: hash_type = HASH_TYPE_MD5;
7890 salt_type = SALT_TYPE_INTERN;
7891 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7892 opts_type = OPTS_TYPE_PT_GENERATE_LE
7893 | OPTS_TYPE_PT_ADD80
7894 | OPTS_TYPE_PT_ADDBITS14
7895 | OPTS_TYPE_ST_ADD80;
7896 kern_type = KERN_TYPE_MD55_PWSLT1;
7897 dgst_size = DGST_SIZE_4_4;
7898 parse_func = vb3_parse_hash;
7899 sort_by_digest = sort_by_digest_4_4;
7900 opti_type = OPTI_TYPE_ZERO_BYTE
7901 | OPTI_TYPE_PRECOMPUTE_INIT
7902 | OPTI_TYPE_PRECOMPUTE_MERKLE
7903 | OPTI_TYPE_EARLY_SKIP;
7904 dgst_pos0 = 0;
7905 dgst_pos1 = 3;
7906 dgst_pos2 = 2;
7907 dgst_pos3 = 1;
7908 break;
7909
7910 case 2612: hash_type = HASH_TYPE_MD5;
7911 salt_type = SALT_TYPE_EMBEDDED;
7912 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7913 opts_type = OPTS_TYPE_PT_GENERATE_LE
7914 | OPTS_TYPE_PT_ADD80
7915 | OPTS_TYPE_PT_ADDBITS14
7916 | OPTS_TYPE_ST_ADD80
7917 | OPTS_TYPE_ST_HEX;
7918 kern_type = KERN_TYPE_MD55_PWSLT1;
7919 dgst_size = DGST_SIZE_4_4;
7920 parse_func = phps_parse_hash;
7921 sort_by_digest = sort_by_digest_4_4;
7922 opti_type = OPTI_TYPE_ZERO_BYTE
7923 | OPTI_TYPE_PRECOMPUTE_INIT
7924 | OPTI_TYPE_PRECOMPUTE_MERKLE
7925 | OPTI_TYPE_EARLY_SKIP;
7926 dgst_pos0 = 0;
7927 dgst_pos1 = 3;
7928 dgst_pos2 = 2;
7929 dgst_pos3 = 1;
7930 break;
7931
7932 case 2711: hash_type = HASH_TYPE_MD5;
7933 salt_type = SALT_TYPE_INTERN;
7934 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7935 opts_type = OPTS_TYPE_PT_GENERATE_LE
7936 | OPTS_TYPE_PT_ADD80
7937 | OPTS_TYPE_PT_ADDBITS14
7938 | OPTS_TYPE_ST_ADD80;
7939 kern_type = KERN_TYPE_MD55_PWSLT2;
7940 dgst_size = DGST_SIZE_4_4;
7941 parse_func = vb30_parse_hash;
7942 sort_by_digest = sort_by_digest_4_4;
7943 opti_type = OPTI_TYPE_ZERO_BYTE
7944 | OPTI_TYPE_PRECOMPUTE_INIT
7945 | OPTI_TYPE_EARLY_SKIP;
7946 dgst_pos0 = 0;
7947 dgst_pos1 = 3;
7948 dgst_pos2 = 2;
7949 dgst_pos3 = 1;
7950 break;
7951
7952 case 2811: hash_type = HASH_TYPE_MD5;
7953 salt_type = SALT_TYPE_INTERN;
7954 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7955 opts_type = OPTS_TYPE_PT_GENERATE_LE
7956 | OPTS_TYPE_PT_ADD80
7957 | OPTS_TYPE_PT_ADDBITS14;
7958 kern_type = KERN_TYPE_MD55_SLTPW;
7959 dgst_size = DGST_SIZE_4_4;
7960 parse_func = ipb2_parse_hash;
7961 sort_by_digest = sort_by_digest_4_4;
7962 opti_type = OPTI_TYPE_ZERO_BYTE
7963 | OPTI_TYPE_PRECOMPUTE_INIT
7964 | OPTI_TYPE_EARLY_SKIP;
7965 dgst_pos0 = 0;
7966 dgst_pos1 = 3;
7967 dgst_pos2 = 2;
7968 dgst_pos3 = 1;
7969 break;
7970
7971 case 3000: hash_type = HASH_TYPE_LM;
7972 salt_type = SALT_TYPE_NONE;
7973 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7974 opts_type = OPTS_TYPE_PT_GENERATE_LE
7975 | OPTS_TYPE_PT_UPPER
7976 | OPTS_TYPE_PT_BITSLICE;
7977 kern_type = KERN_TYPE_LM;
7978 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7979 parse_func = lm_parse_hash;
7980 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7981 opti_type = OPTI_TYPE_ZERO_BYTE
7982 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7983 dgst_pos0 = 0;
7984 dgst_pos1 = 1;
7985 dgst_pos2 = 2;
7986 dgst_pos3 = 3;
7987 break;
7988
7989 case 3100: hash_type = HASH_TYPE_ORACLEH;
7990 salt_type = SALT_TYPE_INTERN;
7991 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7992 opts_type = OPTS_TYPE_PT_GENERATE_LE
7993 | OPTS_TYPE_PT_UPPER
7994 | OPTS_TYPE_ST_UPPER;
7995 kern_type = KERN_TYPE_ORACLEH;
7996 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7997 parse_func = oracleh_parse_hash;
7998 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7999 opti_type = OPTI_TYPE_ZERO_BYTE;
8000 dgst_pos0 = 0;
8001 dgst_pos1 = 1;
8002 dgst_pos2 = 2;
8003 dgst_pos3 = 3;
8004 break;
8005
8006 case 3200: hash_type = HASH_TYPE_BCRYPT;
8007 salt_type = SALT_TYPE_EMBEDDED;
8008 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8009 opts_type = OPTS_TYPE_PT_GENERATE_LE
8010 | OPTS_TYPE_ST_GENERATE_LE;
8011 kern_type = KERN_TYPE_BCRYPT;
8012 dgst_size = DGST_SIZE_4_6;
8013 parse_func = bcrypt_parse_hash;
8014 sort_by_digest = sort_by_digest_4_6;
8015 opti_type = OPTI_TYPE_ZERO_BYTE;
8016 dgst_pos0 = 0;
8017 dgst_pos1 = 1;
8018 dgst_pos2 = 2;
8019 dgst_pos3 = 3;
8020 break;
8021
8022 case 3710: hash_type = HASH_TYPE_MD5;
8023 salt_type = SALT_TYPE_INTERN;
8024 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8025 opts_type = OPTS_TYPE_PT_GENERATE_LE
8026 | OPTS_TYPE_PT_ADD80
8027 | OPTS_TYPE_PT_ADDBITS14;
8028 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8029 dgst_size = DGST_SIZE_4_4;
8030 parse_func = md5s_parse_hash;
8031 sort_by_digest = sort_by_digest_4_4;
8032 opti_type = OPTI_TYPE_ZERO_BYTE
8033 | OPTI_TYPE_PRECOMPUTE_INIT
8034 | OPTI_TYPE_PRECOMPUTE_MERKLE
8035 | OPTI_TYPE_EARLY_SKIP;
8036 dgst_pos0 = 0;
8037 dgst_pos1 = 3;
8038 dgst_pos2 = 2;
8039 dgst_pos3 = 1;
8040 break;
8041
8042 case 3711: hash_type = HASH_TYPE_MD5;
8043 salt_type = SALT_TYPE_EMBEDDED;
8044 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8045 opts_type = OPTS_TYPE_PT_GENERATE_LE
8046 | OPTS_TYPE_PT_ADD80
8047 | OPTS_TYPE_PT_ADDBITS14;
8048 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8049 dgst_size = DGST_SIZE_4_4;
8050 parse_func = mediawiki_b_parse_hash;
8051 sort_by_digest = sort_by_digest_4_4;
8052 opti_type = OPTI_TYPE_ZERO_BYTE
8053 | OPTI_TYPE_PRECOMPUTE_INIT
8054 | OPTI_TYPE_PRECOMPUTE_MERKLE
8055 | OPTI_TYPE_EARLY_SKIP;
8056 dgst_pos0 = 0;
8057 dgst_pos1 = 3;
8058 dgst_pos2 = 2;
8059 dgst_pos3 = 1;
8060 break;
8061
8062 case 3800: hash_type = HASH_TYPE_MD5;
8063 salt_type = SALT_TYPE_INTERN;
8064 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8065 opts_type = OPTS_TYPE_PT_GENERATE_LE
8066 | OPTS_TYPE_ST_ADDBITS14;
8067 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8068 dgst_size = DGST_SIZE_4_4;
8069 parse_func = md5s_parse_hash;
8070 sort_by_digest = sort_by_digest_4_4;
8071 opti_type = OPTI_TYPE_ZERO_BYTE
8072 | OPTI_TYPE_PRECOMPUTE_INIT
8073 | OPTI_TYPE_PRECOMPUTE_MERKLE
8074 | OPTI_TYPE_EARLY_SKIP
8075 | OPTI_TYPE_NOT_ITERATED
8076 | OPTI_TYPE_RAW_HASH;
8077 dgst_pos0 = 0;
8078 dgst_pos1 = 3;
8079 dgst_pos2 = 2;
8080 dgst_pos3 = 1;
8081 break;
8082
8083 case 4300: hash_type = HASH_TYPE_MD5;
8084 salt_type = SALT_TYPE_VIRTUAL;
8085 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8086 opts_type = OPTS_TYPE_PT_GENERATE_LE
8087 | OPTS_TYPE_PT_ADD80
8088 | OPTS_TYPE_PT_ADDBITS14
8089 | OPTS_TYPE_ST_ADD80;
8090 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8091 dgst_size = DGST_SIZE_4_4;
8092 parse_func = md5md5_parse_hash;
8093 sort_by_digest = sort_by_digest_4_4;
8094 opti_type = OPTI_TYPE_ZERO_BYTE
8095 | OPTI_TYPE_PRECOMPUTE_INIT
8096 | OPTI_TYPE_PRECOMPUTE_MERKLE
8097 | OPTI_TYPE_EARLY_SKIP;
8098 dgst_pos0 = 0;
8099 dgst_pos1 = 3;
8100 dgst_pos2 = 2;
8101 dgst_pos3 = 1;
8102 break;
8103
8104
8105 case 4400: hash_type = HASH_TYPE_MD5;
8106 salt_type = SALT_TYPE_NONE;
8107 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8108 opts_type = OPTS_TYPE_PT_GENERATE_BE
8109 | OPTS_TYPE_PT_ADD80
8110 | OPTS_TYPE_PT_ADDBITS15;
8111 kern_type = KERN_TYPE_MD5_SHA1;
8112 dgst_size = DGST_SIZE_4_4;
8113 parse_func = md5_parse_hash;
8114 sort_by_digest = sort_by_digest_4_4;
8115 opti_type = OPTI_TYPE_ZERO_BYTE
8116 | OPTI_TYPE_PRECOMPUTE_INIT
8117 | OPTI_TYPE_PRECOMPUTE_MERKLE
8118 | OPTI_TYPE_EARLY_SKIP
8119 | OPTI_TYPE_NOT_ITERATED
8120 | OPTI_TYPE_NOT_SALTED
8121 | OPTI_TYPE_RAW_HASH;
8122 dgst_pos0 = 0;
8123 dgst_pos1 = 3;
8124 dgst_pos2 = 2;
8125 dgst_pos3 = 1;
8126 break;
8127
8128 case 4500: hash_type = HASH_TYPE_SHA1;
8129 salt_type = SALT_TYPE_NONE;
8130 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8131 opts_type = OPTS_TYPE_PT_GENERATE_BE
8132 | OPTS_TYPE_PT_ADD80
8133 | OPTS_TYPE_PT_ADDBITS15;
8134 kern_type = KERN_TYPE_SHA11;
8135 dgst_size = DGST_SIZE_4_5;
8136 parse_func = sha1_parse_hash;
8137 sort_by_digest = sort_by_digest_4_5;
8138 opti_type = OPTI_TYPE_ZERO_BYTE
8139 | OPTI_TYPE_PRECOMPUTE_INIT
8140 | OPTI_TYPE_PRECOMPUTE_MERKLE
8141 | OPTI_TYPE_EARLY_SKIP
8142 | OPTI_TYPE_NOT_SALTED;
8143 dgst_pos0 = 3;
8144 dgst_pos1 = 4;
8145 dgst_pos2 = 2;
8146 dgst_pos3 = 1;
8147 break;
8148
8149 case 4700: hash_type = HASH_TYPE_SHA1;
8150 salt_type = SALT_TYPE_NONE;
8151 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8152 opts_type = OPTS_TYPE_PT_GENERATE_LE
8153 | OPTS_TYPE_PT_ADD80
8154 | OPTS_TYPE_PT_ADDBITS14;
8155 kern_type = KERN_TYPE_SHA1_MD5;
8156 dgst_size = DGST_SIZE_4_5;
8157 parse_func = sha1_parse_hash;
8158 sort_by_digest = sort_by_digest_4_5;
8159 opti_type = OPTI_TYPE_ZERO_BYTE
8160 | OPTI_TYPE_PRECOMPUTE_INIT
8161 | OPTI_TYPE_PRECOMPUTE_MERKLE
8162 | OPTI_TYPE_EARLY_SKIP
8163 | OPTI_TYPE_NOT_ITERATED
8164 | OPTI_TYPE_NOT_SALTED
8165 | OPTI_TYPE_RAW_HASH;
8166 dgst_pos0 = 3;
8167 dgst_pos1 = 4;
8168 dgst_pos2 = 2;
8169 dgst_pos3 = 1;
8170 break;
8171
8172 case 4800: hash_type = HASH_TYPE_MD5;
8173 salt_type = SALT_TYPE_EMBEDDED;
8174 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8175 opts_type = OPTS_TYPE_PT_GENERATE_LE
8176 | OPTS_TYPE_PT_ADDBITS14;
8177 kern_type = KERN_TYPE_MD5_CHAP;
8178 dgst_size = DGST_SIZE_4_4;
8179 parse_func = chap_parse_hash;
8180 sort_by_digest = sort_by_digest_4_4;
8181 opti_type = OPTI_TYPE_ZERO_BYTE
8182 | OPTI_TYPE_PRECOMPUTE_INIT
8183 | OPTI_TYPE_PRECOMPUTE_MERKLE
8184 | OPTI_TYPE_MEET_IN_MIDDLE
8185 | OPTI_TYPE_EARLY_SKIP
8186 | OPTI_TYPE_NOT_ITERATED
8187 | OPTI_TYPE_RAW_HASH;
8188 dgst_pos0 = 0;
8189 dgst_pos1 = 3;
8190 dgst_pos2 = 2;
8191 dgst_pos3 = 1;
8192 break;
8193
8194 case 4900: hash_type = HASH_TYPE_SHA1;
8195 salt_type = SALT_TYPE_INTERN;
8196 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8197 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8198 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8199 dgst_size = DGST_SIZE_4_5;
8200 parse_func = sha1s_parse_hash;
8201 sort_by_digest = sort_by_digest_4_5;
8202 opti_type = OPTI_TYPE_ZERO_BYTE
8203 | OPTI_TYPE_PRECOMPUTE_INIT
8204 | OPTI_TYPE_PRECOMPUTE_MERKLE
8205 | OPTI_TYPE_EARLY_SKIP;
8206 dgst_pos0 = 3;
8207 dgst_pos1 = 4;
8208 dgst_pos2 = 2;
8209 dgst_pos3 = 1;
8210 break;
8211
8212 case 5000: hash_type = HASH_TYPE_KECCAK;
8213 salt_type = SALT_TYPE_EMBEDDED;
8214 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8215 opts_type = OPTS_TYPE_PT_GENERATE_LE
8216 | OPTS_TYPE_PT_ADD01;
8217 kern_type = KERN_TYPE_KECCAK;
8218 dgst_size = DGST_SIZE_8_25;
8219 parse_func = keccak_parse_hash;
8220 sort_by_digest = sort_by_digest_8_25;
8221 opti_type = OPTI_TYPE_ZERO_BYTE
8222 | OPTI_TYPE_RAW_HASH;
8223 dgst_pos0 = 2;
8224 dgst_pos1 = 3;
8225 dgst_pos2 = 4;
8226 dgst_pos3 = 5;
8227 break;
8228
8229 case 5100: hash_type = HASH_TYPE_MD5H;
8230 salt_type = SALT_TYPE_NONE;
8231 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8232 opts_type = OPTS_TYPE_PT_GENERATE_LE
8233 | OPTS_TYPE_PT_ADD80
8234 | OPTS_TYPE_PT_ADDBITS14;
8235 kern_type = KERN_TYPE_MD5H;
8236 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8237 parse_func = md5half_parse_hash;
8238 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8239 opti_type = OPTI_TYPE_ZERO_BYTE
8240 | OPTI_TYPE_RAW_HASH;
8241 dgst_pos0 = 0;
8242 dgst_pos1 = 1;
8243 dgst_pos2 = 2;
8244 dgst_pos3 = 3;
8245 break;
8246
8247 case 5200: hash_type = HASH_TYPE_SHA256;
8248 salt_type = SALT_TYPE_EMBEDDED;
8249 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8250 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8251 kern_type = KERN_TYPE_PSAFE3;
8252 dgst_size = DGST_SIZE_4_8;
8253 parse_func = psafe3_parse_hash;
8254 sort_by_digest = sort_by_digest_4_8;
8255 opti_type = OPTI_TYPE_ZERO_BYTE;
8256 dgst_pos0 = 0;
8257 dgst_pos1 = 1;
8258 dgst_pos2 = 2;
8259 dgst_pos3 = 3;
8260 break;
8261
8262 case 5300: hash_type = HASH_TYPE_MD5;
8263 salt_type = SALT_TYPE_EMBEDDED;
8264 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8265 opts_type = OPTS_TYPE_PT_GENERATE_LE
8266 | OPTS_TYPE_ST_ADD80;
8267 kern_type = KERN_TYPE_IKEPSK_MD5;
8268 dgst_size = DGST_SIZE_4_4;
8269 parse_func = ikepsk_md5_parse_hash;
8270 sort_by_digest = sort_by_digest_4_4;
8271 opti_type = OPTI_TYPE_ZERO_BYTE;
8272 dgst_pos0 = 0;
8273 dgst_pos1 = 3;
8274 dgst_pos2 = 2;
8275 dgst_pos3 = 1;
8276 break;
8277
8278 case 5400: hash_type = HASH_TYPE_SHA1;
8279 salt_type = SALT_TYPE_EMBEDDED;
8280 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8281 opts_type = OPTS_TYPE_PT_GENERATE_BE
8282 | OPTS_TYPE_ST_ADD80;
8283 kern_type = KERN_TYPE_IKEPSK_SHA1;
8284 dgst_size = DGST_SIZE_4_5;
8285 parse_func = ikepsk_sha1_parse_hash;
8286 sort_by_digest = sort_by_digest_4_5;
8287 opti_type = OPTI_TYPE_ZERO_BYTE;
8288 dgst_pos0 = 3;
8289 dgst_pos1 = 4;
8290 dgst_pos2 = 2;
8291 dgst_pos3 = 1;
8292 break;
8293
8294 case 5500: hash_type = HASH_TYPE_NETNTLM;
8295 salt_type = SALT_TYPE_EMBEDDED;
8296 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8297 opts_type = OPTS_TYPE_PT_GENERATE_LE
8298 | OPTS_TYPE_PT_ADD80
8299 | OPTS_TYPE_PT_ADDBITS14
8300 | OPTS_TYPE_PT_UNICODE
8301 | OPTS_TYPE_ST_HEX;
8302 kern_type = KERN_TYPE_NETNTLMv1;
8303 dgst_size = DGST_SIZE_4_4;
8304 parse_func = netntlmv1_parse_hash;
8305 sort_by_digest = sort_by_digest_4_4;
8306 opti_type = OPTI_TYPE_ZERO_BYTE
8307 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8308 dgst_pos0 = 0;
8309 dgst_pos1 = 1;
8310 dgst_pos2 = 2;
8311 dgst_pos3 = 3;
8312 break;
8313
8314 case 5600: hash_type = HASH_TYPE_MD5;
8315 salt_type = SALT_TYPE_EMBEDDED;
8316 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8317 opts_type = OPTS_TYPE_PT_GENERATE_LE
8318 | OPTS_TYPE_PT_ADD80
8319 | OPTS_TYPE_PT_ADDBITS14
8320 | OPTS_TYPE_PT_UNICODE;
8321 kern_type = KERN_TYPE_NETNTLMv2;
8322 dgst_size = DGST_SIZE_4_4;
8323 parse_func = netntlmv2_parse_hash;
8324 sort_by_digest = sort_by_digest_4_4;
8325 opti_type = OPTI_TYPE_ZERO_BYTE;
8326 dgst_pos0 = 0;
8327 dgst_pos1 = 3;
8328 dgst_pos2 = 2;
8329 dgst_pos3 = 1;
8330 break;
8331
8332 case 5700: hash_type = HASH_TYPE_SHA256;
8333 salt_type = SALT_TYPE_NONE;
8334 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8335 opts_type = OPTS_TYPE_PT_GENERATE_BE
8336 | OPTS_TYPE_PT_ADD80
8337 | OPTS_TYPE_PT_ADDBITS15;
8338 kern_type = KERN_TYPE_SHA256;
8339 dgst_size = DGST_SIZE_4_8;
8340 parse_func = cisco4_parse_hash;
8341 sort_by_digest = sort_by_digest_4_8;
8342 opti_type = OPTI_TYPE_ZERO_BYTE
8343 | OPTI_TYPE_PRECOMPUTE_INIT
8344 | OPTI_TYPE_PRECOMPUTE_MERKLE
8345 | OPTI_TYPE_EARLY_SKIP
8346 | OPTI_TYPE_NOT_ITERATED
8347 | OPTI_TYPE_NOT_SALTED
8348 | OPTI_TYPE_RAW_HASH;
8349 dgst_pos0 = 3;
8350 dgst_pos1 = 7;
8351 dgst_pos2 = 2;
8352 dgst_pos3 = 6;
8353 break;
8354
8355 case 5800: hash_type = HASH_TYPE_SHA1;
8356 salt_type = SALT_TYPE_INTERN;
8357 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8358 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8359 | OPTS_TYPE_ST_ADD80;
8360 kern_type = KERN_TYPE_ANDROIDPIN;
8361 dgst_size = DGST_SIZE_4_5;
8362 parse_func = androidpin_parse_hash;
8363 sort_by_digest = sort_by_digest_4_5;
8364 opti_type = OPTI_TYPE_ZERO_BYTE;
8365 dgst_pos0 = 0;
8366 dgst_pos1 = 1;
8367 dgst_pos2 = 2;
8368 dgst_pos3 = 3;
8369 break;
8370
8371 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8372 salt_type = SALT_TYPE_NONE;
8373 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8374 opts_type = OPTS_TYPE_PT_GENERATE_LE
8375 | OPTS_TYPE_PT_ADD80;
8376 kern_type = KERN_TYPE_RIPEMD160;
8377 dgst_size = DGST_SIZE_4_5;
8378 parse_func = ripemd160_parse_hash;
8379 sort_by_digest = sort_by_digest_4_5;
8380 opti_type = OPTI_TYPE_ZERO_BYTE;
8381 dgst_pos0 = 0;
8382 dgst_pos1 = 1;
8383 dgst_pos2 = 2;
8384 dgst_pos3 = 3;
8385 break;
8386
8387 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8388 salt_type = SALT_TYPE_NONE;
8389 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8390 opts_type = OPTS_TYPE_PT_GENERATE_BE
8391 | OPTS_TYPE_PT_ADD80;
8392 kern_type = KERN_TYPE_WHIRLPOOL;
8393 dgst_size = DGST_SIZE_4_16;
8394 parse_func = whirlpool_parse_hash;
8395 sort_by_digest = sort_by_digest_4_16;
8396 opti_type = OPTI_TYPE_ZERO_BYTE;
8397 dgst_pos0 = 0;
8398 dgst_pos1 = 1;
8399 dgst_pos2 = 2;
8400 dgst_pos3 = 3;
8401 break;
8402
8403 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8404 salt_type = SALT_TYPE_EMBEDDED;
8405 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8406 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8407 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8408 dgst_size = DGST_SIZE_4_5;
8409 parse_func = truecrypt_parse_hash_2k;
8410 sort_by_digest = sort_by_digest_4_5;
8411 opti_type = OPTI_TYPE_ZERO_BYTE;
8412 dgst_pos0 = 0;
8413 dgst_pos1 = 1;
8414 dgst_pos2 = 2;
8415 dgst_pos3 = 3;
8416 break;
8417
8418 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8419 salt_type = SALT_TYPE_EMBEDDED;
8420 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8421 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8422 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8423 dgst_size = DGST_SIZE_4_5;
8424 parse_func = truecrypt_parse_hash_2k;
8425 sort_by_digest = sort_by_digest_4_5;
8426 opti_type = OPTI_TYPE_ZERO_BYTE;
8427 dgst_pos0 = 0;
8428 dgst_pos1 = 1;
8429 dgst_pos2 = 2;
8430 dgst_pos3 = 3;
8431 break;
8432
8433 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8434 salt_type = SALT_TYPE_EMBEDDED;
8435 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8436 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8437 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8438 dgst_size = DGST_SIZE_4_5;
8439 parse_func = truecrypt_parse_hash_2k;
8440 sort_by_digest = sort_by_digest_4_5;
8441 opti_type = OPTI_TYPE_ZERO_BYTE;
8442 dgst_pos0 = 0;
8443 dgst_pos1 = 1;
8444 dgst_pos2 = 2;
8445 dgst_pos3 = 3;
8446 break;
8447
8448 case 6221: hash_type = HASH_TYPE_SHA512;
8449 salt_type = SALT_TYPE_EMBEDDED;
8450 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8451 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8452 kern_type = KERN_TYPE_TCSHA512_XTS512;
8453 dgst_size = DGST_SIZE_8_8;
8454 parse_func = truecrypt_parse_hash_1k;
8455 sort_by_digest = sort_by_digest_8_8;
8456 opti_type = OPTI_TYPE_ZERO_BYTE;
8457 dgst_pos0 = 0;
8458 dgst_pos1 = 1;
8459 dgst_pos2 = 2;
8460 dgst_pos3 = 3;
8461 break;
8462
8463 case 6222: hash_type = HASH_TYPE_SHA512;
8464 salt_type = SALT_TYPE_EMBEDDED;
8465 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8466 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8467 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8468 dgst_size = DGST_SIZE_8_8;
8469 parse_func = truecrypt_parse_hash_1k;
8470 sort_by_digest = sort_by_digest_8_8;
8471 opti_type = OPTI_TYPE_ZERO_BYTE;
8472 dgst_pos0 = 0;
8473 dgst_pos1 = 1;
8474 dgst_pos2 = 2;
8475 dgst_pos3 = 3;
8476 break;
8477
8478 case 6223: hash_type = HASH_TYPE_SHA512;
8479 salt_type = SALT_TYPE_EMBEDDED;
8480 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8481 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8482 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8483 dgst_size = DGST_SIZE_8_8;
8484 parse_func = truecrypt_parse_hash_1k;
8485 sort_by_digest = sort_by_digest_8_8;
8486 opti_type = OPTI_TYPE_ZERO_BYTE;
8487 dgst_pos0 = 0;
8488 dgst_pos1 = 1;
8489 dgst_pos2 = 2;
8490 dgst_pos3 = 3;
8491 break;
8492
8493 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8494 salt_type = SALT_TYPE_EMBEDDED;
8495 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8496 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8497 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8498 dgst_size = DGST_SIZE_4_8;
8499 parse_func = truecrypt_parse_hash_1k;
8500 sort_by_digest = sort_by_digest_4_8;
8501 opti_type = OPTI_TYPE_ZERO_BYTE;
8502 dgst_pos0 = 0;
8503 dgst_pos1 = 1;
8504 dgst_pos2 = 2;
8505 dgst_pos3 = 3;
8506 break;
8507
8508 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8509 salt_type = SALT_TYPE_EMBEDDED;
8510 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8511 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8512 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8513 dgst_size = DGST_SIZE_4_8;
8514 parse_func = truecrypt_parse_hash_1k;
8515 sort_by_digest = sort_by_digest_4_8;
8516 opti_type = OPTI_TYPE_ZERO_BYTE;
8517 dgst_pos0 = 0;
8518 dgst_pos1 = 1;
8519 dgst_pos2 = 2;
8520 dgst_pos3 = 3;
8521 break;
8522
8523 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8524 salt_type = SALT_TYPE_EMBEDDED;
8525 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8526 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8527 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8528 dgst_size = DGST_SIZE_4_8;
8529 parse_func = truecrypt_parse_hash_1k;
8530 sort_by_digest = sort_by_digest_4_8;
8531 opti_type = OPTI_TYPE_ZERO_BYTE;
8532 dgst_pos0 = 0;
8533 dgst_pos1 = 1;
8534 dgst_pos2 = 2;
8535 dgst_pos3 = 3;
8536 break;
8537
8538 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8539 salt_type = SALT_TYPE_EMBEDDED;
8540 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8541 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8542 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8543 dgst_size = DGST_SIZE_4_5;
8544 parse_func = truecrypt_parse_hash_1k;
8545 sort_by_digest = sort_by_digest_4_5;
8546 opti_type = OPTI_TYPE_ZERO_BYTE;
8547 dgst_pos0 = 0;
8548 dgst_pos1 = 1;
8549 dgst_pos2 = 2;
8550 dgst_pos3 = 3;
8551 break;
8552
8553 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8554 salt_type = SALT_TYPE_EMBEDDED;
8555 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8556 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8557 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8558 dgst_size = DGST_SIZE_4_5;
8559 parse_func = truecrypt_parse_hash_1k;
8560 sort_by_digest = sort_by_digest_4_5;
8561 opti_type = OPTI_TYPE_ZERO_BYTE;
8562 dgst_pos0 = 0;
8563 dgst_pos1 = 1;
8564 dgst_pos2 = 2;
8565 dgst_pos3 = 3;
8566 break;
8567
8568 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8569 salt_type = SALT_TYPE_EMBEDDED;
8570 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8571 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8572 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8573 dgst_size = DGST_SIZE_4_5;
8574 parse_func = truecrypt_parse_hash_1k;
8575 sort_by_digest = sort_by_digest_4_5;
8576 opti_type = OPTI_TYPE_ZERO_BYTE;
8577 dgst_pos0 = 0;
8578 dgst_pos1 = 1;
8579 dgst_pos2 = 2;
8580 dgst_pos3 = 3;
8581 break;
8582
8583 case 6300: hash_type = HASH_TYPE_MD5;
8584 salt_type = SALT_TYPE_EMBEDDED;
8585 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8586 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8587 kern_type = KERN_TYPE_MD5AIX;
8588 dgst_size = DGST_SIZE_4_4;
8589 parse_func = md5aix_parse_hash;
8590 sort_by_digest = sort_by_digest_4_4;
8591 opti_type = OPTI_TYPE_ZERO_BYTE;
8592 dgst_pos0 = 0;
8593 dgst_pos1 = 1;
8594 dgst_pos2 = 2;
8595 dgst_pos3 = 3;
8596 break;
8597
8598 case 6400: hash_type = HASH_TYPE_SHA256;
8599 salt_type = SALT_TYPE_EMBEDDED;
8600 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8601 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8602 kern_type = KERN_TYPE_SHA256AIX;
8603 dgst_size = DGST_SIZE_4_8;
8604 parse_func = sha256aix_parse_hash;
8605 sort_by_digest = sort_by_digest_4_8;
8606 opti_type = OPTI_TYPE_ZERO_BYTE;
8607 dgst_pos0 = 0;
8608 dgst_pos1 = 1;
8609 dgst_pos2 = 2;
8610 dgst_pos3 = 3;
8611 break;
8612
8613 case 6500: hash_type = HASH_TYPE_SHA512;
8614 salt_type = SALT_TYPE_EMBEDDED;
8615 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8616 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8617 kern_type = KERN_TYPE_SHA512AIX;
8618 dgst_size = DGST_SIZE_8_8;
8619 parse_func = sha512aix_parse_hash;
8620 sort_by_digest = sort_by_digest_8_8;
8621 opti_type = OPTI_TYPE_ZERO_BYTE;
8622 dgst_pos0 = 0;
8623 dgst_pos1 = 1;
8624 dgst_pos2 = 2;
8625 dgst_pos3 = 3;
8626 break;
8627
8628 case 6600: hash_type = HASH_TYPE_AES;
8629 salt_type = SALT_TYPE_EMBEDDED;
8630 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8631 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8632 kern_type = KERN_TYPE_AGILEKEY;
8633 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8634 parse_func = agilekey_parse_hash;
8635 sort_by_digest = sort_by_digest_4_5;
8636 opti_type = OPTI_TYPE_ZERO_BYTE;
8637 dgst_pos0 = 0;
8638 dgst_pos1 = 1;
8639 dgst_pos2 = 2;
8640 dgst_pos3 = 3;
8641 break;
8642
8643 case 6700: hash_type = HASH_TYPE_SHA1;
8644 salt_type = SALT_TYPE_EMBEDDED;
8645 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8646 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8647 kern_type = KERN_TYPE_SHA1AIX;
8648 dgst_size = DGST_SIZE_4_5;
8649 parse_func = sha1aix_parse_hash;
8650 sort_by_digest = sort_by_digest_4_5;
8651 opti_type = OPTI_TYPE_ZERO_BYTE;
8652 dgst_pos0 = 0;
8653 dgst_pos1 = 1;
8654 dgst_pos2 = 2;
8655 dgst_pos3 = 3;
8656 break;
8657
8658 case 6800: hash_type = HASH_TYPE_AES;
8659 salt_type = SALT_TYPE_EMBEDDED;
8660 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8661 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8662 kern_type = KERN_TYPE_LASTPASS;
8663 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
8664 parse_func = lastpass_parse_hash;
8665 sort_by_digest = sort_by_digest_4_8;
8666 opti_type = OPTI_TYPE_ZERO_BYTE;
8667 dgst_pos0 = 0;
8668 dgst_pos1 = 1;
8669 dgst_pos2 = 2;
8670 dgst_pos3 = 3;
8671 break;
8672
8673 case 6900: hash_type = HASH_TYPE_GOST;
8674 salt_type = SALT_TYPE_NONE;
8675 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8676 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8677 kern_type = KERN_TYPE_GOST;
8678 dgst_size = DGST_SIZE_4_8;
8679 parse_func = gost_parse_hash;
8680 sort_by_digest = sort_by_digest_4_8;
8681 opti_type = OPTI_TYPE_ZERO_BYTE;
8682 dgst_pos0 = 0;
8683 dgst_pos1 = 1;
8684 dgst_pos2 = 2;
8685 dgst_pos3 = 3;
8686 break;
8687
8688 case 7100: hash_type = HASH_TYPE_SHA512;
8689 salt_type = SALT_TYPE_EMBEDDED;
8690 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8691 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8692 kern_type = KERN_TYPE_PBKDF2_SHA512;
8693 dgst_size = DGST_SIZE_8_16;
8694 parse_func = sha512osx_parse_hash;
8695 sort_by_digest = sort_by_digest_8_16;
8696 opti_type = OPTI_TYPE_ZERO_BYTE;
8697 dgst_pos0 = 0;
8698 dgst_pos1 = 1;
8699 dgst_pos2 = 2;
8700 dgst_pos3 = 3;
8701 break;
8702
8703 case 7200: hash_type = HASH_TYPE_SHA512;
8704 salt_type = SALT_TYPE_EMBEDDED;
8705 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8706 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8707 kern_type = KERN_TYPE_PBKDF2_SHA512;
8708 dgst_size = DGST_SIZE_8_16;
8709 parse_func = sha512grub_parse_hash;
8710 sort_by_digest = sort_by_digest_8_16;
8711 opti_type = OPTI_TYPE_ZERO_BYTE;
8712 dgst_pos0 = 0;
8713 dgst_pos1 = 1;
8714 dgst_pos2 = 2;
8715 dgst_pos3 = 3;
8716 break;
8717
8718 case 7300: hash_type = HASH_TYPE_SHA1;
8719 salt_type = SALT_TYPE_EMBEDDED;
8720 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8721 opts_type = OPTS_TYPE_PT_GENERATE_BE
8722 | OPTS_TYPE_ST_ADD80
8723 | OPTS_TYPE_ST_ADDBITS15;
8724 kern_type = KERN_TYPE_RAKP;
8725 dgst_size = DGST_SIZE_4_5;
8726 parse_func = rakp_parse_hash;
8727 sort_by_digest = sort_by_digest_4_5;
8728 opti_type = OPTI_TYPE_ZERO_BYTE
8729 | OPTI_TYPE_NOT_ITERATED;
8730 dgst_pos0 = 3;
8731 dgst_pos1 = 4;
8732 dgst_pos2 = 2;
8733 dgst_pos3 = 1;
8734 break;
8735
8736 case 7400: hash_type = HASH_TYPE_SHA256;
8737 salt_type = SALT_TYPE_EMBEDDED;
8738 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8739 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8740 kern_type = KERN_TYPE_SHA256CRYPT;
8741 dgst_size = DGST_SIZE_4_8;
8742 parse_func = sha256crypt_parse_hash;
8743 sort_by_digest = sort_by_digest_4_8;
8744 opti_type = OPTI_TYPE_ZERO_BYTE;
8745 dgst_pos0 = 0;
8746 dgst_pos1 = 1;
8747 dgst_pos2 = 2;
8748 dgst_pos3 = 3;
8749 break;
8750
8751 case 7500: hash_type = HASH_TYPE_KRB5PA;
8752 salt_type = SALT_TYPE_EMBEDDED;
8753 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8754 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8755 kern_type = KERN_TYPE_KRB5PA;
8756 dgst_size = DGST_SIZE_4_4;
8757 parse_func = krb5pa_parse_hash;
8758 sort_by_digest = sort_by_digest_4_4;
8759 opti_type = OPTI_TYPE_ZERO_BYTE
8760 | OPTI_TYPE_NOT_ITERATED;
8761 dgst_pos0 = 3;
8762 dgst_pos1 = 7;
8763 dgst_pos2 = 2;
8764 dgst_pos3 = 6;
8765 break;
8766
8767 case 7600: hash_type = HASH_TYPE_SHA1;
8768 salt_type = SALT_TYPE_INTERN;
8769 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8770 opts_type = OPTS_TYPE_PT_GENERATE_BE
8771 | OPTS_TYPE_PT_ADD80
8772 | OPTS_TYPE_PT_ADDBITS15;
8773 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
8774 dgst_size = DGST_SIZE_4_5;
8775 parse_func = redmine_parse_hash;
8776 sort_by_digest = sort_by_digest_4_5;
8777 opti_type = OPTI_TYPE_ZERO_BYTE
8778 | OPTI_TYPE_PRECOMPUTE_INIT
8779 | OPTI_TYPE_EARLY_SKIP
8780 | OPTI_TYPE_NOT_ITERATED
8781 | OPTI_TYPE_PREPENDED_SALT;
8782 dgst_pos0 = 3;
8783 dgst_pos1 = 4;
8784 dgst_pos2 = 2;
8785 dgst_pos3 = 1;
8786 break;
8787
8788 case 7700: hash_type = HASH_TYPE_SAPB;
8789 salt_type = SALT_TYPE_EMBEDDED;
8790 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8791 opts_type = OPTS_TYPE_PT_GENERATE_LE
8792 | OPTS_TYPE_PT_UPPER
8793 | OPTS_TYPE_ST_UPPER;
8794 kern_type = KERN_TYPE_SAPB;
8795 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8796 parse_func = sapb_parse_hash;
8797 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8798 opti_type = OPTI_TYPE_ZERO_BYTE
8799 | OPTI_TYPE_PRECOMPUTE_INIT
8800 | OPTI_TYPE_NOT_ITERATED;
8801 dgst_pos0 = 0;
8802 dgst_pos1 = 1;
8803 dgst_pos2 = 2;
8804 dgst_pos3 = 3;
8805 break;
8806
8807 case 7800: hash_type = HASH_TYPE_SAPG;
8808 salt_type = SALT_TYPE_EMBEDDED;
8809 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8810 opts_type = OPTS_TYPE_PT_GENERATE_BE
8811 | OPTS_TYPE_ST_ADD80
8812 | OPTS_TYPE_ST_UPPER;
8813 kern_type = KERN_TYPE_SAPG;
8814 dgst_size = DGST_SIZE_4_5;
8815 parse_func = sapg_parse_hash;
8816 sort_by_digest = sort_by_digest_4_5;
8817 opti_type = OPTI_TYPE_ZERO_BYTE
8818 | OPTI_TYPE_PRECOMPUTE_INIT
8819 | OPTI_TYPE_NOT_ITERATED;
8820 dgst_pos0 = 3;
8821 dgst_pos1 = 4;
8822 dgst_pos2 = 2;
8823 dgst_pos3 = 1;
8824 break;
8825
8826 case 7900: hash_type = HASH_TYPE_SHA512;
8827 salt_type = SALT_TYPE_EMBEDDED;
8828 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8829 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8830 kern_type = KERN_TYPE_DRUPAL7;
8831 dgst_size = DGST_SIZE_8_8;
8832 parse_func = drupal7_parse_hash;
8833 sort_by_digest = sort_by_digest_8_8;
8834 opti_type = OPTI_TYPE_ZERO_BYTE;
8835 dgst_pos0 = 0;
8836 dgst_pos1 = 1;
8837 dgst_pos2 = 2;
8838 dgst_pos3 = 3;
8839 break;
8840
8841 case 8000: hash_type = HASH_TYPE_SHA256;
8842 salt_type = SALT_TYPE_EMBEDDED;
8843 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8844 opts_type = OPTS_TYPE_PT_GENERATE_BE
8845 | OPTS_TYPE_PT_UNICODE
8846 | OPTS_TYPE_ST_ADD80
8847 | OPTS_TYPE_ST_HEX;
8848 kern_type = KERN_TYPE_SYBASEASE;
8849 dgst_size = DGST_SIZE_4_8;
8850 parse_func = sybasease_parse_hash;
8851 sort_by_digest = sort_by_digest_4_8;
8852 opti_type = OPTI_TYPE_ZERO_BYTE
8853 | OPTI_TYPE_PRECOMPUTE_INIT
8854 | OPTI_TYPE_EARLY_SKIP
8855 | OPTI_TYPE_NOT_ITERATED
8856 | OPTI_TYPE_RAW_HASH;
8857 dgst_pos0 = 3;
8858 dgst_pos1 = 7;
8859 dgst_pos2 = 2;
8860 dgst_pos3 = 6;
8861 break;
8862
8863 case 8100: hash_type = HASH_TYPE_SHA1;
8864 salt_type = SALT_TYPE_EMBEDDED;
8865 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8866 opts_type = OPTS_TYPE_PT_GENERATE_BE;
8867 kern_type = KERN_TYPE_NETSCALER;
8868 dgst_size = DGST_SIZE_4_5;
8869 parse_func = netscaler_parse_hash;
8870 sort_by_digest = sort_by_digest_4_5;
8871 opti_type = OPTI_TYPE_ZERO_BYTE
8872 | OPTI_TYPE_PRECOMPUTE_INIT
8873 | OPTI_TYPE_PRECOMPUTE_MERKLE
8874 | OPTI_TYPE_EARLY_SKIP
8875 | OPTI_TYPE_NOT_ITERATED
8876 | OPTI_TYPE_PREPENDED_SALT
8877 | OPTI_TYPE_RAW_HASH;
8878 dgst_pos0 = 3;
8879 dgst_pos1 = 4;
8880 dgst_pos2 = 2;
8881 dgst_pos3 = 1;
8882 break;
8883
8884 case 8200: hash_type = HASH_TYPE_SHA256;
8885 salt_type = SALT_TYPE_EMBEDDED;
8886 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8887 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8888 kern_type = KERN_TYPE_CLOUDKEY;
8889 dgst_size = DGST_SIZE_4_8;
8890 parse_func = cloudkey_parse_hash;
8891 sort_by_digest = sort_by_digest_4_8;
8892 opti_type = OPTI_TYPE_ZERO_BYTE;
8893 dgst_pos0 = 0;
8894 dgst_pos1 = 1;
8895 dgst_pos2 = 2;
8896 dgst_pos3 = 3;
8897 break;
8898
8899 case 8300: hash_type = HASH_TYPE_SHA1;
8900 salt_type = SALT_TYPE_EMBEDDED;
8901 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8902 opts_type = OPTS_TYPE_PT_GENERATE_LE
8903 | OPTS_TYPE_ST_HEX
8904 | OPTS_TYPE_ST_ADD80;
8905 kern_type = KERN_TYPE_NSEC3;
8906 dgst_size = DGST_SIZE_4_5;
8907 parse_func = nsec3_parse_hash;
8908 sort_by_digest = sort_by_digest_4_5;
8909 opti_type = OPTI_TYPE_ZERO_BYTE;
8910 dgst_pos0 = 3;
8911 dgst_pos1 = 4;
8912 dgst_pos2 = 2;
8913 dgst_pos3 = 1;
8914 break;
8915
8916 case 8400: hash_type = HASH_TYPE_SHA1;
8917 salt_type = SALT_TYPE_INTERN;
8918 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8919 opts_type = OPTS_TYPE_PT_GENERATE_BE
8920 | OPTS_TYPE_PT_ADD80
8921 | OPTS_TYPE_PT_ADDBITS15;
8922 kern_type = KERN_TYPE_WBB3;
8923 dgst_size = DGST_SIZE_4_5;
8924 parse_func = wbb3_parse_hash;
8925 sort_by_digest = sort_by_digest_4_5;
8926 opti_type = OPTI_TYPE_ZERO_BYTE
8927 | OPTI_TYPE_PRECOMPUTE_INIT
8928 | OPTI_TYPE_NOT_ITERATED;
8929 dgst_pos0 = 3;
8930 dgst_pos1 = 4;
8931 dgst_pos2 = 2;
8932 dgst_pos3 = 1;
8933 break;
8934
8935 case 8500: hash_type = HASH_TYPE_DESRACF;
8936 salt_type = SALT_TYPE_EMBEDDED;
8937 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8938 opts_type = OPTS_TYPE_PT_GENERATE_LE
8939 | OPTS_TYPE_ST_UPPER;
8940 kern_type = KERN_TYPE_RACF;
8941 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8942 parse_func = racf_parse_hash;
8943 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8944 opti_type = OPTI_TYPE_ZERO_BYTE
8945 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8946 dgst_pos0 = 0;
8947 dgst_pos1 = 1;
8948 dgst_pos2 = 2;
8949 dgst_pos3 = 3;
8950 break;
8951
8952 case 8600: hash_type = HASH_TYPE_LOTUS5;
8953 salt_type = SALT_TYPE_NONE;
8954 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8955 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8956 kern_type = KERN_TYPE_LOTUS5;
8957 dgst_size = DGST_SIZE_4_4;
8958 parse_func = lotus5_parse_hash;
8959 sort_by_digest = sort_by_digest_4_4;
8960 opti_type = OPTI_TYPE_EARLY_SKIP
8961 | OPTI_TYPE_NOT_ITERATED
8962 | OPTI_TYPE_NOT_SALTED
8963 | OPTI_TYPE_RAW_HASH;
8964 dgst_pos0 = 0;
8965 dgst_pos1 = 1;
8966 dgst_pos2 = 2;
8967 dgst_pos3 = 3;
8968 break;
8969
8970 case 8700: hash_type = HASH_TYPE_LOTUS6;
8971 salt_type = SALT_TYPE_EMBEDDED;
8972 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8973 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8974 kern_type = KERN_TYPE_LOTUS6;
8975 dgst_size = DGST_SIZE_4_4;
8976 parse_func = lotus6_parse_hash;
8977 sort_by_digest = sort_by_digest_4_4;
8978 opti_type = OPTI_TYPE_EARLY_SKIP
8979 | OPTI_TYPE_NOT_ITERATED
8980 | OPTI_TYPE_RAW_HASH;
8981 dgst_pos0 = 0;
8982 dgst_pos1 = 1;
8983 dgst_pos2 = 2;
8984 dgst_pos3 = 3;
8985 break;
8986
8987 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
8988 salt_type = SALT_TYPE_EMBEDDED;
8989 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8990 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8991 kern_type = KERN_TYPE_ANDROIDFDE;
8992 dgst_size = DGST_SIZE_4_4;
8993 parse_func = androidfde_parse_hash;
8994 sort_by_digest = sort_by_digest_4_4;
8995 opti_type = OPTI_TYPE_ZERO_BYTE;
8996 dgst_pos0 = 0;
8997 dgst_pos1 = 1;
8998 dgst_pos2 = 2;
8999 dgst_pos3 = 3;
9000 break;
9001
9002 case 8900: hash_type = HASH_TYPE_SCRYPT;
9003 salt_type = SALT_TYPE_EMBEDDED;
9004 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9005 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9006 kern_type = KERN_TYPE_SCRYPT;
9007 dgst_size = DGST_SIZE_4_8;
9008 parse_func = scrypt_parse_hash;
9009 sort_by_digest = sort_by_digest_4_8;
9010 opti_type = OPTI_TYPE_ZERO_BYTE;
9011 dgst_pos0 = 0;
9012 dgst_pos1 = 1;
9013 dgst_pos2 = 2;
9014 dgst_pos3 = 3;
9015 break;
9016
9017 case 9000: hash_type = HASH_TYPE_SHA1;
9018 salt_type = SALT_TYPE_EMBEDDED;
9019 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9020 opts_type = OPTS_TYPE_PT_GENERATE_LE
9021 | OPTS_TYPE_ST_GENERATE_LE;
9022 kern_type = KERN_TYPE_PSAFE2;
9023 dgst_size = DGST_SIZE_4_5;
9024 parse_func = psafe2_parse_hash;
9025 sort_by_digest = sort_by_digest_4_5;
9026 opti_type = OPTI_TYPE_ZERO_BYTE;
9027 dgst_pos0 = 0;
9028 dgst_pos1 = 1;
9029 dgst_pos2 = 2;
9030 dgst_pos3 = 3;
9031 break;
9032
9033 case 9100: hash_type = HASH_TYPE_LOTUS8;
9034 salt_type = SALT_TYPE_EMBEDDED;
9035 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9036 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9037 kern_type = KERN_TYPE_LOTUS8;
9038 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9039 parse_func = lotus8_parse_hash;
9040 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9041 opti_type = OPTI_TYPE_ZERO_BYTE;
9042 dgst_pos0 = 0;
9043 dgst_pos1 = 1;
9044 dgst_pos2 = 2;
9045 dgst_pos3 = 3;
9046 break;
9047
9048 case 9200: hash_type = HASH_TYPE_SHA256;
9049 salt_type = SALT_TYPE_EMBEDDED;
9050 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9051 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9052 kern_type = KERN_TYPE_PBKDF2_SHA256;
9053 dgst_size = DGST_SIZE_4_32;
9054 parse_func = cisco8_parse_hash;
9055 sort_by_digest = sort_by_digest_4_32;
9056 opti_type = OPTI_TYPE_ZERO_BYTE;
9057 dgst_pos0 = 0;
9058 dgst_pos1 = 1;
9059 dgst_pos2 = 2;
9060 dgst_pos3 = 3;
9061 break;
9062
9063 case 9300: hash_type = HASH_TYPE_SCRYPT;
9064 salt_type = SALT_TYPE_EMBEDDED;
9065 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9066 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9067 kern_type = KERN_TYPE_SCRYPT;
9068 dgst_size = DGST_SIZE_4_8;
9069 parse_func = cisco9_parse_hash;
9070 sort_by_digest = sort_by_digest_4_8;
9071 opti_type = OPTI_TYPE_ZERO_BYTE;
9072 dgst_pos0 = 0;
9073 dgst_pos1 = 1;
9074 dgst_pos2 = 2;
9075 dgst_pos3 = 3;
9076 break;
9077
9078 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9079 salt_type = SALT_TYPE_EMBEDDED;
9080 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9081 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9082 kern_type = KERN_TYPE_OFFICE2007;
9083 dgst_size = DGST_SIZE_4_4;
9084 parse_func = office2007_parse_hash;
9085 sort_by_digest = sort_by_digest_4_4;
9086 opti_type = OPTI_TYPE_ZERO_BYTE;
9087 dgst_pos0 = 0;
9088 dgst_pos1 = 1;
9089 dgst_pos2 = 2;
9090 dgst_pos3 = 3;
9091 break;
9092
9093 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9094 salt_type = SALT_TYPE_EMBEDDED;
9095 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9096 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9097 kern_type = KERN_TYPE_OFFICE2010;
9098 dgst_size = DGST_SIZE_4_4;
9099 parse_func = office2010_parse_hash;
9100 sort_by_digest = sort_by_digest_4_4;
9101 opti_type = OPTI_TYPE_ZERO_BYTE;
9102 dgst_pos0 = 0;
9103 dgst_pos1 = 1;
9104 dgst_pos2 = 2;
9105 dgst_pos3 = 3;
9106 break;
9107
9108 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9109 salt_type = SALT_TYPE_EMBEDDED;
9110 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9111 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9112 kern_type = KERN_TYPE_OFFICE2013;
9113 dgst_size = DGST_SIZE_4_4;
9114 parse_func = office2013_parse_hash;
9115 sort_by_digest = sort_by_digest_4_4;
9116 opti_type = OPTI_TYPE_ZERO_BYTE;
9117 dgst_pos0 = 0;
9118 dgst_pos1 = 1;
9119 dgst_pos2 = 2;
9120 dgst_pos3 = 3;
9121 break;
9122
9123 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9124 salt_type = SALT_TYPE_EMBEDDED;
9125 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9126 opts_type = OPTS_TYPE_PT_GENERATE_LE
9127 | OPTS_TYPE_PT_ADD80
9128 | OPTS_TYPE_PT_UNICODE;
9129 kern_type = KERN_TYPE_OLDOFFICE01;
9130 dgst_size = DGST_SIZE_4_4;
9131 parse_func = oldoffice01_parse_hash;
9132 sort_by_digest = sort_by_digest_4_4;
9133 opti_type = OPTI_TYPE_ZERO_BYTE
9134 | OPTI_TYPE_PRECOMPUTE_INIT
9135 | OPTI_TYPE_NOT_ITERATED;
9136 dgst_pos0 = 0;
9137 dgst_pos1 = 1;
9138 dgst_pos2 = 2;
9139 dgst_pos3 = 3;
9140 break;
9141
9142 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9143 salt_type = SALT_TYPE_EMBEDDED;
9144 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9145 opts_type = OPTS_TYPE_PT_GENERATE_LE
9146 | OPTS_TYPE_PT_ADD80;
9147 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9148 dgst_size = DGST_SIZE_4_4;
9149 parse_func = oldoffice01cm1_parse_hash;
9150 sort_by_digest = sort_by_digest_4_4;
9151 opti_type = OPTI_TYPE_ZERO_BYTE
9152 | OPTI_TYPE_PRECOMPUTE_INIT
9153 | OPTI_TYPE_NOT_ITERATED;
9154 dgst_pos0 = 0;
9155 dgst_pos1 = 1;
9156 dgst_pos2 = 2;
9157 dgst_pos3 = 3;
9158 break;
9159
9160 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9161 salt_type = SALT_TYPE_EMBEDDED;
9162 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9163 opts_type = OPTS_TYPE_PT_GENERATE_LE
9164 | OPTS_TYPE_PT_ADD80
9165 | OPTS_TYPE_PT_UNICODE
9166 | OPTS_TYPE_PT_NEVERCRACK;
9167 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9168 dgst_size = DGST_SIZE_4_4;
9169 parse_func = oldoffice01cm2_parse_hash;
9170 sort_by_digest = sort_by_digest_4_4;
9171 opti_type = OPTI_TYPE_ZERO_BYTE
9172 | OPTI_TYPE_PRECOMPUTE_INIT
9173 | OPTI_TYPE_NOT_ITERATED;
9174 dgst_pos0 = 0;
9175 dgst_pos1 = 1;
9176 dgst_pos2 = 2;
9177 dgst_pos3 = 3;
9178 break;
9179
9180 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9181 salt_type = SALT_TYPE_EMBEDDED;
9182 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9183 opts_type = OPTS_TYPE_PT_GENERATE_BE
9184 | OPTS_TYPE_PT_ADD80
9185 | OPTS_TYPE_PT_UNICODE;
9186 kern_type = KERN_TYPE_OLDOFFICE34;
9187 dgst_size = DGST_SIZE_4_4;
9188 parse_func = oldoffice34_parse_hash;
9189 sort_by_digest = sort_by_digest_4_4;
9190 opti_type = OPTI_TYPE_ZERO_BYTE
9191 | OPTI_TYPE_PRECOMPUTE_INIT
9192 | OPTI_TYPE_NOT_ITERATED;
9193 dgst_pos0 = 0;
9194 dgst_pos1 = 1;
9195 dgst_pos2 = 2;
9196 dgst_pos3 = 3;
9197 break;
9198
9199 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9200 salt_type = SALT_TYPE_EMBEDDED;
9201 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9202 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9203 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9204 dgst_size = DGST_SIZE_4_4;
9205 parse_func = oldoffice34cm1_parse_hash;
9206 sort_by_digest = sort_by_digest_4_4;
9207 opti_type = OPTI_TYPE_ZERO_BYTE
9208 | OPTI_TYPE_PRECOMPUTE_INIT
9209 | OPTI_TYPE_NOT_ITERATED;
9210 dgst_pos0 = 0;
9211 dgst_pos1 = 1;
9212 dgst_pos2 = 2;
9213 dgst_pos3 = 3;
9214 break;
9215
9216 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9217 salt_type = SALT_TYPE_EMBEDDED;
9218 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9219 opts_type = OPTS_TYPE_PT_GENERATE_BE
9220 | OPTS_TYPE_PT_ADD80
9221 | OPTS_TYPE_PT_UNICODE
9222 | OPTS_TYPE_PT_NEVERCRACK;
9223 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9224 dgst_size = DGST_SIZE_4_4;
9225 parse_func = oldoffice34cm2_parse_hash;
9226 sort_by_digest = sort_by_digest_4_4;
9227 opti_type = OPTI_TYPE_ZERO_BYTE
9228 | OPTI_TYPE_PRECOMPUTE_INIT
9229 | OPTI_TYPE_NOT_ITERATED;
9230 dgst_pos0 = 0;
9231 dgst_pos1 = 1;
9232 dgst_pos2 = 2;
9233 dgst_pos3 = 3;
9234 break;
9235
9236 case 9900: hash_type = HASH_TYPE_MD5;
9237 salt_type = SALT_TYPE_NONE;
9238 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9239 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9240 kern_type = KERN_TYPE_RADMIN2;
9241 dgst_size = DGST_SIZE_4_4;
9242 parse_func = radmin2_parse_hash;
9243 sort_by_digest = sort_by_digest_4_4;
9244 opti_type = OPTI_TYPE_ZERO_BYTE
9245 | OPTI_TYPE_PRECOMPUTE_INIT
9246 | OPTI_TYPE_EARLY_SKIP
9247 | OPTI_TYPE_NOT_ITERATED
9248 | OPTI_TYPE_NOT_SALTED;
9249 dgst_pos0 = 0;
9250 dgst_pos1 = 3;
9251 dgst_pos2 = 2;
9252 dgst_pos3 = 1;
9253 break;
9254
9255 case 10000: hash_type = HASH_TYPE_SHA256;
9256 salt_type = SALT_TYPE_EMBEDDED;
9257 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9258 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9259 kern_type = KERN_TYPE_PBKDF2_SHA256;
9260 dgst_size = DGST_SIZE_4_32;
9261 parse_func = djangopbkdf2_parse_hash;
9262 sort_by_digest = sort_by_digest_4_32;
9263 opti_type = OPTI_TYPE_ZERO_BYTE;
9264 dgst_pos0 = 0;
9265 dgst_pos1 = 1;
9266 dgst_pos2 = 2;
9267 dgst_pos3 = 3;
9268 break;
9269
9270 case 10100: hash_type = HASH_TYPE_SIPHASH;
9271 salt_type = SALT_TYPE_EMBEDDED;
9272 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9273 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9274 kern_type = KERN_TYPE_SIPHASH;
9275 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9276 parse_func = siphash_parse_hash;
9277 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9278 opti_type = OPTI_TYPE_ZERO_BYTE
9279 | OPTI_TYPE_NOT_ITERATED
9280 | OPTI_TYPE_RAW_HASH;
9281 dgst_pos0 = 0;
9282 dgst_pos1 = 1;
9283 dgst_pos2 = 2;
9284 dgst_pos3 = 3;
9285 break;
9286
9287 case 10200: hash_type = HASH_TYPE_MD5;
9288 salt_type = SALT_TYPE_EMBEDDED;
9289 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9290 opts_type = OPTS_TYPE_PT_GENERATE_LE
9291 | OPTS_TYPE_ST_ADD80
9292 | OPTS_TYPE_ST_ADDBITS14;
9293 kern_type = KERN_TYPE_HMACMD5_PW;
9294 dgst_size = DGST_SIZE_4_4;
9295 parse_func = crammd5_parse_hash;
9296 sort_by_digest = sort_by_digest_4_4;
9297 opti_type = OPTI_TYPE_ZERO_BYTE
9298 | OPTI_TYPE_NOT_ITERATED;
9299 dgst_pos0 = 0;
9300 dgst_pos1 = 3;
9301 dgst_pos2 = 2;
9302 dgst_pos3 = 1;
9303 break;
9304
9305 case 10300: hash_type = HASH_TYPE_SHA1;
9306 salt_type = SALT_TYPE_EMBEDDED;
9307 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9308 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9309 kern_type = KERN_TYPE_SAPH_SHA1;
9310 dgst_size = DGST_SIZE_4_5;
9311 parse_func = saph_sha1_parse_hash;
9312 sort_by_digest = sort_by_digest_4_5;
9313 opti_type = OPTI_TYPE_ZERO_BYTE;
9314 dgst_pos0 = 0;
9315 dgst_pos1 = 1;
9316 dgst_pos2 = 2;
9317 dgst_pos3 = 3;
9318 break;
9319
9320 case 10400: hash_type = HASH_TYPE_PDFU16;
9321 salt_type = SALT_TYPE_EMBEDDED;
9322 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9323 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9324 kern_type = KERN_TYPE_PDF11;
9325 dgst_size = DGST_SIZE_4_4;
9326 parse_func = pdf11_parse_hash;
9327 sort_by_digest = sort_by_digest_4_4;
9328 opti_type = OPTI_TYPE_ZERO_BYTE
9329 | OPTI_TYPE_NOT_ITERATED;
9330 dgst_pos0 = 0;
9331 dgst_pos1 = 1;
9332 dgst_pos2 = 2;
9333 dgst_pos3 = 3;
9334 break;
9335
9336 case 10410: hash_type = HASH_TYPE_PDFU16;
9337 salt_type = SALT_TYPE_EMBEDDED;
9338 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9339 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9340 kern_type = KERN_TYPE_PDF11CM1;
9341 dgst_size = DGST_SIZE_4_4;
9342 parse_func = pdf11cm1_parse_hash;
9343 sort_by_digest = sort_by_digest_4_4;
9344 opti_type = OPTI_TYPE_ZERO_BYTE
9345 | OPTI_TYPE_NOT_ITERATED;
9346 dgst_pos0 = 0;
9347 dgst_pos1 = 1;
9348 dgst_pos2 = 2;
9349 dgst_pos3 = 3;
9350 break;
9351
9352 case 10420: hash_type = HASH_TYPE_PDFU16;
9353 salt_type = SALT_TYPE_EMBEDDED;
9354 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9355 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9356 kern_type = KERN_TYPE_PDF11CM2;
9357 dgst_size = DGST_SIZE_4_4;
9358 parse_func = pdf11cm2_parse_hash;
9359 sort_by_digest = sort_by_digest_4_4;
9360 opti_type = OPTI_TYPE_ZERO_BYTE
9361 | OPTI_TYPE_NOT_ITERATED;
9362 dgst_pos0 = 0;
9363 dgst_pos1 = 1;
9364 dgst_pos2 = 2;
9365 dgst_pos3 = 3;
9366 break;
9367
9368 case 10500: hash_type = HASH_TYPE_PDFU16;
9369 salt_type = SALT_TYPE_EMBEDDED;
9370 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9371 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9372 kern_type = KERN_TYPE_PDF14;
9373 dgst_size = DGST_SIZE_4_4;
9374 parse_func = pdf14_parse_hash;
9375 sort_by_digest = sort_by_digest_4_4;
9376 opti_type = OPTI_TYPE_ZERO_BYTE
9377 | OPTI_TYPE_NOT_ITERATED;
9378 dgst_pos0 = 0;
9379 dgst_pos1 = 1;
9380 dgst_pos2 = 2;
9381 dgst_pos3 = 3;
9382 break;
9383
9384 case 10600: hash_type = HASH_TYPE_SHA256;
9385 salt_type = SALT_TYPE_EMBEDDED;
9386 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9387 opts_type = OPTS_TYPE_PT_GENERATE_BE
9388 | OPTS_TYPE_ST_ADD80
9389 | OPTS_TYPE_ST_ADDBITS15
9390 | OPTS_TYPE_HASH_COPY;
9391 kern_type = KERN_TYPE_SHA256_PWSLT;
9392 dgst_size = DGST_SIZE_4_8;
9393 parse_func = pdf17l3_parse_hash;
9394 sort_by_digest = sort_by_digest_4_8;
9395 opti_type = OPTI_TYPE_ZERO_BYTE
9396 | OPTI_TYPE_PRECOMPUTE_INIT
9397 | OPTI_TYPE_PRECOMPUTE_MERKLE
9398 | OPTI_TYPE_EARLY_SKIP
9399 | OPTI_TYPE_NOT_ITERATED
9400 | OPTI_TYPE_APPENDED_SALT
9401 | OPTI_TYPE_RAW_HASH;
9402 dgst_pos0 = 3;
9403 dgst_pos1 = 7;
9404 dgst_pos2 = 2;
9405 dgst_pos3 = 6;
9406 break;
9407
9408 case 10700: hash_type = HASH_TYPE_PDFU32;
9409 salt_type = SALT_TYPE_EMBEDDED;
9410 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9411 opts_type = OPTS_TYPE_PT_GENERATE_LE
9412 | OPTS_TYPE_HASH_COPY;
9413 kern_type = KERN_TYPE_PDF17L8;
9414 dgst_size = DGST_SIZE_4_8;
9415 parse_func = pdf17l8_parse_hash;
9416 sort_by_digest = sort_by_digest_4_8;
9417 opti_type = OPTI_TYPE_ZERO_BYTE
9418 | OPTI_TYPE_NOT_ITERATED;
9419 dgst_pos0 = 0;
9420 dgst_pos1 = 1;
9421 dgst_pos2 = 2;
9422 dgst_pos3 = 3;
9423 break;
9424
9425 case 10800: hash_type = HASH_TYPE_SHA384;
9426 salt_type = SALT_TYPE_NONE;
9427 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9428 opts_type = OPTS_TYPE_PT_GENERATE_BE
9429 | OPTS_TYPE_PT_ADD80
9430 | OPTS_TYPE_PT_ADDBITS15;
9431 kern_type = KERN_TYPE_SHA384;
9432 dgst_size = DGST_SIZE_8_8;
9433 parse_func = sha384_parse_hash;
9434 sort_by_digest = sort_by_digest_8_8;
9435 opti_type = OPTI_TYPE_ZERO_BYTE
9436 | OPTI_TYPE_PRECOMPUTE_INIT
9437 | OPTI_TYPE_PRECOMPUTE_MERKLE
9438 | OPTI_TYPE_EARLY_SKIP
9439 | OPTI_TYPE_NOT_ITERATED
9440 | OPTI_TYPE_NOT_SALTED
9441 | OPTI_TYPE_RAW_HASH;
9442 dgst_pos0 = 6;
9443 dgst_pos1 = 7;
9444 dgst_pos2 = 4;
9445 dgst_pos3 = 5;
9446 break;
9447
9448 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9449 salt_type = SALT_TYPE_EMBEDDED;
9450 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9451 opts_type = OPTS_TYPE_PT_GENERATE_LE
9452 | OPTS_TYPE_ST_BASE64
9453 | OPTS_TYPE_HASH_COPY;
9454 kern_type = KERN_TYPE_PBKDF2_SHA256;
9455 dgst_size = DGST_SIZE_4_32;
9456 parse_func = pbkdf2_sha256_parse_hash;
9457 sort_by_digest = sort_by_digest_4_32;
9458 opti_type = OPTI_TYPE_ZERO_BYTE;
9459 dgst_pos0 = 0;
9460 dgst_pos1 = 1;
9461 dgst_pos2 = 2;
9462 dgst_pos3 = 3;
9463 break;
9464
9465 case 11000: hash_type = HASH_TYPE_MD5;
9466 salt_type = SALT_TYPE_INTERN;
9467 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9468 opts_type = OPTS_TYPE_PT_GENERATE_LE
9469 | OPTS_TYPE_PT_ADD80;
9470 kern_type = KERN_TYPE_PRESTASHOP;
9471 dgst_size = DGST_SIZE_4_4;
9472 parse_func = prestashop_parse_hash;
9473 sort_by_digest = sort_by_digest_4_4;
9474 opti_type = OPTI_TYPE_ZERO_BYTE
9475 | OPTI_TYPE_PRECOMPUTE_INIT
9476 | OPTI_TYPE_NOT_ITERATED
9477 | OPTI_TYPE_PREPENDED_SALT;
9478 dgst_pos0 = 0;
9479 dgst_pos1 = 3;
9480 dgst_pos2 = 2;
9481 dgst_pos3 = 1;
9482 break;
9483
9484 case 11100: hash_type = HASH_TYPE_MD5;
9485 salt_type = SALT_TYPE_EMBEDDED;
9486 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9487 opts_type = OPTS_TYPE_PT_GENERATE_LE
9488 | OPTS_TYPE_ST_ADD80;
9489 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9490 dgst_size = DGST_SIZE_4_4;
9491 parse_func = postgresql_auth_parse_hash;
9492 sort_by_digest = sort_by_digest_4_4;
9493 opti_type = OPTI_TYPE_ZERO_BYTE
9494 | OPTI_TYPE_PRECOMPUTE_INIT
9495 | OPTI_TYPE_PRECOMPUTE_MERKLE
9496 | OPTI_TYPE_EARLY_SKIP;
9497 dgst_pos0 = 0;
9498 dgst_pos1 = 3;
9499 dgst_pos2 = 2;
9500 dgst_pos3 = 1;
9501 break;
9502
9503 case 11200: hash_type = HASH_TYPE_SHA1;
9504 salt_type = SALT_TYPE_EMBEDDED;
9505 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9506 opts_type = OPTS_TYPE_PT_GENERATE_BE
9507 | OPTS_TYPE_PT_ADD80
9508 | OPTS_TYPE_ST_HEX;
9509 kern_type = KERN_TYPE_MYSQL_AUTH;
9510 dgst_size = DGST_SIZE_4_5;
9511 parse_func = mysql_auth_parse_hash;
9512 sort_by_digest = sort_by_digest_4_5;
9513 opti_type = OPTI_TYPE_ZERO_BYTE
9514 | OPTI_TYPE_EARLY_SKIP;
9515 dgst_pos0 = 3;
9516 dgst_pos1 = 4;
9517 dgst_pos2 = 2;
9518 dgst_pos3 = 1;
9519 break;
9520
9521 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9522 salt_type = SALT_TYPE_EMBEDDED;
9523 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9524 opts_type = OPTS_TYPE_PT_GENERATE_LE
9525 | OPTS_TYPE_ST_HEX
9526 | OPTS_TYPE_ST_ADD80;
9527 kern_type = KERN_TYPE_BITCOIN_WALLET;
9528 dgst_size = DGST_SIZE_4_4;
9529 parse_func = bitcoin_wallet_parse_hash;
9530 sort_by_digest = sort_by_digest_4_4;
9531 opti_type = OPTI_TYPE_ZERO_BYTE;
9532 dgst_pos0 = 0;
9533 dgst_pos1 = 1;
9534 dgst_pos2 = 2;
9535 dgst_pos3 = 3;
9536 break;
9537
9538 case 11400: hash_type = HASH_TYPE_MD5;
9539 salt_type = SALT_TYPE_EMBEDDED;
9540 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9541 opts_type = OPTS_TYPE_PT_GENERATE_LE
9542 | OPTS_TYPE_PT_ADD80
9543 | OPTS_TYPE_HASH_COPY;
9544 kern_type = KERN_TYPE_SIP_AUTH;
9545 dgst_size = DGST_SIZE_4_4;
9546 parse_func = sip_auth_parse_hash;
9547 sort_by_digest = sort_by_digest_4_4;
9548 opti_type = OPTI_TYPE_ZERO_BYTE;
9549 dgst_pos0 = 0;
9550 dgst_pos1 = 3;
9551 dgst_pos2 = 2;
9552 dgst_pos3 = 1;
9553 break;
9554
9555 case 11500: hash_type = HASH_TYPE_CRC32;
9556 salt_type = SALT_TYPE_INTERN;
9557 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9558 opts_type = OPTS_TYPE_PT_GENERATE_LE
9559 | OPTS_TYPE_ST_GENERATE_LE
9560 | OPTS_TYPE_ST_HEX;
9561 kern_type = KERN_TYPE_CRC32;
9562 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9563 parse_func = crc32_parse_hash;
9564 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9565 opti_type = OPTI_TYPE_ZERO_BYTE;
9566 dgst_pos0 = 0;
9567 dgst_pos1 = 1;
9568 dgst_pos2 = 2;
9569 dgst_pos3 = 3;
9570 break;
9571
9572 case 11600: hash_type = HASH_TYPE_AES;
9573 salt_type = SALT_TYPE_EMBEDDED;
9574 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9575 opts_type = OPTS_TYPE_PT_GENERATE_LE
9576 | OPTS_TYPE_PT_NEVERCRACK;
9577 kern_type = KERN_TYPE_SEVEN_ZIP;
9578 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9579 parse_func = seven_zip_parse_hash;
9580 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9581 opti_type = OPTI_TYPE_ZERO_BYTE;
9582 dgst_pos0 = 0;
9583 dgst_pos1 = 1;
9584 dgst_pos2 = 2;
9585 dgst_pos3 = 3;
9586 break;
9587
9588 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9589 salt_type = SALT_TYPE_NONE;
9590 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9591 opts_type = OPTS_TYPE_PT_GENERATE_LE
9592 | OPTS_TYPE_PT_ADD01;
9593 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9594 dgst_size = DGST_SIZE_4_8;
9595 parse_func = gost2012sbog_256_parse_hash;
9596 sort_by_digest = sort_by_digest_4_8;
9597 opti_type = OPTI_TYPE_ZERO_BYTE;
9598 dgst_pos0 = 0;
9599 dgst_pos1 = 1;
9600 dgst_pos2 = 2;
9601 dgst_pos3 = 3;
9602 break;
9603
9604 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9605 salt_type = SALT_TYPE_NONE;
9606 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9607 opts_type = OPTS_TYPE_PT_GENERATE_LE
9608 | OPTS_TYPE_PT_ADD01;
9609 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9610 dgst_size = DGST_SIZE_4_16;
9611 parse_func = gost2012sbog_512_parse_hash;
9612 sort_by_digest = sort_by_digest_4_16;
9613 opti_type = OPTI_TYPE_ZERO_BYTE;
9614 dgst_pos0 = 0;
9615 dgst_pos1 = 1;
9616 dgst_pos2 = 2;
9617 dgst_pos3 = 3;
9618 break;
9619
9620 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9621 salt_type = SALT_TYPE_EMBEDDED;
9622 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9623 opts_type = OPTS_TYPE_PT_GENERATE_LE
9624 | OPTS_TYPE_ST_BASE64
9625 | OPTS_TYPE_HASH_COPY;
9626 kern_type = KERN_TYPE_PBKDF2_MD5;
9627 dgst_size = DGST_SIZE_4_32;
9628 parse_func = pbkdf2_md5_parse_hash;
9629 sort_by_digest = sort_by_digest_4_32;
9630 opti_type = OPTI_TYPE_ZERO_BYTE;
9631 dgst_pos0 = 0;
9632 dgst_pos1 = 1;
9633 dgst_pos2 = 2;
9634 dgst_pos3 = 3;
9635 break;
9636
9637 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
9638 salt_type = SALT_TYPE_EMBEDDED;
9639 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9640 opts_type = OPTS_TYPE_PT_GENERATE_LE
9641 | OPTS_TYPE_ST_BASE64
9642 | OPTS_TYPE_HASH_COPY;
9643 kern_type = KERN_TYPE_PBKDF2_SHA1;
9644 dgst_size = DGST_SIZE_4_32;
9645 parse_func = pbkdf2_sha1_parse_hash;
9646 sort_by_digest = sort_by_digest_4_32;
9647 opti_type = OPTI_TYPE_ZERO_BYTE;
9648 dgst_pos0 = 0;
9649 dgst_pos1 = 1;
9650 dgst_pos2 = 2;
9651 dgst_pos3 = 3;
9652 break;
9653
9654 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
9655 salt_type = SALT_TYPE_EMBEDDED;
9656 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9657 opts_type = OPTS_TYPE_PT_GENERATE_LE
9658 | OPTS_TYPE_ST_BASE64
9659 | OPTS_TYPE_HASH_COPY;
9660 kern_type = KERN_TYPE_PBKDF2_SHA512;
9661 dgst_size = DGST_SIZE_8_16;
9662 parse_func = pbkdf2_sha512_parse_hash;
9663 sort_by_digest = sort_by_digest_8_16;
9664 opti_type = OPTI_TYPE_ZERO_BYTE;
9665 dgst_pos0 = 0;
9666 dgst_pos1 = 1;
9667 dgst_pos2 = 2;
9668 dgst_pos3 = 3;
9669 break;
9670
9671 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
9672 salt_type = SALT_TYPE_EMBEDDED;
9673 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9674 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9675 kern_type = KERN_TYPE_ECRYPTFS;
9676 dgst_size = DGST_SIZE_8_8;
9677 parse_func = ecryptfs_parse_hash;
9678 sort_by_digest = sort_by_digest_8_8;
9679 opti_type = OPTI_TYPE_ZERO_BYTE;
9680 dgst_pos0 = 0;
9681 dgst_pos1 = 1;
9682 dgst_pos2 = 2;
9683 dgst_pos3 = 3;
9684 break;
9685
9686 case 12300: hash_type = HASH_TYPE_ORACLET;
9687 salt_type = SALT_TYPE_EMBEDDED;
9688 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9689 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9690 kern_type = KERN_TYPE_ORACLET;
9691 dgst_size = DGST_SIZE_8_16;
9692 parse_func = oraclet_parse_hash;
9693 sort_by_digest = sort_by_digest_8_16;
9694 opti_type = OPTI_TYPE_ZERO_BYTE;
9695 dgst_pos0 = 0;
9696 dgst_pos1 = 1;
9697 dgst_pos2 = 2;
9698 dgst_pos3 = 3;
9699 break;
9700
9701 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
9702 salt_type = SALT_TYPE_EMBEDDED;
9703 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9704 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9705 kern_type = KERN_TYPE_BSDICRYPT;
9706 dgst_size = DGST_SIZE_4_4;
9707 parse_func = bsdicrypt_parse_hash;
9708 sort_by_digest = sort_by_digest_4_4;
9709 opti_type = OPTI_TYPE_ZERO_BYTE
9710 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9711 dgst_pos0 = 0;
9712 dgst_pos1 = 1;
9713 dgst_pos2 = 2;
9714 dgst_pos3 = 3;
9715 break;
9716
9717 case 12500: hash_type = HASH_TYPE_RAR3HP;
9718 salt_type = SALT_TYPE_EMBEDDED;
9719 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9720 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9721 kern_type = KERN_TYPE_RAR3;
9722 dgst_size = DGST_SIZE_4_4;
9723 parse_func = rar3hp_parse_hash;
9724 sort_by_digest = sort_by_digest_4_4;
9725 opti_type = OPTI_TYPE_ZERO_BYTE;
9726 dgst_pos0 = 0;
9727 dgst_pos1 = 1;
9728 dgst_pos2 = 2;
9729 dgst_pos3 = 3;
9730 break;
9731
9732 case 12600: hash_type = HASH_TYPE_SHA256;
9733 salt_type = SALT_TYPE_INTERN;
9734 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9735 opts_type = OPTS_TYPE_PT_GENERATE_BE
9736 | OPTS_TYPE_PT_ADD80;
9737 kern_type = KERN_TYPE_CF10;
9738 dgst_size = DGST_SIZE_4_8;
9739 parse_func = cf10_parse_hash;
9740 sort_by_digest = sort_by_digest_4_8;
9741 opti_type = OPTI_TYPE_ZERO_BYTE
9742 | OPTI_TYPE_PRECOMPUTE_INIT
9743 | OPTI_TYPE_EARLY_SKIP
9744 | OPTI_TYPE_NOT_ITERATED;
9745 dgst_pos0 = 3;
9746 dgst_pos1 = 7;
9747 dgst_pos2 = 2;
9748 dgst_pos3 = 6;
9749 break;
9750
9751 case 12700: hash_type = HASH_TYPE_AES;
9752 salt_type = SALT_TYPE_EMBEDDED;
9753 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9754 opts_type = OPTS_TYPE_PT_GENERATE_LE
9755 | OPTS_TYPE_HASH_COPY;
9756 kern_type = KERN_TYPE_MYWALLET;
9757 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9758 parse_func = mywallet_parse_hash;
9759 sort_by_digest = sort_by_digest_4_5;
9760 opti_type = OPTI_TYPE_ZERO_BYTE;
9761 dgst_pos0 = 0;
9762 dgst_pos1 = 1;
9763 dgst_pos2 = 2;
9764 dgst_pos3 = 3;
9765 break;
9766
9767 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
9768 salt_type = SALT_TYPE_EMBEDDED;
9769 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9770 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9771 kern_type = KERN_TYPE_MS_DRSR;
9772 dgst_size = DGST_SIZE_4_8;
9773 parse_func = ms_drsr_parse_hash;
9774 sort_by_digest = sort_by_digest_4_8;
9775 opti_type = OPTI_TYPE_ZERO_BYTE;
9776 dgst_pos0 = 0;
9777 dgst_pos1 = 1;
9778 dgst_pos2 = 2;
9779 dgst_pos3 = 3;
9780 break;
9781
9782 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9783 salt_type = SALT_TYPE_EMBEDDED;
9784 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9785 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9786 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
9787 dgst_size = DGST_SIZE_4_8;
9788 parse_func = androidfde_samsung_parse_hash;
9789 sort_by_digest = sort_by_digest_4_8;
9790 opti_type = OPTI_TYPE_ZERO_BYTE;
9791 dgst_pos0 = 0;
9792 dgst_pos1 = 1;
9793 dgst_pos2 = 2;
9794 dgst_pos3 = 3;
9795 break;
9796
9797 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
9798 salt_type = SALT_TYPE_EMBEDDED;
9799 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9800 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9801 kern_type = KERN_TYPE_RAR5;
9802 dgst_size = DGST_SIZE_4_4;
9803 parse_func = rar5_parse_hash;
9804 sort_by_digest = sort_by_digest_4_4;
9805 opti_type = OPTI_TYPE_ZERO_BYTE;
9806 dgst_pos0 = 0;
9807 dgst_pos1 = 1;
9808 dgst_pos2 = 2;
9809 dgst_pos3 = 3;
9810 break;
9811
9812 default: usage_mini_print (PROGNAME); return (-1);
9813 }
9814
9815 /**
9816 * transpose
9817 */
9818
9819 data.parse_func = parse_func;
9820
9821 /**
9822 * misc stuff
9823 */
9824
9825 if (hex_salt)
9826 {
9827 if (salt_type == SALT_TYPE_INTERN)
9828 {
9829 opts_type |= OPTS_TYPE_ST_HEX;
9830 }
9831 else
9832 {
9833 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
9834
9835 return (-1);
9836 }
9837 }
9838
9839 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
9840 | (salt_type == SALT_TYPE_EXTERN)
9841 | (salt_type == SALT_TYPE_EMBEDDED)
9842 | (salt_type == SALT_TYPE_VIRTUAL));
9843
9844 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
9845
9846 data.hash_type = hash_type;
9847 data.attack_mode = attack_mode;
9848 data.attack_kern = attack_kern;
9849 data.attack_exec = attack_exec;
9850 data.kern_type = kern_type;
9851 data.opts_type = opts_type;
9852 data.dgst_size = dgst_size;
9853 data.salt_type = salt_type;
9854 data.isSalted = isSalted;
9855 data.sort_by_digest = sort_by_digest;
9856 data.dgst_pos0 = dgst_pos0;
9857 data.dgst_pos1 = dgst_pos1;
9858 data.dgst_pos2 = dgst_pos2;
9859 data.dgst_pos3 = dgst_pos3;
9860
9861 esalt_size = 0;
9862
9863 switch (hash_mode)
9864 {
9865 case 2500: esalt_size = sizeof (wpa_t); break;
9866 case 5300: esalt_size = sizeof (ikepsk_t); break;
9867 case 5400: esalt_size = sizeof (ikepsk_t); break;
9868 case 5500: esalt_size = sizeof (netntlm_t); break;
9869 case 5600: esalt_size = sizeof (netntlm_t); break;
9870 case 6211:
9871 case 6212:
9872 case 6213:
9873 case 6221:
9874 case 6222:
9875 case 6223:
9876 case 6231:
9877 case 6232:
9878 case 6233:
9879 case 6241:
9880 case 6242:
9881 case 6243: esalt_size = sizeof (tc_t); break;
9882 case 6600: esalt_size = sizeof (agilekey_t); break;
9883 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
9884 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
9885 case 7300: esalt_size = sizeof (rakp_t); break;
9886 case 7500: esalt_size = sizeof (krb5pa_t); break;
9887 case 8200: esalt_size = sizeof (cloudkey_t); break;
9888 case 8800: esalt_size = sizeof (androidfde_t); break;
9889 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
9890 case 9400: esalt_size = sizeof (office2007_t); break;
9891 case 9500: esalt_size = sizeof (office2010_t); break;
9892 case 9600: esalt_size = sizeof (office2013_t); break;
9893 case 9700: esalt_size = sizeof (oldoffice01_t); break;
9894 case 9710: esalt_size = sizeof (oldoffice01_t); break;
9895 case 9720: esalt_size = sizeof (oldoffice01_t); break;
9896 case 9800: esalt_size = sizeof (oldoffice34_t); break;
9897 case 9810: esalt_size = sizeof (oldoffice34_t); break;
9898 case 9820: esalt_size = sizeof (oldoffice34_t); break;
9899 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
9900 case 10200: esalt_size = sizeof (cram_md5_t); break;
9901 case 10400: esalt_size = sizeof (pdf_t); break;
9902 case 10410: esalt_size = sizeof (pdf_t); break;
9903 case 10420: esalt_size = sizeof (pdf_t); break;
9904 case 10500: esalt_size = sizeof (pdf_t); break;
9905 case 10600: esalt_size = sizeof (pdf_t); break;
9906 case 10700: esalt_size = sizeof (pdf_t); break;
9907 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
9908 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
9909 case 11400: esalt_size = sizeof (sip_t); break;
9910 case 11600: esalt_size = sizeof (seven_zip_t); break;
9911 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
9912 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
9913 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
9914 case 13000: esalt_size = sizeof (rar5_t); break;
9915 }
9916
9917 data.esalt_size = esalt_size;
9918
9919 /**
9920 * choose dictionary parser
9921 */
9922
9923 if (hash_type == HASH_TYPE_LM)
9924 {
9925 get_next_word_func = get_next_word_lm;
9926 }
9927 else if (opts_type & OPTS_TYPE_PT_UPPER)
9928 {
9929 get_next_word_func = get_next_word_uc;
9930 }
9931 else
9932 {
9933 get_next_word_func = get_next_word_std;
9934 }
9935
9936 /**
9937 * dictstat
9938 */
9939
9940 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
9941
9942 #ifdef _POSIX
9943 size_t dictstat_nmemb = 0;
9944 #endif
9945
9946 #ifdef _WIN
9947 uint dictstat_nmemb = 0;
9948 #endif
9949
9950 char dictstat[256];
9951
9952 FILE *dictstat_fp = NULL;
9953
9954 if (keyspace == 0)
9955 {
9956 memset (dictstat, 0, sizeof (dictstat));
9957
9958 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
9959
9960 dictstat_fp = fopen (dictstat, "rb");
9961
9962 if (dictstat_fp)
9963 {
9964 #ifdef _POSIX
9965 struct stat tmpstat;
9966
9967 fstat (fileno (dictstat_fp), &tmpstat);
9968 #endif
9969
9970 #ifdef _WIN
9971 struct stat64 tmpstat;
9972
9973 _fstat64 (fileno (dictstat_fp), &tmpstat);
9974 #endif
9975
9976 if (tmpstat.st_mtime < COMPTIME)
9977 {
9978 /* with v0.15 the format changed so we have to ensure user is using a good version
9979 since there is no version-header in the dictstat file */
9980
9981 fclose (dictstat_fp);
9982
9983 unlink (dictstat);
9984 }
9985 else
9986 {
9987 while (!feof (dictstat_fp))
9988 {
9989 dictstat_t d;
9990
9991 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
9992
9993 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
9994
9995 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
9996 {
9997 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
9998
9999 return -1;
10000 }
10001 }
10002
10003 fclose (dictstat_fp);
10004 }
10005 }
10006 }
10007
10008 /**
10009 * potfile
10010 */
10011
10012 char potfile[256];
10013
10014 memset (potfile, 0, sizeof (potfile));
10015
10016 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
10017
10018 data.pot_fp = NULL;
10019
10020 FILE *out_fp = NULL;
10021 FILE *pot_fp = NULL;
10022
10023 if (show == 1 || left == 1)
10024 {
10025 pot_fp = fopen (potfile, "rb");
10026
10027 if (pot_fp == NULL)
10028 {
10029 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10030
10031 return (-1);
10032 }
10033
10034 if (outfile != NULL)
10035 {
10036 if ((out_fp = fopen (outfile, "ab")) == NULL)
10037 {
10038 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10039
10040 fclose (pot_fp);
10041
10042 return (-1);
10043 }
10044 }
10045 else
10046 {
10047 out_fp = stdout;
10048 }
10049 }
10050 else
10051 {
10052 if (potfile_disable == 0)
10053 {
10054 pot_fp = fopen (potfile, "ab");
10055
10056 if (pot_fp == NULL)
10057 {
10058 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10059
10060 return (-1);
10061 }
10062
10063 data.pot_fp = pot_fp;
10064 }
10065 }
10066
10067 pot_t *pot = NULL;
10068
10069 uint pot_cnt = 0;
10070 uint pot_avail = 0;
10071
10072 if (show == 1 || left == 1)
10073 {
10074 SUPPRESS_OUTPUT = 1;
10075
10076 pot_avail = count_lines (pot_fp);
10077
10078 rewind (pot_fp);
10079
10080 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10081
10082 uint pot_hashes_avail = 0;
10083
10084 uint line_num = 0;
10085
10086 while (!feof (pot_fp))
10087 {
10088 line_num++;
10089
10090 char line_buf[BUFSIZ];
10091
10092 int line_len = fgetl (pot_fp, line_buf);
10093
10094 if (line_len == 0) continue;
10095
10096 char *plain_buf = line_buf + line_len;
10097
10098 pot_t *pot_ptr = &pot[pot_cnt];
10099
10100 hash_t *hashes_buf = &pot_ptr->hash;
10101
10102 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10103 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10104
10105 if (pot_cnt == pot_hashes_avail)
10106 {
10107 uint pos = 0;
10108
10109 for (pos = 0; pos < INCR_POT; pos++)
10110 {
10111 if ((pot_cnt + pos) >= pot_avail) break;
10112
10113 pot_t *tmp_pot = &pot[pot_cnt + pos];
10114
10115 hash_t *tmp_hash = &tmp_pot->hash;
10116
10117 tmp_hash->digest = mymalloc (dgst_size);
10118
10119 if (isSalted)
10120 {
10121 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10122 }
10123
10124 if (esalt_size)
10125 {
10126 tmp_hash->esalt = mymalloc (esalt_size);
10127 }
10128
10129 pot_hashes_avail++;
10130 }
10131 }
10132
10133 int plain_len = 0;
10134
10135 int parser_status;
10136
10137 int iter = MAX_CUT_TRIES;
10138
10139 do
10140 {
10141 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10142 {
10143 if (line_buf[i] == ':')
10144 {
10145 line_len--;
10146
10147 break;
10148 }
10149 }
10150
10151 if (data.hash_mode != 2500)
10152 {
10153 parser_status = parse_func (line_buf, line_len, hashes_buf);
10154 }
10155 else
10156 {
10157 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10158
10159 if (line_len > max_salt_size)
10160 {
10161 parser_status = PARSER_GLOBAL_LENGTH;
10162 }
10163 else
10164 {
10165 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10166
10167 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10168
10169 hashes_buf->salt->salt_len = line_len;
10170
10171 parser_status = PARSER_OK;
10172 }
10173 }
10174
10175 // if NOT parsed without error, we add the ":" to the plain
10176
10177 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10178 {
10179 plain_len++;
10180 plain_buf--;
10181 }
10182
10183 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10184
10185 if (parser_status < PARSER_GLOBAL_ZERO)
10186 {
10187 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10188
10189 continue;
10190 }
10191
10192 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10193
10194 pot_ptr->plain_len = plain_len;
10195
10196 pot_cnt++;
10197 }
10198
10199 fclose (pot_fp);
10200
10201 SUPPRESS_OUTPUT = 0;
10202
10203 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10204 }
10205
10206 /**
10207 * kernel accel and loops auto adjustment
10208 */
10209
10210 if (kernel_accel_chgd == 0) kernel_accel = set_kernel_accel (hash_mode);
10211 if (kernel_loops_chgd == 0) kernel_loops = set_kernel_loops (hash_mode);
10212
10213 if (workload_profile == 1)
10214 {
10215 kernel_loops /= 8;
10216 kernel_accel /= 4;
10217
10218 if (kernel_loops == 0) kernel_loops = 8;
10219 if (kernel_accel == 0) kernel_accel = 2;
10220 }
10221 else if (workload_profile == 3)
10222 {
10223 kernel_loops *= 8;
10224 kernel_accel *= 4;
10225
10226 if (kernel_loops > 1024) kernel_loops = 1024;
10227 if (kernel_accel > 256) kernel_accel = 256; // causes memory problems otherwise
10228 }
10229
10230 // those hashes *must* run at a specific kernel_loops count because of some optimization inside the kernel
10231
10232 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
10233 {
10234 kernel_loops = 1024;
10235 }
10236
10237 if (hash_mode == 12500)
10238 {
10239 kernel_loops = ROUNDS_RAR3 / 16;
10240 }
10241
10242 data.kernel_accel = kernel_accel;
10243 data.kernel_loops = kernel_loops;
10244
10245 /**
10246 * word len
10247 */
10248
10249 uint pw_min = PW_MIN;
10250 uint pw_max = PW_MAX;
10251
10252 switch (hash_mode)
10253 {
10254 case 400: if (pw_max > 40) pw_max = 40;
10255 break;
10256 case 500: if (pw_max > 16) pw_max = 16;
10257 break;
10258 case 1500: if (pw_max > 8) pw_max = 8;
10259 break;
10260 case 1600: if (pw_max > 16) pw_max = 16;
10261 break;
10262 case 1800: if (pw_max > 16) pw_max = 16;
10263 break;
10264 case 2100: if (pw_max > 16) pw_max = 16;
10265 break;
10266 case 2500: if (pw_min < 8) pw_min = 8;
10267 break;
10268 case 3000: if (pw_max > 7) pw_max = 7;
10269 break;
10270 case 5200: if (pw_max > 24) pw_max = 24;
10271 break;
10272 case 5800: if (pw_max > 16) pw_max = 16;
10273 break;
10274 case 6300: if (pw_max > 16) pw_max = 16;
10275 break;
10276 case 7400: if (pw_max > 16) pw_max = 16;
10277 break;
10278 case 7900: if (pw_max > 48) pw_max = 48;
10279 break;
10280 case 8500: if (pw_max > 8) pw_max = 8;
10281 break;
10282 case 8600: if (pw_max > 16) pw_max = 16;
10283 break;
10284 case 9710: pw_min = 5;
10285 pw_max = 5;
10286 break;
10287 case 9810: pw_min = 5;
10288 pw_max = 5;
10289 break;
10290 case 10410: pw_min = 5;
10291 pw_max = 5;
10292 break;
10293 case 10300: if (pw_max < 3) pw_min = 3;
10294 if (pw_max > 40) pw_max = 40;
10295 break;
10296 case 10500: if (pw_max < 3) pw_min = 3;
10297 if (pw_max > 40) pw_max = 40;
10298 break;
10299 case 10700: if (pw_max > 16) pw_max = 16;
10300 break;
10301 case 11300: if (pw_max > 40) pw_max = 40;
10302 break;
10303 case 12500: if (pw_max > 20) pw_max = 20;
10304 break;
10305 case 12800: if (pw_max > 24) pw_max = 24;
10306 break;
10307 }
10308
10309 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10310 {
10311 switch (attack_kern)
10312 {
10313 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10314 break;
10315 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10316 break;
10317 }
10318 }
10319
10320 /**
10321 * charsets : keep them together for more easy maintainnce
10322 */
10323
10324 cs_t mp_sys[6];
10325 cs_t mp_usr[4];
10326
10327 memset (mp_sys, 0, sizeof (mp_sys));
10328 memset (mp_usr, 0, sizeof (mp_usr));
10329
10330 mp_setup_sys (mp_sys);
10331
10332 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10333 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10334 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10335 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10336
10337 /**
10338 * load hashes, part I: find input mode, count hashes
10339 */
10340
10341 uint hashlist_mode = 0;
10342 uint hashlist_format = HLFMT_HASHCAT;
10343
10344 uint hashes_avail = 0;
10345
10346 if (benchmark == 0)
10347 {
10348 struct stat f;
10349
10350 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10351
10352 if ((hash_mode == 2500) ||
10353 (hash_mode == 5200) ||
10354 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10355 (hash_mode == 9000))
10356 {
10357 hashlist_mode = HL_MODE_ARG;
10358
10359 char *hashfile = myargv[optind];
10360
10361 data.hashfile = hashfile;
10362
10363 logfile_top_var_string ("target", hashfile);
10364 }
10365
10366 if (hashlist_mode == HL_MODE_ARG)
10367 {
10368 if (hash_mode == 2500)
10369 {
10370 struct stat st;
10371
10372 if (stat (data.hashfile, &st) == -1)
10373 {
10374 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10375
10376 return (-1);
10377 }
10378
10379 hashes_avail = st.st_size / sizeof (hccap_t);
10380 }
10381 else
10382 {
10383 hashes_avail = 1;
10384 }
10385 }
10386 else if (hashlist_mode == HL_MODE_FILE)
10387 {
10388 char *hashfile = myargv[optind];
10389
10390 data.hashfile = hashfile;
10391
10392 logfile_top_var_string ("target", hashfile);
10393
10394 FILE *fp = NULL;
10395
10396 if ((fp = fopen (hashfile, "rb")) == NULL)
10397 {
10398 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10399
10400 return (-1);
10401 }
10402
10403 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10404
10405 hashes_avail = count_lines (fp);
10406
10407 rewind (fp);
10408
10409 if (hashes_avail == 0)
10410 {
10411 log_error ("ERROR: hashfile is empty or corrupt");
10412
10413 fclose (fp);
10414
10415 return (-1);
10416 }
10417
10418 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10419
10420 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10421 {
10422 log_error ("ERROR: remove not supported in native hashfile-format mode");
10423
10424 fclose (fp);
10425
10426 return (-1);
10427 }
10428
10429 fclose (fp);
10430 }
10431 }
10432 else
10433 {
10434 hashlist_mode = HL_MODE_ARG;
10435
10436 hashes_avail = 1;
10437 }
10438
10439 if (hash_mode == 3000) hashes_avail *= 2;
10440
10441 data.hashlist_mode = hashlist_mode;
10442 data.hashlist_format = hashlist_format;
10443
10444 logfile_top_uint (hashlist_mode);
10445 logfile_top_uint (hashlist_format);
10446
10447 /**
10448 * load hashes, part II: allocate required memory, set pointers
10449 */
10450
10451 hash_t *hashes_buf = NULL;
10452 void *digests_buf = NULL;
10453 salt_t *salts_buf = NULL;
10454 void *esalts_buf = NULL;
10455
10456 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10457
10458 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10459
10460 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10461 {
10462 uint32_t hash_pos;
10463
10464 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10465 {
10466 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10467
10468 hashes_buf[hash_pos].hash_info = hash_info;
10469
10470 if (username && (remove || show || left))
10471 {
10472 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10473 }
10474
10475 if (benchmark)
10476 {
10477 hash_info->orighash = (char *) mymalloc (256);
10478 }
10479 }
10480 }
10481
10482 if (isSalted)
10483 {
10484 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10485
10486 if (esalt_size)
10487 {
10488 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10489 }
10490 }
10491 else
10492 {
10493 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10494 }
10495
10496 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10497 {
10498 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10499
10500 if (isSalted)
10501 {
10502 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10503
10504 if (esalt_size)
10505 {
10506 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10507 }
10508 }
10509 else
10510 {
10511 hashes_buf[hash_pos].salt = &salts_buf[0];
10512 }
10513 }
10514
10515 /**
10516 * load hashes, part III: parse hashes or generate them if benchmark
10517 */
10518
10519 uint hashes_cnt = 0;
10520
10521 if (benchmark == 0)
10522 {
10523 if (keyspace == 1)
10524 {
10525 // useless to read hash file for keyspace, cheat a little bit w/ optind
10526 }
10527 else if (hashes_avail == 0)
10528 {
10529 }
10530 else if (hashlist_mode == HL_MODE_ARG)
10531 {
10532 char *input_buf = myargv[optind];
10533
10534 uint input_len = strlen (input_buf);
10535
10536 logfile_top_var_string ("target", input_buf);
10537
10538 char *hash_buf = NULL;
10539 int hash_len = 0;
10540
10541 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10542
10543 if (hash_len)
10544 {
10545 if (opts_type & OPTS_TYPE_HASH_COPY)
10546 {
10547 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10548
10549 hash_info_tmp->orighash = mystrdup (hash_buf);
10550 }
10551
10552 if (isSalted)
10553 {
10554 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10555 }
10556
10557 int parser_status = PARSER_OK;
10558
10559 if (hash_mode == 2500)
10560 {
10561 if (hash_len == 0)
10562 {
10563 log_error ("ERROR: hccap file not specified");
10564
10565 return (-1);
10566 }
10567
10568 hashlist_mode = HL_MODE_FILE;
10569
10570 data.hashlist_mode = hashlist_mode;
10571
10572 FILE *fp = fopen (hash_buf, "rb");
10573
10574 if (fp == NULL)
10575 {
10576 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10577
10578 return (-1);
10579 }
10580
10581 if (hashes_avail < 1)
10582 {
10583 log_error ("ERROR: hccap file is empty or corrupt");
10584
10585 fclose (fp);
10586
10587 return (-1);
10588 }
10589
10590 uint hccap_size = sizeof (hccap_t);
10591
10592 char in[hccap_size];
10593
10594 while (!feof (fp))
10595 {
10596 int n = fread (&in, hccap_size, 1, fp);
10597
10598 if (n != 1)
10599 {
10600 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
10601
10602 break;
10603 }
10604
10605 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
10606
10607 if (parser_status != PARSER_OK)
10608 {
10609 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
10610
10611 continue;
10612 }
10613
10614 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
10615
10616 if ((show == 1) || (left == 1))
10617 {
10618 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
10619
10620 char *salt_ptr = (char *) tmp_salt->salt_buf;
10621
10622 int cur_pos = tmp_salt->salt_len;
10623 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10624
10625 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
10626
10627 unsigned char *pke_ptr = (unsigned char *) wpa->pke;
10628
10629 // do the appending task
10630
10631 snprintf (salt_ptr + cur_pos,
10632 rem_len,
10633 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
10634 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
10635 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
10636
10637
10638 // memset () the remaining part of the salt
10639
10640 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
10641 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10642
10643 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
10644
10645 tmp_salt->salt_len += 1 + 12 + 1 + 12;
10646 }
10647
10648 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);
10649 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);
10650
10651 hashes_cnt++;
10652 }
10653
10654 fclose (fp);
10655 }
10656 else if (hash_mode == 3000)
10657 {
10658 if (hash_len == 32)
10659 {
10660 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10661
10662 hash_t *lm_hash_left = NULL;
10663
10664 if (parser_status == PARSER_OK)
10665 {
10666 lm_hash_left = &hashes_buf[hashes_cnt];
10667
10668 hashes_cnt++;
10669 }
10670 else
10671 {
10672 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10673 }
10674
10675
10676 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10677
10678 hash_t *lm_hash_right = NULL;
10679
10680 if (parser_status == PARSER_OK)
10681 {
10682 lm_hash_right = &hashes_buf[hashes_cnt];
10683
10684 hashes_cnt++;
10685 }
10686 else
10687 {
10688 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10689 }
10690
10691 // show / left
10692
10693 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
10694 {
10695 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);
10696 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);
10697 }
10698 }
10699 else
10700 {
10701 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10702
10703 if (parser_status == PARSER_OK)
10704 {
10705 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10706 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10707 }
10708
10709 if (parser_status == PARSER_OK)
10710 {
10711 hashes_cnt++;
10712 }
10713 else
10714 {
10715 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10716 }
10717 }
10718 }
10719 else
10720 {
10721 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10722
10723 if (parser_status == PARSER_OK)
10724 {
10725 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10726 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10727 }
10728
10729 if (parser_status == PARSER_OK)
10730 {
10731 hashes_cnt++;
10732 }
10733 else
10734 {
10735 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10736 }
10737 }
10738 }
10739 }
10740 else if (hashlist_mode == HL_MODE_FILE)
10741 {
10742 char *hashfile = data.hashfile;
10743
10744 FILE *fp;
10745
10746 if ((fp = fopen (hashfile, "rb")) == NULL)
10747 {
10748 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10749
10750 return (-1);
10751 }
10752
10753 uint line_num = 0;
10754
10755 while (!feof (fp))
10756 {
10757 line_num++;
10758
10759 char line_buf[BUFSIZ];
10760
10761 int line_len = fgetl (fp, line_buf);
10762
10763 if (line_len == 0) continue;
10764
10765 char *hash_buf = NULL;
10766 int hash_len = 0;
10767
10768 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
10769
10770 if (username)
10771 {
10772 char *user_buf = NULL;
10773 int user_len = 0;
10774
10775 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
10776
10777 if (remove || show)
10778 {
10779 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
10780
10781 *user = (user_t *) malloc (sizeof (user_t));
10782
10783 user_t *user_ptr = *user;
10784
10785 if (user_buf != NULL)
10786 {
10787 user_ptr->user_name = mystrdup (user_buf);
10788 }
10789 else
10790 {
10791 user_ptr->user_name = mystrdup ("");
10792 }
10793
10794 user_ptr->user_len = user_len;
10795 }
10796 }
10797
10798 if (opts_type & OPTS_TYPE_HASH_COPY)
10799 {
10800 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10801
10802 hash_info_tmp->orighash = mystrdup (hash_buf);
10803 }
10804
10805 if (isSalted)
10806 {
10807 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
10808 }
10809
10810 if (hash_mode == 3000)
10811 {
10812 if (hash_len == 32)
10813 {
10814 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10815
10816 if (parser_status < PARSER_GLOBAL_ZERO)
10817 {
10818 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10819
10820 continue;
10821 }
10822
10823 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
10824
10825 hashes_cnt++;
10826
10827 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10828
10829 if (parser_status < PARSER_GLOBAL_ZERO)
10830 {
10831 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10832
10833 continue;
10834 }
10835
10836 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
10837
10838 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);
10839
10840 hashes_cnt++;
10841
10842 // show / left
10843
10844 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);
10845 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);
10846 }
10847 else
10848 {
10849 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10850
10851 if (parser_status < PARSER_GLOBAL_ZERO)
10852 {
10853 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10854
10855 continue;
10856 }
10857
10858 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);
10859
10860 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10861 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10862
10863 hashes_cnt++;
10864 }
10865 }
10866 else
10867 {
10868 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10869
10870 if (parser_status < PARSER_GLOBAL_ZERO)
10871 {
10872 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10873
10874 continue;
10875 }
10876
10877 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);
10878
10879 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10880 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10881
10882 hashes_cnt++;
10883 }
10884 }
10885
10886 fclose (fp);
10887
10888 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
10889
10890 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
10891 }
10892 }
10893 else
10894 {
10895 if (isSalted)
10896 {
10897 hashes_buf[0].salt->salt_len = 8;
10898
10899 // special salt handling
10900
10901 switch (hash_mode)
10902 {
10903 case 1500: hashes_buf[0].salt->salt_len = 2;
10904 break;
10905 case 1731: hashes_buf[0].salt->salt_len = 4;
10906 break;
10907 case 2410: hashes_buf[0].salt->salt_len = 4;
10908 break;
10909 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
10910 break;
10911 case 3100: hashes_buf[0].salt->salt_len = 1;
10912 break;
10913 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
10914 break;
10915 case 5800: hashes_buf[0].salt->salt_len = 16;
10916 break;
10917 case 6800: hashes_buf[0].salt->salt_len = 32;
10918 break;
10919 case 8400: hashes_buf[0].salt->salt_len = 40;
10920 break;
10921 case 8800: hashes_buf[0].salt->salt_len = 16;
10922 break;
10923 case 8900: hashes_buf[0].salt->salt_len = 16;
10924 hashes_buf[0].salt->scrypt_N = 1024;
10925 hashes_buf[0].salt->scrypt_r = 1;
10926 hashes_buf[0].salt->scrypt_p = 1;
10927 break;
10928 case 9100: hashes_buf[0].salt->salt_len = 16;
10929 break;
10930 case 9300: hashes_buf[0].salt->salt_len = 14;
10931 hashes_buf[0].salt->scrypt_N = 16384;
10932 hashes_buf[0].salt->scrypt_r = 1;
10933 hashes_buf[0].salt->scrypt_p = 1;
10934 break;
10935 case 9400: hashes_buf[0].salt->salt_len = 16;
10936 break;
10937 case 9500: hashes_buf[0].salt->salt_len = 16;
10938 break;
10939 case 9600: hashes_buf[0].salt->salt_len = 16;
10940 break;
10941 case 9700: hashes_buf[0].salt->salt_len = 16;
10942 break;
10943 case 9710: hashes_buf[0].salt->salt_len = 16;
10944 break;
10945 case 9720: hashes_buf[0].salt->salt_len = 16;
10946 break;
10947 case 9800: hashes_buf[0].salt->salt_len = 16;
10948 break;
10949 case 9810: hashes_buf[0].salt->salt_len = 16;
10950 break;
10951 case 9820: hashes_buf[0].salt->salt_len = 16;
10952 break;
10953 case 10300: hashes_buf[0].salt->salt_len = 12;
10954 break;
10955 case 11500: hashes_buf[0].salt->salt_len = 4;
10956 break;
10957 case 11600: hashes_buf[0].salt->salt_len = 4;
10958 break;
10959 case 12400: hashes_buf[0].salt->salt_len = 4;
10960 break;
10961 case 12500: hashes_buf[0].salt->salt_len = 8;
10962 break;
10963 case 12600: hashes_buf[0].salt->salt_len = 64;
10964 break;
10965 }
10966
10967 // special esalt handling
10968
10969 switch (hash_mode)
10970 {
10971 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
10972 break;
10973 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
10974 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
10975 break;
10976 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
10977 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
10978 break;
10979 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
10980 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
10981 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
10982 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
10983 break;
10984 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
10985 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
10986 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
10987 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
10988 break;
10989 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
10990 break;
10991 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10992 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
10993 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
10994 break;
10995 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10996 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
10997 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
10998 break;
10999 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11000 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11001 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11002 break;
11003 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11004 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11005 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11006 break;
11007 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11008 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11009 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11010 break;
11011 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11012 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11013 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11014 break;
11015 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11016 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11017 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11018 break;
11019 }
11020 }
11021
11022 // set hashfile
11023
11024 switch (hash_mode)
11025 {
11026 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11027 break;
11028 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11029 break;
11030 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11031 break;
11032 case 6211:
11033 case 6212:
11034 case 6213:
11035 case 6221:
11036 case 6222:
11037 case 6223:
11038 case 6231:
11039 case 6232:
11040 case 6233:
11041 case 6241:
11042 case 6242:
11043 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11044 break;
11045 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11046 break;
11047 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11048 break;
11049 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11050 break;
11051 }
11052
11053 // set default iterations
11054
11055 switch (hash_mode)
11056 {
11057 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11058 break;
11059 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11060 break;
11061 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11062 break;
11063 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11064 break;
11065 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11066 break;
11067 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11068 break;
11069 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11070 break;
11071 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11072 break;
11073 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11074 break;
11075 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11076 break;
11077 case 6211:
11078 case 6212:
11079 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11080 break;
11081 case 6221:
11082 case 6222:
11083 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11084 break;
11085 case 6231:
11086 case 6232:
11087 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11088 break;
11089 case 6241:
11090 case 6242:
11091 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11092 break;
11093 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11094 break;
11095 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11096 break;
11097 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11098 break;
11099 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11100 break;
11101 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11102 break;
11103 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11104 break;
11105 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11106 break;
11107 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11108 break;
11109 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11110 break;
11111 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11112 break;
11113 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11114 break;
11115 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11116 break;
11117 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11118 break;
11119 case 8900: hashes_buf[0].salt->salt_iter = 1;
11120 break;
11121 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11122 break;
11123 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11124 break;
11125 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11126 break;
11127 case 9300: hashes_buf[0].salt->salt_iter = 1;
11128 break;
11129 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11130 break;
11131 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11132 break;
11133 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11134 break;
11135 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11136 break;
11137 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11138 break;
11139 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11140 break;
11141 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11142 break;
11143 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11144 break;
11145 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11146 break;
11147 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11148 break;
11149 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11150 break;
11151 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11152 break;
11153 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11154 break;
11155 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11156 break;
11157 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11158 break;
11159 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11160 break;
11161 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11162 break;
11163 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11164 break;
11165 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11166 break;
11167 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11168 break;
11169 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11170 break;
11171 }
11172
11173 // set special tuning for benchmark-mode 1
11174
11175 if (benchmark_mode == 1)
11176 {
11177 kernel_loops *= 8;
11178 kernel_accel *= 4;
11179
11180 switch (hash_mode)
11181 {
11182 case 400: kernel_loops = ROUNDS_PHPASS;
11183 kernel_accel = 32;
11184 break;
11185 case 500: kernel_loops = ROUNDS_MD5CRYPT;
11186 kernel_accel = 32;
11187 break;
11188 case 501: kernel_loops = ROUNDS_MD5CRYPT;
11189 kernel_accel = 32;
11190 break;
11191 case 1600: kernel_loops = ROUNDS_MD5CRYPT;
11192 kernel_accel = 32;
11193 break;
11194 case 1800: kernel_loops = ROUNDS_SHA512CRYPT;
11195 kernel_accel = 16;
11196 break;
11197 case 2100: kernel_loops = ROUNDS_DCC2;
11198 kernel_accel = 16;
11199 break;
11200 case 2500: kernel_loops = ROUNDS_WPA2;
11201 kernel_accel = 32;
11202 break;
11203 case 3200: kernel_loops = ROUNDS_BCRYPT;
11204 kernel_accel = 8;
11205 break;
11206 case 5200: kernel_loops = ROUNDS_PSAFE3;
11207 kernel_accel = 16;
11208 break;
11209 case 5800: kernel_loops = ROUNDS_ANDROIDPIN;
11210 kernel_accel = 16;
11211 break;
11212 case 6211: kernel_loops = ROUNDS_TRUECRYPT_2K;
11213 kernel_accel = 64;
11214 break;
11215 case 6212: kernel_loops = ROUNDS_TRUECRYPT_2K;
11216 kernel_accel = 32;
11217 break;
11218 case 6213: kernel_loops = ROUNDS_TRUECRYPT_2K;
11219 kernel_accel = 32;
11220 break;
11221 case 6221: kernel_loops = ROUNDS_TRUECRYPT_1K;
11222 kernel_accel = 8;
11223 break;
11224 case 6222: kernel_loops = ROUNDS_TRUECRYPT_1K;
11225 kernel_accel = 8;
11226 break;
11227 case 6223: kernel_loops = ROUNDS_TRUECRYPT_1K;
11228 kernel_accel = 8;
11229 break;
11230 case 6231: kernel_loops = ROUNDS_TRUECRYPT_1K;
11231 kernel_accel = 8;
11232 break;
11233 case 6232: kernel_loops = ROUNDS_TRUECRYPT_1K;
11234 kernel_accel = 8;
11235 break;
11236 case 6233: kernel_loops = ROUNDS_TRUECRYPT_1K;
11237 kernel_accel = 8;
11238 break;
11239 case 6241: kernel_loops = ROUNDS_TRUECRYPT_1K;
11240 kernel_accel = 128;
11241 break;
11242 case 6242: kernel_loops = ROUNDS_TRUECRYPT_1K;
11243 kernel_accel = 64;
11244 break;
11245 case 6243: kernel_loops = ROUNDS_TRUECRYPT_1K;
11246 kernel_accel = 64;
11247 break;
11248 case 6300: kernel_loops = ROUNDS_MD5CRYPT;
11249 kernel_accel = 32;
11250 break;
11251 case 6700: kernel_loops = ROUNDS_SHA1AIX;
11252 kernel_accel = 128;
11253 break;
11254 case 6400: kernel_loops = ROUNDS_SHA256AIX;
11255 kernel_accel = 128;
11256 break;
11257 case 6500: kernel_loops = ROUNDS_SHA512AIX;
11258 kernel_accel = 32;
11259 break;
11260 case 6600: kernel_loops = ROUNDS_AGILEKEY;
11261 kernel_accel = 64;
11262 break;
11263 case 6800: kernel_loops = ROUNDS_LASTPASS;
11264 kernel_accel = 64;
11265 break;
11266 case 7100: kernel_loops = ROUNDS_SHA512OSX;
11267 kernel_accel = 8;
11268 break;
11269 case 7200: kernel_loops = ROUNDS_GRUB;
11270 kernel_accel = 16;
11271 break;
11272 case 7400: kernel_loops = ROUNDS_SHA256CRYPT;
11273 kernel_accel = 8;
11274 break;
11275 case 7900: kernel_loops = ROUNDS_DRUPAL7;
11276 kernel_accel = 8;
11277 break;
11278 case 8200: kernel_loops = ROUNDS_CLOUDKEY;
11279 kernel_accel = 8;
11280 break;
11281 case 8800: kernel_loops = ROUNDS_ANDROIDFDE;
11282 kernel_accel = 32;
11283 break;
11284 case 8900: kernel_loops = 1;
11285 kernel_accel = 64;
11286 break;
11287 case 9000: kernel_loops = ROUNDS_PSAFE2;
11288 kernel_accel = 16;
11289 break;
11290 case 9100: kernel_loops = ROUNDS_LOTUS8;
11291 kernel_accel = 64;
11292 break;
11293 case 9200: kernel_loops = ROUNDS_CISCO8;
11294 kernel_accel = 8;
11295 break;
11296 case 9300: kernel_loops = 1;
11297 kernel_accel = 4;
11298 break;
11299 case 9400: kernel_loops = ROUNDS_OFFICE2007;
11300 kernel_accel = 32;
11301 break;
11302 case 9500: kernel_loops = ROUNDS_OFFICE2010;
11303 kernel_accel = 32;
11304 break;
11305 case 9600: kernel_loops = ROUNDS_OFFICE2013;
11306 kernel_accel = 8;
11307 break;
11308 case 10000: kernel_loops = ROUNDS_DJANGOPBKDF2;
11309 kernel_accel = 8;
11310 break;
11311 case 10300: kernel_loops = ROUNDS_SAPH_SHA1;
11312 kernel_accel = 16;
11313 break;
11314 case 10500: kernel_loops = ROUNDS_PDF14;
11315 kernel_accel = 256;
11316 break;
11317 case 10700: kernel_loops = ROUNDS_PDF17L8;
11318 kernel_accel = 8;
11319 break;
11320 case 10900: kernel_loops = ROUNDS_PBKDF2_SHA256;
11321 kernel_accel = 8;
11322 break;
11323 case 11300: kernel_loops = ROUNDS_BITCOIN_WALLET;
11324 kernel_accel = 8;
11325 break;
11326 case 11600: kernel_loops = ROUNDS_SEVEN_ZIP;
11327 kernel_accel = 8;
11328 break;
11329 case 11900: kernel_loops = ROUNDS_PBKDF2_MD5;
11330 kernel_accel = 8;
11331 break;
11332 case 12000: kernel_loops = ROUNDS_PBKDF2_SHA1;
11333 kernel_accel = 8;
11334 break;
11335 case 12100: kernel_loops = ROUNDS_PBKDF2_SHA512;
11336 kernel_accel = 8;
11337 break;
11338 case 12200: kernel_loops = ROUNDS_ECRYPTFS;
11339 kernel_accel = 8;
11340 break;
11341 case 12300: kernel_loops = ROUNDS_ORACLET;
11342 kernel_accel = 8;
11343 break;
11344 case 12500: kernel_loops = ROUNDS_RAR3;
11345 kernel_accel = 32;
11346 break;
11347 case 12700: kernel_loops = ROUNDS_MYWALLET;
11348 kernel_accel = 512;
11349 break;
11350 case 12800: kernel_loops = ROUNDS_MS_DRSR;
11351 kernel_accel = 512;
11352 break;
11353 case 12900: kernel_loops = ROUNDS_ANDROIDFDE_SAMSUNG;
11354 kernel_accel = 8;
11355 break;
11356 case 13000: kernel_loops = ROUNDS_RAR5;
11357 kernel_accel = 8;
11358 break;
11359 }
11360
11361 // some algorithm collide too fast, make that impossible
11362
11363 switch (hash_mode)
11364 {
11365 case 11500: ((uint *) digests_buf)[1] = 1;
11366 break;
11367 }
11368
11369 if (kernel_loops > 1024) kernel_loops = 1024;
11370 if (kernel_accel > 256) kernel_accel = 256; // causes memory problems otherwise
11371 }
11372
11373 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
11374 {
11375 kernel_loops = 1024;
11376 }
11377
11378 if (hash_mode == 12500)
11379 {
11380 kernel_loops = ROUNDS_RAR3 / 16;
11381 }
11382
11383 data.kernel_accel = kernel_accel;
11384 data.kernel_loops = kernel_loops;
11385
11386 hashes_cnt = 1;
11387 }
11388
11389 if (show == 1 || left == 1)
11390 {
11391 for (uint i = 0; i < pot_cnt; i++)
11392 {
11393 pot_t *pot_ptr = &pot[i];
11394
11395 hash_t *hashes_buf = &pot_ptr->hash;
11396
11397 local_free (hashes_buf->digest);
11398
11399 if (isSalted)
11400 {
11401 local_free (hashes_buf->salt);
11402 }
11403 }
11404
11405 local_free (pot);
11406
11407 if (data.quiet == 0) log_info_nn ("");
11408
11409 return (0);
11410 }
11411
11412 if (keyspace == 0)
11413 {
11414 if (hashes_cnt == 0)
11415 {
11416 log_error ("ERROR: No hashes loaded");
11417
11418 return (-1);
11419 }
11420 }
11421
11422 /**
11423 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11424 */
11425
11426 if (data.outfile != NULL)
11427 {
11428 if (data.hashfile != NULL)
11429 {
11430 #ifdef _POSIX
11431 struct stat tmpstat_outfile;
11432 struct stat tmpstat_hashfile;
11433 #endif
11434
11435 #ifdef _WIN
11436 struct stat64 tmpstat_outfile;
11437 struct stat64 tmpstat_hashfile;
11438 #endif
11439
11440 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11441
11442 if (tmp_outfile_fp)
11443 {
11444 #ifdef _POSIX
11445 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11446 #endif
11447
11448 #ifdef _WIN
11449 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11450 #endif
11451
11452 fclose (tmp_outfile_fp);
11453 }
11454
11455 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11456
11457 if (tmp_hashfile_fp)
11458 {
11459 #ifdef _POSIX
11460 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11461 #endif
11462
11463 #ifdef _WIN
11464 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11465 #endif
11466
11467 fclose (tmp_hashfile_fp);
11468 }
11469
11470 if (tmp_outfile_fp && tmp_outfile_fp)
11471 {
11472 tmpstat_outfile.st_mode = 0;
11473 tmpstat_outfile.st_nlink = 0;
11474 tmpstat_outfile.st_uid = 0;
11475 tmpstat_outfile.st_gid = 0;
11476 tmpstat_outfile.st_rdev = 0;
11477 tmpstat_outfile.st_atime = 0;
11478
11479 tmpstat_hashfile.st_mode = 0;
11480 tmpstat_hashfile.st_nlink = 0;
11481 tmpstat_hashfile.st_uid = 0;
11482 tmpstat_hashfile.st_gid = 0;
11483 tmpstat_hashfile.st_rdev = 0;
11484 tmpstat_hashfile.st_atime = 0;
11485
11486 #ifdef _POSIX
11487 tmpstat_outfile.st_blksize = 0;
11488 tmpstat_outfile.st_blocks = 0;
11489
11490 tmpstat_hashfile.st_blksize = 0;
11491 tmpstat_hashfile.st_blocks = 0;
11492 #endif
11493
11494 #ifdef _POSIX
11495 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11496 {
11497 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11498
11499 return (-1);
11500 }
11501 #endif
11502
11503 #ifdef _WIN
11504 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11505 {
11506 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11507
11508 return (-1);
11509 }
11510 #endif
11511 }
11512 }
11513 }
11514
11515 /**
11516 * Remove duplicates
11517 */
11518
11519 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11520
11521 if (isSalted)
11522 {
11523 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11524 }
11525 else
11526 {
11527 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11528 }
11529
11530 uint hashes_cnt_orig = hashes_cnt;
11531
11532 hashes_cnt = 1;
11533
11534 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11535 {
11536 if (isSalted)
11537 {
11538 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11539 {
11540 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11541 }
11542 }
11543 else
11544 {
11545 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11546 }
11547
11548 if (hashes_pos > hashes_cnt)
11549 {
11550 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11551 }
11552
11553 hashes_cnt++;
11554 }
11555
11556 /**
11557 * Potfile removes
11558 */
11559
11560 uint potfile_remove_cracks = 0;
11561
11562 if (potfile_disable == 0)
11563 {
11564 hash_t hash_buf;
11565
11566 hash_buf.digest = mymalloc (dgst_size);
11567 hash_buf.salt = NULL;
11568 hash_buf.esalt = NULL;
11569 hash_buf.hash_info = NULL;
11570 hash_buf.cracked = 0;
11571
11572 if (isSalted)
11573 {
11574 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11575 }
11576
11577 if (esalt_size)
11578 {
11579 hash_buf.esalt = mymalloc (esalt_size);
11580 }
11581
11582 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11583
11584 // no solution for these special hash types (for instane because they use hashfile in output etc)
11585 if ((hash_mode != 5200) &&
11586 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11587 (hash_mode != 9000))
11588 {
11589 FILE *fp = fopen (potfile, "rb");
11590
11591 if (fp != NULL)
11592 {
11593 while (!feof (fp))
11594 {
11595 char line_buf[BUFSIZ];
11596
11597 memset (line_buf, 0, BUFSIZ);
11598
11599 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11600
11601 if (ptr == NULL) break;
11602
11603 int line_len = strlen (line_buf);
11604
11605 if (line_len == 0) continue;
11606
11607 int iter = MAX_CUT_TRIES;
11608
11609 for (int i = line_len - 1; i && iter; i--, line_len--)
11610 {
11611 if (line_buf[i] != ':') continue;
11612
11613 if (isSalted)
11614 {
11615 memset (hash_buf.salt, 0, sizeof (salt_t));
11616 }
11617
11618 hash_t *found = NULL;
11619
11620 if (hash_mode == 6800)
11621 {
11622 if (i < 48) // 48 = 12 * uint in salt_buf[]
11623 {
11624 // manipulate salt_buf
11625 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11626
11627 hash_buf.salt->salt_len = i;
11628
11629 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11630 }
11631 }
11632 else if (hash_mode == 2500)
11633 {
11634 if (i < 48) // 48 = 12 * uint in salt_buf[]
11635 {
11636 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11637 // manipulate salt_buf
11638
11639 // to be safe work with a copy (because of line_len loop, i etc)
11640
11641 char line_buf_cpy[BUFSIZ];
11642 memset (line_buf_cpy, 0, BUFSIZ);
11643
11644 memset (line_buf_cpy, 0, sizeof (line_buf_cpy));
11645
11646 memcpy (line_buf_cpy, line_buf, i);
11647
11648 char *mac2_pos = strrchr (line_buf_cpy, ':');
11649
11650 if (mac2_pos == NULL) continue;
11651
11652 mac2_pos[0] = 0;
11653 mac2_pos++;
11654
11655 if (strlen (mac2_pos) != 12) continue;
11656
11657 char *mac1_pos = strrchr (line_buf_cpy, ':');
11658
11659 if (mac1_pos == NULL) continue;
11660
11661 mac1_pos[0] = 0;
11662 mac1_pos++;
11663
11664 if (strlen (mac1_pos) != 12) continue;
11665
11666 uint essid_length = mac1_pos - line_buf_cpy - 1;
11667
11668 // here we need the ESSID
11669 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11670
11671 hash_buf.salt->salt_len = essid_length;
11672
11673 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11674
11675 if (found)
11676 {
11677 wpa_t *wpa = (wpa_t *) found->esalt;
11678
11679 uint pke[25];
11680
11681 char *pke_ptr = (char *) pke;
11682
11683 for (uint i = 0; i < 25; i++)
11684 {
11685 pke[i] = byte_swap_32 (wpa->pke[i]);
11686 }
11687
11688 unsigned char mac1[6];
11689 unsigned char mac2[6];
11690
11691 memcpy (mac1, pke_ptr + 23, 6);
11692 memcpy (mac2, pke_ptr + 29, 6);
11693
11694 // compare hex string(s) vs binary MAC address(es)
11695
11696 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11697 {
11698 if (mac1[i] != (unsigned char) hex_to_char (&mac1_pos[j]))
11699 {
11700 found = NULL;
11701 break;
11702 }
11703 }
11704
11705 // early skip ;)
11706 if (!found) continue;
11707
11708 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11709 {
11710 if (mac2[i] != (unsigned char) hex_to_char (&mac2_pos[j]))
11711 {
11712 found = NULL;
11713 break;
11714 }
11715 }
11716 }
11717 }
11718 }
11719 else
11720 {
11721 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11722
11723 if (parser_status == PARSER_OK)
11724 {
11725 if (isSalted)
11726 {
11727 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11728 }
11729 else
11730 {
11731 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11732 }
11733 }
11734 }
11735
11736 if (found == NULL) continue;
11737
11738 if (!found->cracked) potfile_remove_cracks++;
11739
11740 found->cracked = 1;
11741
11742 if (found) break;
11743
11744 iter--;
11745 }
11746 }
11747
11748 fclose (fp);
11749 }
11750 }
11751
11752 if (esalt_size)
11753 {
11754 local_free (hash_buf.esalt);
11755 }
11756
11757 if (isSalted)
11758 {
11759 local_free (hash_buf.salt);
11760 }
11761
11762 local_free (hash_buf.digest);
11763 }
11764
11765 /**
11766 * Now generate all the buffers required for later
11767 */
11768
11769 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11770
11771 salt_t *salts_buf_new = NULL;
11772 void *esalts_buf_new = NULL;
11773
11774 if (isSalted)
11775 {
11776 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11777
11778 if (esalt_size)
11779 {
11780 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
11781 }
11782 }
11783 else
11784 {
11785 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
11786 }
11787
11788 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
11789
11790 uint digests_cnt = hashes_cnt;
11791 uint digests_done = 0;
11792
11793 uint size_digests = digests_cnt * dgst_size;
11794 uint size_shown = digests_cnt * sizeof (uint);
11795
11796 uint *digests_shown = (uint *) mymalloc (size_shown);
11797 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
11798
11799 uint salts_cnt = 0;
11800 uint salts_done = 0;
11801
11802 hashinfo_t **hash_info = NULL;
11803
11804 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11805 {
11806 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
11807
11808 if (username && (remove || show))
11809 {
11810 uint user_pos;
11811
11812 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
11813 {
11814 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
11815
11816 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
11817 }
11818 }
11819 }
11820
11821 uint *salts_shown = (uint *) mymalloc (size_shown);
11822
11823 salt_t *salt_buf;
11824
11825 {
11826 // copied from inner loop
11827
11828 salt_buf = &salts_buf_new[salts_cnt];
11829
11830 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
11831
11832 if (esalt_size)
11833 {
11834 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
11835 }
11836
11837 salt_buf->digests_cnt = 0;
11838 salt_buf->digests_done = 0;
11839 salt_buf->digests_offset = 0;
11840
11841 salts_cnt++;
11842 }
11843
11844 if (hashes_buf[0].cracked == 1)
11845 {
11846 digests_shown[0] = 1;
11847
11848 digests_done++;
11849
11850 salt_buf->digests_done++;
11851 }
11852
11853 salt_buf->digests_cnt++;
11854
11855 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
11856
11857 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11858 {
11859 hash_info[0] = hashes_buf[0].hash_info;
11860 }
11861
11862 // copy from inner loop
11863
11864 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
11865 {
11866 if (isSalted)
11867 {
11868 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
11869 {
11870 salt_buf = &salts_buf_new[salts_cnt];
11871
11872 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
11873
11874 if (esalt_size)
11875 {
11876 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
11877 }
11878
11879 salt_buf->digests_cnt = 0;
11880 salt_buf->digests_done = 0;
11881 salt_buf->digests_offset = hashes_pos;
11882
11883 salts_cnt++;
11884 }
11885 }
11886
11887 if (hashes_buf[hashes_pos].cracked == 1)
11888 {
11889 digests_shown[hashes_pos] = 1;
11890
11891 digests_done++;
11892
11893 salt_buf->digests_done++;
11894 }
11895
11896 salt_buf->digests_cnt++;
11897
11898 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
11899
11900 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11901 {
11902 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
11903 }
11904 }
11905
11906 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
11907 {
11908 salt_t *salt_buf = &salts_buf_new[salt_pos];
11909
11910 if (salt_buf->digests_done == salt_buf->digests_cnt)
11911 {
11912 salts_shown[salt_pos] = 1;
11913
11914 salts_done++;
11915 }
11916
11917 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
11918 }
11919
11920 local_free (digests_buf);
11921 local_free (salts_buf);
11922 local_free (esalts_buf);
11923
11924 digests_buf = digests_buf_new;
11925 salts_buf = salts_buf_new;
11926 esalts_buf = esalts_buf_new;
11927
11928 local_free (hashes_buf);
11929
11930 /**
11931 * special modification not set from parser
11932 */
11933
11934 switch (hash_mode)
11935 {
11936 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
11937 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
11938 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
11939 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
11940 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
11941 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
11942 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
11943 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
11944 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
11945 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
11946 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
11947 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
11948 }
11949
11950 if (truecrypt_keyfiles)
11951 {
11952 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
11953
11954 char *keyfiles = strdup (truecrypt_keyfiles);
11955
11956 char *keyfile = strtok (keyfiles, ",");
11957
11958 do
11959 {
11960 truecrypt_crc32 (keyfile, (unsigned char *) keyfile_buf);
11961
11962 } while ((keyfile = strtok (NULL, ",")) != NULL);
11963
11964 free (keyfiles);
11965 }
11966
11967 data.digests_cnt = digests_cnt;
11968 data.digests_done = digests_done;
11969 data.digests_buf = digests_buf;
11970 data.digests_shown = digests_shown;
11971 data.digests_shown_tmp = digests_shown_tmp;
11972
11973 data.salts_cnt = salts_cnt;
11974 data.salts_done = salts_done;
11975 data.salts_buf = salts_buf;
11976 data.salts_shown = salts_shown;
11977
11978 data.esalts_buf = esalts_buf;
11979 data.hash_info = hash_info;
11980
11981 /**
11982 * Automatic Optimizers
11983 */
11984
11985 if (salts_cnt == 1)
11986 opti_type |= OPTI_TYPE_SINGLE_SALT;
11987
11988 if (digests_cnt == 1)
11989 opti_type |= OPTI_TYPE_SINGLE_HASH;
11990
11991 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11992 opti_type |= OPTI_TYPE_NOT_ITERATED;
11993
11994 if (attack_mode == ATTACK_MODE_BF)
11995 opti_type |= OPTI_TYPE_BRUTE_FORCE;
11996
11997 data.opti_type = opti_type;
11998
11999 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12000 {
12001 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12002 {
12003 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12004 {
12005 if (opts_type & OPTS_TYPE_ST_ADD80)
12006 {
12007 opts_type &= ~OPTS_TYPE_ST_ADD80;
12008 opts_type |= OPTS_TYPE_PT_ADD80;
12009 }
12010
12011 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12012 {
12013 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12014 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12015 }
12016
12017 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12018 {
12019 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12020 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12021 }
12022 }
12023 }
12024 }
12025
12026 /**
12027 * Some algorithm, like descrypt, can benefit from JIT compilation
12028 */
12029
12030 uint force_jit_compilation = 0;
12031
12032 if (hash_mode == 8900)
12033 {
12034 force_jit_compilation = 8900;
12035 }
12036 else if (hash_mode == 9300)
12037 {
12038 force_jit_compilation = 8900;
12039 }
12040 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12041 {
12042 force_jit_compilation = 1500;
12043 }
12044
12045 /**
12046 * generate bitmap tables
12047 */
12048
12049 const uint bitmap_shift1 = 5;
12050 const uint bitmap_shift2 = 13;
12051
12052 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12053
12054 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12055 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12056 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12057 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12058 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12059 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12060 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12061 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12062
12063 uint bitmap_bits;
12064 uint bitmap_nums;
12065 uint bitmap_mask;
12066 uint bitmap_size;
12067
12068 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12069 {
12070 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12071
12072 bitmap_nums = 1 << bitmap_bits;
12073
12074 bitmap_mask = bitmap_nums - 1;
12075
12076 bitmap_size = bitmap_nums * sizeof (uint);
12077
12078 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12079
12080 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;
12081 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;
12082
12083 break;
12084 }
12085
12086 bitmap_nums = 1 << bitmap_bits;
12087
12088 bitmap_mask = bitmap_nums - 1;
12089
12090 bitmap_size = bitmap_nums * sizeof (uint);
12091
12092 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);
12093 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);
12094
12095 /**
12096 * prepare quick rule
12097 */
12098
12099 data.rule_buf_l = rule_buf_l;
12100 data.rule_buf_r = rule_buf_r;
12101
12102 int rule_len_l = (int) strlen (rule_buf_l);
12103 int rule_len_r = (int) strlen (rule_buf_r);
12104
12105 data.rule_len_l = rule_len_l;
12106 data.rule_len_r = rule_len_r;
12107
12108 /**
12109 * load rules
12110 */
12111
12112 uint *all_kernel_rules_cnt = NULL;
12113
12114 kernel_rule_t **all_kernel_rules_buf = NULL;
12115
12116 if (rp_files_cnt)
12117 {
12118 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12119
12120 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12121 }
12122
12123 char rule_buf[BUFSIZ];
12124
12125 int rule_len = 0;
12126
12127 for (uint i = 0; i < rp_files_cnt; i++)
12128 {
12129 uint kernel_rules_avail = 0;
12130
12131 uint kernel_rules_cnt = 0;
12132
12133 kernel_rule_t *kernel_rules_buf = NULL;
12134
12135 char *rp_file = rp_files[i];
12136
12137 char in[BLOCK_SIZE];
12138 char out[BLOCK_SIZE];
12139
12140 FILE *fp = NULL;
12141
12142 uint rule_line = 0;
12143
12144 if ((fp = fopen (rp_file, "rb")) == NULL)
12145 {
12146 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12147
12148 return (-1);
12149 }
12150
12151 while (!feof (fp))
12152 {
12153 memset (rule_buf, 0, BUFSIZ);
12154
12155 rule_len = fgetl (fp, rule_buf);
12156
12157 rule_line++;
12158
12159 if (rule_len == 0) continue;
12160
12161 if (rule_buf[0] == '#') continue;
12162
12163 if (kernel_rules_avail == kernel_rules_cnt)
12164 {
12165 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12166
12167 kernel_rules_avail += INCR_RULES;
12168 }
12169
12170 memset (in, 0, BLOCK_SIZE);
12171 memset (out, 0, BLOCK_SIZE);
12172
12173 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12174
12175 if (result == -1)
12176 {
12177 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12178
12179 continue;
12180 }
12181
12182 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12183 {
12184 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12185
12186 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12187
12188 continue;
12189 }
12190
12191 /* its so slow
12192 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12193 {
12194 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12195
12196 continue;
12197 }
12198 */
12199
12200 kernel_rules_cnt++;
12201 }
12202
12203 fclose (fp);
12204
12205 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12206
12207 all_kernel_rules_buf[i] = kernel_rules_buf;
12208 }
12209
12210 /**
12211 * merge rules or automatic rule generator
12212 */
12213
12214 uint kernel_rules_cnt = 0;
12215
12216 kernel_rule_t *kernel_rules_buf = NULL;
12217
12218 if (attack_mode == ATTACK_MODE_STRAIGHT)
12219 {
12220 if (rp_files_cnt)
12221 {
12222 kernel_rules_cnt = 1;
12223
12224 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12225
12226 repeats[0] = kernel_rules_cnt;
12227
12228 for (uint i = 0; i < rp_files_cnt; i++)
12229 {
12230 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12231
12232 repeats[i + 1] = kernel_rules_cnt;
12233 }
12234
12235 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12236
12237 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12238
12239 for (uint i = 0; i < kernel_rules_cnt; i++)
12240 {
12241 uint out_pos = 0;
12242
12243 kernel_rule_t *out = &kernel_rules_buf[i];
12244
12245 for (uint j = 0; j < rp_files_cnt; j++)
12246 {
12247 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12248 uint in_pos;
12249
12250 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12251
12252 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12253 {
12254 if (out_pos == RULES_MAX - 1)
12255 {
12256 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12257
12258 break;
12259 }
12260
12261 out->cmds[out_pos] = in->cmds[in_pos];
12262 }
12263 }
12264 }
12265
12266 local_free (repeats);
12267 }
12268 else if (rp_gen)
12269 {
12270 uint kernel_rules_avail = 0;
12271
12272 while (kernel_rules_cnt < rp_gen)
12273 {
12274 if (kernel_rules_avail == kernel_rules_cnt)
12275 {
12276 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12277
12278 kernel_rules_avail += INCR_RULES;
12279 }
12280
12281 memset (rule_buf, 0, BLOCK_SIZE);
12282
12283 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12284
12285 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12286
12287 kernel_rules_cnt++;
12288 }
12289 }
12290 }
12291
12292 /**
12293 * generate NOP rules
12294 */
12295
12296 if (kernel_rules_cnt == 0)
12297 {
12298 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12299
12300 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12301
12302 kernel_rules_cnt++;
12303 }
12304
12305 data.kernel_rules_cnt = kernel_rules_cnt;
12306 data.kernel_rules_buf = kernel_rules_buf;
12307
12308 /**
12309 * platform
12310 */
12311
12312 cl_platform_id CL_platforms[CL_PLATFORMS_MAX];
12313
12314 uint CL_platforms_cnt = 0;
12315
12316 hc_clGetPlatformIDs (CL_PLATFORMS_MAX, CL_platforms, &CL_platforms_cnt);
12317
12318 if (CL_platforms_cnt == 0)
12319 {
12320 log_error ("ERROR: No OpenCL compatible platform found");
12321
12322 return (-1);
12323 }
12324
12325 int CL_platform_sel = 1;
12326
12327 if (opencl_platform != NULL)
12328 {
12329 CL_platform_sel = atoi (opencl_platform);
12330 }
12331
12332 if (CL_platforms_cnt > 1)
12333 {
12334 if (opencl_platform == NULL)
12335 {
12336 log_error ("ERROR: Too many OpenCL compatible platforms found");
12337
12338 log_info ("Please select a single platform using the --opencl-platform option");
12339 log_info ("");
12340 log_info ("Available OpenCL platforms:");
12341 log_info ("");
12342
12343 for (uint i = 0; i < CL_platforms_cnt; i++)
12344 {
12345 char CL_platform_vendor[INFOSZ];
12346
12347 memset (CL_platform_vendor, 0, sizeof (CL_platform_vendor));
12348
12349 hc_clGetPlatformInfo (CL_platforms[i], CL_PLATFORM_VENDOR, sizeof (CL_platform_vendor), CL_platform_vendor, NULL);
12350
12351 log_info ("* %d = %s", i + 1, CL_platform_vendor);
12352 }
12353
12354 log_info ("");
12355
12356 return (-1);
12357 }
12358 else
12359 {
12360 if (CL_platform_sel < 1)
12361 {
12362 log_error ("ERROR: --opencl-platform < 1");
12363
12364 return (-1);
12365 }
12366
12367 if (CL_platform_sel > (int) CL_platforms_cnt)
12368 {
12369 log_error ("ERROR: invalid OpenCL platforms selected");
12370
12371 return (-1);
12372 }
12373 }
12374 }
12375 else
12376 {
12377 if (CL_platform_sel != 1)
12378 {
12379 log_error ("ERROR: OpenCL platform number %d is not available", CL_platform_sel);
12380
12381 return (-1);
12382 }
12383 }
12384
12385 // zero-indexed: not starting to count at 1, as user does
12386
12387 CL_platform_sel -= 1;
12388
12389
12390 cl_platform_id CL_platform = CL_platforms[CL_platform_sel];
12391
12392 char CL_platform_vendor[INFOSZ];
12393
12394 memset (CL_platform_vendor, 0, sizeof (CL_platform_vendor));
12395
12396 hc_clGetPlatformInfo (CL_platform, CL_PLATFORM_VENDOR, sizeof (CL_platform_vendor), CL_platform_vendor, NULL);
12397
12398 cl_device_type device_type_filter;
12399
12400 uint vendor_id;
12401
12402 if (strcmp (CL_platform_vendor, CL_VENDOR_AMD) == 0)
12403 {
12404 vendor_id = VENDOR_ID_AMD;
12405
12406 device_type_filter = CL_DEVICE_TYPE_GPU;
12407 }
12408 else if (strcmp (CL_platform_vendor, CL_VENDOR_NV) == 0)
12409 {
12410 vendor_id = VENDOR_ID_NV;
12411
12412 device_type_filter = CL_DEVICE_TYPE_GPU;
12413
12414 // make sure that we do not directly control the fan for NVidia
12415
12416 gpu_temp_retain = 0;
12417
12418 data.gpu_temp_retain = gpu_temp_retain;
12419 }
12420 else if (strcmp (CL_platform_vendor, CL_VENDOR_POCL) == 0)
12421 {
12422 if (force == 0)
12423 {
12424 log_error ("");
12425 log_error ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12426 log_error ("You are STRONGLY encouraged not to use it");
12427 log_error ("You can use --force to override this but do not post error reports if you do so");
12428
12429 return (-1);
12430 }
12431
12432 vendor_id = VENDOR_ID_GENERIC;
12433
12434 device_type_filter = CL_DEVICE_TYPE_DEFAULT;
12435 }
12436 else
12437 {
12438 vendor_id = VENDOR_ID_GENERIC;
12439
12440 device_type_filter = CL_DEVICE_TYPE_DEFAULT;
12441 }
12442
12443 if (vendor_id == VENDOR_ID_GENERIC)
12444 {
12445 log_error ("Warning: unknown OpenCL vendor '%s' detected", CL_platform_vendor);
12446
12447 gpu_temp_disable = 1;
12448 }
12449
12450 data.vendor_id = vendor_id;
12451
12452 /**
12453 * cached kernel path depends on vendor_id which we don't know, so create it here
12454 */
12455
12456 int vendor_id_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 10 + 1;
12457
12458 char *vendor_id_folder = (char *) mymalloc (vendor_id_folder_size);
12459
12460 snprintf (vendor_id_folder, vendor_id_folder_size - 1, "%s/kernels", profile_dir);
12461
12462 mkdir (vendor_id_folder, 0700);
12463
12464 snprintf (vendor_id_folder, vendor_id_folder_size - 1, "%s/kernels/%d", profile_dir, vendor_id);
12465
12466 mkdir (vendor_id_folder, 0700);
12467
12468 myfree (vendor_id_folder);
12469
12470 /**
12471 * devices
12472 */
12473
12474 cl_device_id devices_all[DEVICES_MAX];
12475 cl_device_id devices[DEVICES_MAX];
12476
12477 uint devices_all_cnt = 0;
12478
12479 hc_clGetDeviceIDs (CL_platform, device_type_filter, DEVICES_MAX, devices_all, (uint *) &devices_all_cnt);
12480
12481 int hm_adapters_all = devices_all_cnt;
12482
12483 hm_attrs_t hm_adapter_all[DEVICES_MAX];
12484
12485 memset (hm_adapter_all, 0, sizeof (hm_adapter_all));
12486
12487 if (gpu_temp_disable == 0)
12488 {
12489 if (vendor_id == VENDOR_ID_NV)
12490 {
12491 #ifdef LINUX
12492 HM_LIB hm_dll = hm_init ();
12493
12494 data.hm_dll = hm_dll;
12495
12496 if (hc_NVML_nvmlInit (hm_dll) == NVML_SUCCESS)
12497 {
12498 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX];
12499
12500 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12501
12502 int tmp_out = 0;
12503
12504 for (int i = 0; i < tmp_in; i++)
12505 {
12506 hm_adapter_all[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12507 }
12508
12509 hm_adapters_all = tmp_out;
12510
12511 for (int i = 0; i < tmp_out; i++)
12512 {
12513 unsigned int speed;
12514
12515 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;
12516 }
12517 }
12518 #endif
12519
12520 #ifdef WIN
12521 if (NvAPI_Initialize () == NVAPI_OK)
12522 {
12523 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX];
12524
12525 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12526
12527 int tmp_out = 0;
12528
12529 for (int i = 0; i < tmp_in; i++)
12530 {
12531 hm_adapter_all[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12532 }
12533
12534 hm_adapters_all = tmp_out;
12535
12536 for (int i = 0; i < tmp_out; i++)
12537 {
12538 NvU32 speed;
12539
12540 if (NvAPI_GPU_GetTachReading (hm_adapter_all[i].adapter_index.nv, &speed) != NVAPI_NOT_SUPPORTED) hm_adapter_all[i].fan_supported = 1;
12541 }
12542 }
12543 #endif
12544 }
12545
12546 if (vendor_id == VENDOR_ID_AMD)
12547 {
12548 HM_LIB hm_dll = hm_init ();
12549
12550 data.hm_dll = hm_dll;
12551
12552 if (hc_ADL_Main_Control_Create (hm_dll, ADL_Main_Memory_Alloc, 0) == ADL_OK)
12553 {
12554 // total number of adapters
12555
12556 int hm_adapters_num;
12557
12558 if (get_adapters_num_amd (hm_dll, &hm_adapters_num) != 0) return (-1);
12559
12560 // adapter info
12561
12562 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (hm_dll, hm_adapters_num);
12563
12564 if (lpAdapterInfo == NULL) return (-1);
12565
12566 // get a list (of ids of) valid/usable adapters
12567
12568 int num_adl_adapters = 0;
12569
12570 uint32_t *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
12571
12572 if (num_adl_adapters > 0)
12573 {
12574 hc_thread_mutex_lock (mux_adl);
12575
12576 // hm_get_opencl_busid_devid (hm_adapter_all, devices_all_cnt, devices_all);
12577
12578 hm_get_adapter_index_amd (hm_adapter_all, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12579
12580 hm_get_overdrive_version (hm_dll, hm_adapter_all, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12581 hm_check_fanspeed_control (hm_dll, hm_adapter_all, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12582
12583 hc_thread_mutex_unlock (mux_adl);
12584 }
12585
12586 hm_adapters_all = num_adl_adapters;
12587
12588 myfree (valid_adl_device_list);
12589 myfree (lpAdapterInfo);
12590 }
12591 }
12592 }
12593
12594 if (hm_adapters_all == 0)
12595 {
12596 gpu_temp_disable = 1;
12597 }
12598
12599 if (gpu_temp_disable == 1)
12600 {
12601 gpu_temp_abort = 0;
12602 gpu_temp_retain = 0;
12603 }
12604
12605 /**
12606 * enable custom signal handler(s)
12607 */
12608
12609 if (benchmark == 0)
12610 {
12611 hc_signal (sigHandler_default);
12612 }
12613 else
12614 {
12615 hc_signal (sigHandler_benchmark);
12616 }
12617
12618 /**
12619 * devices mask and properties
12620 */
12621
12622 uint devices_cnt = 0;
12623
12624 for (uint device_all_id = 0; device_all_id < devices_all_cnt; device_all_id++)
12625 {
12626 if (opencl_devicemask)
12627 {
12628 uint device_all_id_mask = 1 << device_all_id;
12629
12630 if ((device_all_id_mask & opencl_devicemask) != device_all_id_mask)
12631 {
12632 if (quiet == 0 && algorithm_pos == 0) log_info ("Device #%d: skipped by user", device_all_id_mask + 1);
12633
12634 continue;
12635 }
12636 }
12637
12638 const uint device_id = devices_cnt;
12639
12640 devices[device_id] = devices_all[device_all_id];
12641
12642 memcpy (&data.hm_device[device_id], &hm_adapter_all[device_all_id], sizeof (hm_attrs_t));
12643
12644 char device_name[INFOSZ];
12645
12646 memset (device_name, 0, sizeof (device_name));
12647
12648 cl_ulong global_mem_size;
12649 cl_ulong max_mem_alloc_size;
12650 cl_uint max_clock_frequency;
12651 cl_uint max_compute_units;
12652
12653 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_NAME, sizeof (device_name), &device_name, NULL);
12654 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (global_mem_size), &global_mem_size, NULL);
12655 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (max_mem_alloc_size), &max_mem_alloc_size, NULL);
12656 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (max_clock_frequency), &max_clock_frequency, NULL);
12657 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (max_compute_units), &max_compute_units, NULL);
12658
12659 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12660 {
12661 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12662 device_all_id + 1,
12663 device_name,
12664 (unsigned int) (max_mem_alloc_size / 1024 / 1024),
12665 (unsigned int) (global_mem_size / 1024 / 1024),
12666 (unsigned int) (max_clock_frequency),
12667 (unsigned int) max_compute_units);
12668 }
12669
12670 devices_cnt++;
12671 }
12672
12673 if (devices_cnt == 0)
12674 {
12675 log_error ("ERROR: No devices left that matches your specification.");
12676
12677 return (-1);
12678 }
12679
12680 data.devices_cnt = devices_cnt;
12681
12682 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12683 {
12684 log_info ("");
12685 }
12686
12687 /**
12688 * inform the user
12689 */
12690
12691 // gpu temp sanity check
12692
12693 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
12694 {
12695 if (gpu_temp_abort < gpu_temp_retain)
12696 {
12697 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
12698
12699 return (-1);
12700 }
12701 }
12702
12703 data.gpu_temp_disable = gpu_temp_disable;
12704 data.gpu_temp_abort = gpu_temp_abort;
12705 data.gpu_temp_retain = gpu_temp_retain;
12706
12707 if (data.quiet == 0)
12708 {
12709 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
12710
12711 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);
12712
12713 if (attack_mode == ATTACK_MODE_STRAIGHT)
12714 {
12715 log_info ("Rules: %u", kernel_rules_cnt);
12716 }
12717
12718 if (opti_type)
12719 {
12720 log_info ("Applicable Optimizers:");
12721
12722 for (uint i = 0; i < 32; i++)
12723 {
12724 const uint opti_bit = 1 << i;
12725
12726 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
12727 }
12728 }
12729
12730 /**
12731 * Watchdog and Temperature balance
12732 */
12733
12734 if (gpu_temp_abort == 0)
12735 {
12736 log_info ("Watchdog: Temperature abort trigger disabled");
12737 }
12738 else
12739 {
12740 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
12741 }
12742
12743 if (gpu_temp_retain == 0)
12744 {
12745 log_info ("Watchdog: Temperature retain trigger disabled");
12746 }
12747 else
12748 {
12749 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
12750 }
12751 }
12752
12753 /**
12754 * devices init
12755 */
12756
12757 int *temp_retain_fanspeed_value = (int *) mycalloc (devices_cnt, sizeof (int));
12758
12759 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (devices_cnt, sizeof (ADLOD6MemClockState));
12760
12761 int *od_power_control_status = (int *) mycalloc (devices_cnt, sizeof (int));
12762
12763 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (devices_cnt, sizeof (hc_device_param_t));
12764
12765 data.devices_param = devices_param;
12766
12767 for (uint device_id = 0; device_id < devices_cnt; device_id++)
12768 {
12769 hc_device_param_t *device_param = &data.devices_param[device_id];
12770
12771 cl_device_id device = devices[device_id];
12772
12773 device_param->device = device;
12774
12775 cl_device_type device_type = 0;
12776
12777 hc_clGetDeviceInfo (device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12778
12779 device_param->device_type = device_type;
12780
12781 cl_uint max_compute_units = 0;
12782
12783 hc_clGetDeviceInfo (device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (max_compute_units), &max_compute_units, NULL);
12784
12785 device_param->device_processors = max_compute_units;
12786
12787 cl_ulong max_mem_alloc_size = 0;
12788
12789 hc_clGetDeviceInfo (device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (max_mem_alloc_size), &max_mem_alloc_size, NULL);
12790
12791 device_param->device_maxmem_alloc = max_mem_alloc_size;
12792
12793 char tmp[INFOSZ], t1[64];
12794
12795 memset (tmp, 0, sizeof (tmp));
12796
12797 hc_clGetDeviceInfo (device, CL_DEVICE_NAME, sizeof (tmp), &tmp, NULL);
12798
12799 device_param->device_name = mystrdup (tmp);
12800
12801 memset (tmp, 0, sizeof (tmp));
12802
12803 hc_clGetDeviceInfo (device, CL_DEVICE_VERSION, sizeof (tmp), &tmp, NULL);
12804
12805 memset (t1, 0, sizeof (t1));
12806
12807 sscanf (tmp, "%*16s %*16s %*16s (%[^)]16s)", t1);
12808
12809 device_param->device_version = mystrdup (t1);
12810
12811 memset (tmp, 0, sizeof (tmp));
12812
12813 hc_clGetDeviceInfo (device, CL_DRIVER_VERSION, sizeof (tmp), &tmp, NULL);
12814
12815 device_param->driver_version = mystrdup (tmp);
12816
12817 // create some filename that is easier to read on cached folder
12818
12819 snprintf (tmp, sizeof (tmp) - 1, "%s-%s-%s-%d", device_param->device_name, device_param->device_version, device_param->driver_version, COMPTIME);
12820
12821 uint device_name_digest[4];
12822
12823 device_name_digest[0] = 0;
12824 device_name_digest[1] = 0;
12825 device_name_digest[2] = 0;
12826 device_name_digest[3] = 0;
12827
12828 md5_64 ((uint *) tmp, device_name_digest);
12829
12830 sprintf (tmp, "%08x", device_name_digest[0]);
12831
12832 device_param->device_name_chksum = mystrdup (tmp);
12833
12834 if (device_type & CL_DEVICE_TYPE_CPU)
12835 {
12836 cl_uint device_processor_cores = 1;
12837
12838 device_param->device_processor_cores = device_processor_cores;
12839 }
12840
12841 if (device_type & CL_DEVICE_TYPE_GPU)
12842 {
12843 if (vendor_id == VENDOR_ID_AMD)
12844 {
12845 cl_uint device_processor_cores = 0;
12846
12847 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12848
12849 hc_clGetDeviceInfo (device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12850
12851 device_param->device_processor_cores = device_processor_cores;
12852 }
12853
12854 if (vendor_id == VENDOR_ID_NV)
12855 {
12856 cl_uint kernel_exec_timeout = 0;
12857
12858 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12859
12860 hc_clGetDeviceInfo (device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12861
12862 device_param->kernel_exec_timeout = kernel_exec_timeout;
12863
12864 cl_uint device_processor_cores = 0;
12865
12866 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12867
12868 hc_clGetDeviceInfo (device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12869
12870 device_param->device_processor_cores = device_processor_cores;
12871
12872 cl_uint sm_minor = 0;
12873 cl_uint sm_major = 0;
12874
12875 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12876 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12877
12878 hc_clGetDeviceInfo (device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12879 hc_clGetDeviceInfo (device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12880
12881 device_param->sm_minor = sm_minor;
12882 device_param->sm_major = sm_major;
12883 }
12884 }
12885
12886 /**
12887 * common driver check
12888 */
12889
12890 if (device_type & CL_DEVICE_TYPE_GPU)
12891 {
12892 if (vendor_id == VENDOR_ID_NV)
12893 {
12894 if (device_param->kernel_exec_timeout != 0)
12895 {
12896 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);
12897 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12898 }
12899 }
12900
12901 if (vendor_id == VENDOR_ID_AMD)
12902 {
12903 int catalyst_check = (force == 1) ? 0 : 1;
12904
12905 int catalyst_warn = 0;
12906
12907 int catalyst_broken = 0;
12908
12909 if (catalyst_check == 1)
12910 {
12911 catalyst_warn = 1;
12912
12913 // v14.9 and higher
12914 if ((atoi (device_param->device_version) >= 1573)
12915 && (atoi (device_param->driver_version) >= 1573))
12916 {
12917 catalyst_warn = 0;
12918 }
12919
12920 catalyst_check = 0;
12921 }
12922
12923 if (catalyst_broken == 1)
12924 {
12925 log_error ("");
12926 log_error ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12927 log_error ("It will pass over cracked hashes and does not report them as cracked");
12928 log_error ("You are STRONGLY encouraged not to use it");
12929 log_error ("You can use --force to override this but do not post error reports if you do so");
12930
12931 return (-1);
12932 }
12933
12934 if (catalyst_warn == 1)
12935 {
12936 log_error ("");
12937 log_error ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12938 log_error ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12939 log_error ("See oclHashcat's homepage for official supported catalyst drivers");
12940 #ifdef _WIN
12941 log_error ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12942 #endif
12943 log_error ("You can use --force to override this but do not post error reports if you do so");
12944
12945 return (-1);
12946 }
12947 }
12948 }
12949 }
12950
12951 /*
12952 * Temporary fix:
12953 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
12954 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
12955 * were not working @ full speed (setting hc_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
12956 * Driver / ADL bug?
12957 */
12958
12959 if (vendor_id == VENDOR_ID_AMD)
12960 {
12961 if (powertune_enable == 1)
12962 {
12963 hc_thread_mutex_lock (mux_adl);
12964
12965 for (uint i = 0; i < devices_cnt; i++)
12966 {
12967 if (data.hm_device[i].od_version == 6)
12968 {
12969 // set powertune value only
12970
12971 int powertune_supported = 0;
12972
12973 int ADL_rc = 0;
12974
12975 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll, data.hm_device[i].adapter_index.amd, &powertune_supported)) != ADL_OK)
12976 {
12977 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
12978
12979 return (-1);
12980 }
12981
12982 if (powertune_supported != 0)
12983 {
12984 // powertune set
12985 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
12986
12987 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll, data.hm_device[i].adapter_index.amd, &powertune)) != ADL_OK)
12988 {
12989 log_error ("ERROR: Failed to get current ADL PowerControl settings");
12990
12991 return (-1);
12992 }
12993
12994 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll, data.hm_device[i].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
12995 {
12996 log_error ("ERROR: Failed to set new ADL PowerControl values");
12997
12998 return (-1);
12999 }
13000 }
13001 }
13002 }
13003
13004 hc_thread_mutex_unlock (mux_adl);
13005 }
13006 }
13007
13008 uint kernel_blocks_all = 0;
13009
13010 for (uint device_id = 0; device_id < devices_cnt; device_id++)
13011 {
13012 /**
13013 * host buffer
13014 */
13015
13016 hc_device_param_t *device_param = &data.devices_param[device_id];
13017
13018 /**
13019 * device properties
13020 */
13021
13022 char *device_name_chksum = device_param->device_name_chksum;
13023
13024 uint device_processors = device_param->device_processors;
13025
13026 uint device_processor_cores = device_param->device_processor_cores;
13027
13028 cl_device_type device_type = device_param->device_type;
13029
13030 /**
13031 * create context for each device
13032 */
13033
13034 device_param->context = hc_clCreateContext (NULL, 1, &device_param->device, NULL, NULL);
13035
13036 /**
13037 * create command-queue
13038 */
13039
13040 // not support with NV
13041 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13042
13043 device_param->command_queue = hc_clCreateCommandQueue (device_param->context, device_param->device, 0);
13044
13045 /**
13046 * create input buffers on device
13047 */
13048
13049 uint kernel_threads = KERNEL_THREADS;
13050
13051 // bcrypt
13052 if (hash_mode == 3200) kernel_threads = 8;
13053 if (hash_mode == 9000) kernel_threads = 8;
13054
13055 if (device_type & CL_DEVICE_TYPE_CPU)
13056 {
13057 // CPU still need lots of workitems, don't know why...
13058 // for testing phase, lets start with this
13059
13060 kernel_accel = 1;
13061 }
13062
13063 uint kernel_power = device_processors * kernel_threads * kernel_accel;
13064 uint kernel_blocks = kernel_power;
13065
13066 device_param->kernel_threads = kernel_threads;
13067 device_param->kernel_power_user = kernel_power;
13068 device_param->kernel_blocks_user = kernel_blocks;
13069
13070 kernel_blocks_all += kernel_blocks;
13071
13072 uint size_pws = kernel_power * sizeof (pw_t);
13073
13074 uint size_tmps = 4;
13075
13076 switch (hash_mode)
13077 {
13078 case 400: size_tmps = kernel_blocks * sizeof (phpass_tmp_t); break;
13079 case 500: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13080 case 501: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13081 case 1600: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13082 case 1800: size_tmps = kernel_blocks * sizeof (sha512crypt_tmp_t); break;
13083 case 2100: size_tmps = kernel_blocks * sizeof (dcc2_tmp_t); break;
13084 case 2500: size_tmps = kernel_blocks * sizeof (wpa_tmp_t); break;
13085 case 3200: size_tmps = kernel_blocks * sizeof (bcrypt_tmp_t); break;
13086 case 5200: size_tmps = kernel_blocks * sizeof (pwsafe3_tmp_t); break;
13087 case 5800: size_tmps = kernel_blocks * sizeof (androidpin_tmp_t); break;
13088 case 6211:
13089 case 6212:
13090 case 6213: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13091 case 6221:
13092 case 6222:
13093 case 6223: size_tmps = kernel_blocks * sizeof (tc64_tmp_t); break;
13094 case 6231:
13095 case 6232:
13096 case 6233: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13097 case 6241:
13098 case 6242:
13099 case 6243: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13100 case 6300: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13101 case 6400: size_tmps = kernel_blocks * sizeof (sha256aix_tmp_t); break;
13102 case 6500: size_tmps = kernel_blocks * sizeof (sha512aix_tmp_t); break;
13103 case 6600: size_tmps = kernel_blocks * sizeof (agilekey_tmp_t); break;
13104 case 6700: size_tmps = kernel_blocks * sizeof (sha1aix_tmp_t); break;
13105 case 6800: size_tmps = kernel_blocks * sizeof (lastpass_tmp_t); break;
13106 case 7100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13107 case 7200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13108 case 7400: size_tmps = kernel_blocks * sizeof (sha256crypt_tmp_t); break;
13109 case 7900: size_tmps = kernel_blocks * sizeof (drupal7_tmp_t); break;
13110 case 8200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13111 case 8800: size_tmps = kernel_blocks * sizeof (androidfde_tmp_t); break;
13112 case 8900: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13113 case 9000: size_tmps = kernel_blocks * sizeof (pwsafe2_tmp_t); break;
13114 case 9100: size_tmps = kernel_blocks * sizeof (lotus8_tmp_t); break;
13115 case 9200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13116 case 9300: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13117 case 9400: size_tmps = kernel_blocks * sizeof (office2007_tmp_t); break;
13118 case 9500: size_tmps = kernel_blocks * sizeof (office2010_tmp_t); break;
13119 case 9600: size_tmps = kernel_blocks * sizeof (office2013_tmp_t); break;
13120 case 10000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13121 case 10200: size_tmps = kernel_blocks * sizeof (cram_md5_t); break;
13122 case 10300: size_tmps = kernel_blocks * sizeof (saph_sha1_tmp_t); break;
13123 case 10500: size_tmps = kernel_blocks * sizeof (pdf14_tmp_t); break;
13124 case 10700: size_tmps = kernel_blocks * sizeof (pdf17l8_tmp_t); break;
13125 case 10900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13126 case 11300: size_tmps = kernel_blocks * sizeof (bitcoin_wallet_tmp_t); break;
13127 case 11600: size_tmps = kernel_blocks * sizeof (seven_zip_tmp_t); break;
13128 case 11900: size_tmps = kernel_blocks * sizeof (pbkdf2_md5_tmp_t); break;
13129 case 12000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha1_tmp_t); break;
13130 case 12100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13131 case 12200: size_tmps = kernel_blocks * sizeof (ecryptfs_tmp_t); break;
13132 case 12300: size_tmps = kernel_blocks * sizeof (oraclet_tmp_t); break;
13133 case 12400: size_tmps = kernel_blocks * sizeof (bsdicrypt_tmp_t); break;
13134 case 12500: size_tmps = kernel_blocks * sizeof (rar3_tmp_t); break;
13135 case 12700: size_tmps = kernel_blocks * sizeof (mywallet_tmp_t); break;
13136 case 12800: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13137 case 12900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13138 case 13000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13139 };
13140
13141 uint size_hooks = 4;
13142
13143 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13144 {
13145 // insert correct hook size
13146 }
13147
13148 // we can optimize some stuff here...
13149
13150 device_param->size_pws = size_pws;
13151 device_param->size_tmps = size_tmps;
13152 device_param->size_hooks = size_hooks;
13153
13154 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13155 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13156
13157 device_param->size_root_css = size_root_css;
13158 device_param->size_markov_css = size_markov_css;
13159
13160 uint size_results = KERNEL_THREADS * sizeof (uint);
13161
13162 device_param->size_results = size_results;
13163
13164 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13165 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13166
13167 uint size_plains = digests_cnt * sizeof (plain_t);
13168 uint size_salts = salts_cnt * sizeof (salt_t);
13169 uint size_esalts = salts_cnt * esalt_size;
13170
13171 device_param->size_plains = size_plains;
13172 device_param->size_digests = size_digests;
13173 device_param->size_shown = size_shown;
13174 device_param->size_salts = size_salts;
13175
13176 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13177 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13178 uint size_tm = 32 * sizeof (bs_word_t);
13179
13180 uint64_t size_scryptV = 1;
13181
13182 if ((hash_mode == 8900) || (hash_mode == 9300))
13183 {
13184 uint tmto_start = 0;
13185 uint tmto_stop = 10;
13186
13187 if (scrypt_tmto)
13188 {
13189 tmto_start = scrypt_tmto;
13190 }
13191 else
13192 {
13193 // in case the user did not specify the tmto manually
13194 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13195 // but set the lower end only in case the user has a device with too less memory
13196
13197 if (hash_mode == 8900)
13198 {
13199 if (vendor_id == VENDOR_ID_AMD)
13200 {
13201 tmto_start = 1;
13202 }
13203 else if (vendor_id == VENDOR_ID_NV)
13204 {
13205 tmto_start = 3;
13206 }
13207 }
13208 else if (hash_mode == 9300)
13209 {
13210 if (vendor_id == VENDOR_ID_AMD)
13211 {
13212 tmto_start = 3;
13213 }
13214 else if (vendor_id == VENDOR_ID_NV)
13215 {
13216 tmto_start = 5;
13217 }
13218 }
13219 }
13220
13221 if (quiet == 0) log_info ("");
13222
13223 uint shader_per_mp = 1;
13224
13225 if (vendor_id == VENDOR_ID_AMD)
13226 {
13227 shader_per_mp = 8;
13228 }
13229
13230 if (vendor_id == VENDOR_ID_NV)
13231 {
13232 shader_per_mp = 32;
13233 }
13234
13235 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13236 {
13237 // TODO: in theory the following calculation needs to be done per salt, not global
13238 // we assume all hashes have the same scrypt settings
13239
13240 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13241
13242 size_scryptV /= 1 << tmto;
13243
13244 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13245
13246 if (size_scryptV > device_param->device_maxmem_alloc)
13247 {
13248 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13249
13250 continue;
13251 }
13252
13253 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13254 {
13255 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13256 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13257 }
13258
13259 break;
13260 }
13261
13262 if (data.salts_buf[0].scrypt_phy == 0)
13263 {
13264 log_error ("ERROR: can't allocate enough device memory");
13265
13266 return -1;
13267 }
13268
13269 if (quiet == 0) log_info ("");
13270 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13271 }
13272
13273 /**
13274 * default building options
13275 */
13276
13277 char build_opts[1024];
13278
13279 // we don't have sm_* on AMD but it doesn't matter
13280
13281 sprintf (build_opts, "-I%s/ -DVENDOR_ID=%d -DCUDA_ARCH=%d", shared_dir, vendor_id, (device_param->sm_major * 100) + device_param->sm_minor);
13282
13283 /**
13284 * main kernel
13285 */
13286
13287 {
13288 /**
13289 * kernel source filename
13290 */
13291
13292 char source_file[256];
13293
13294 memset (source_file, 0, sizeof (source_file));
13295
13296 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13297
13298 struct stat sst;
13299
13300 if (stat (source_file, &sst) == -1)
13301 {
13302 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13303
13304 return -1;
13305 }
13306
13307 /**
13308 * kernel cached filename
13309 */
13310
13311 char cached_file[256];
13312
13313 memset (cached_file, 0, sizeof (cached_file));
13314
13315 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, vendor_id, cached_file);
13316
13317 int cached = 1;
13318
13319 struct stat cst;
13320
13321 if (stat (cached_file, &cst) == -1)
13322 {
13323 cached = 0;
13324 }
13325
13326 /**
13327 * kernel compile or load
13328 */
13329
13330 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13331
13332 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13333
13334 if (force_jit_compilation == 0)
13335 {
13336 if (cached == 0)
13337 {
13338 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13339
13340 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13341
13342 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13343
13344 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13345
13346 size_t binary_size;
13347
13348 clGetProgramInfo (device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13349
13350 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13351
13352 clGetProgramInfo (device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13353
13354 writeProgramBin (cached_file, binary, binary_size);
13355
13356 local_free (binary);
13357 }
13358 else
13359 {
13360 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13361
13362 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13363
13364 device_param->program = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13365
13366 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13367 }
13368 }
13369 else
13370 {
13371 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13372
13373 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13374
13375 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13376
13377 if (force_jit_compilation == 1500)
13378 {
13379 sprintf (build_opts, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13380 }
13381 else if (force_jit_compilation == 8900)
13382 {
13383 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);
13384 }
13385
13386 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13387 }
13388
13389 local_free (kernel_lengths);
13390 local_free (kernel_sources[0]);
13391 local_free (kernel_sources);
13392
13393 // this is mostly for debug
13394
13395 size_t ret_val_size = 0;
13396
13397 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13398
13399 if (ret_val_size > 2)
13400 {
13401 char *build_log = (char *) mymalloc (ret_val_size + 1);
13402
13403 memset (build_log, 0, ret_val_size + 1);
13404
13405 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13406
13407 puts (build_log);
13408
13409 myfree (build_log);
13410 }
13411 }
13412
13413 /**
13414 * word generator kernel
13415 */
13416
13417 if (attack_mode != ATTACK_MODE_STRAIGHT)
13418 {
13419 /**
13420 * kernel mp source filename
13421 */
13422
13423 char source_file[256];
13424
13425 memset (source_file, 0, sizeof (source_file));
13426
13427 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
13428
13429 struct stat sst;
13430
13431 if (stat (source_file, &sst) == -1)
13432 {
13433 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13434
13435 return -1;
13436 }
13437
13438 /**
13439 * kernel mp cached filename
13440 */
13441
13442 char cached_file[256];
13443
13444 memset (cached_file, 0, sizeof (cached_file));
13445
13446 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, vendor_id, cached_file);
13447
13448 int cached = 1;
13449
13450 struct stat cst;
13451
13452 if (stat (cached_file, &cst) == -1)
13453 {
13454 cached = 0;
13455 }
13456
13457 /**
13458 * kernel compile or load
13459 */
13460
13461 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13462
13463 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13464
13465 if (cached == 0)
13466 {
13467 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13468
13469 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13470
13471 device_param->program_mp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13472
13473 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13474
13475 size_t binary_size;
13476
13477 clGetProgramInfo (device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13478
13479 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13480
13481 clGetProgramInfo (device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13482
13483 writeProgramBin (cached_file, binary, binary_size);
13484
13485 local_free (binary);
13486 }
13487 else
13488 {
13489 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13490
13491 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13492
13493 device_param->program_mp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13494
13495 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13496 }
13497
13498 local_free (kernel_lengths);
13499 local_free (kernel_sources[0]);
13500 local_free (kernel_sources);
13501
13502 // this is mostly for debug
13503
13504 size_t ret_val_size = 0;
13505
13506 clGetProgramBuildInfo (device_param->program_mp, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13507
13508 if (ret_val_size > 2)
13509 {
13510 char *build_log = (char *) mymalloc (ret_val_size + 1);
13511
13512 memset (build_log, 0, ret_val_size + 1);
13513
13514 clGetProgramBuildInfo (device_param->program_mp, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13515
13516 puts (build_log);
13517
13518 myfree (build_log);
13519 }
13520 }
13521
13522 /**
13523 * amplifier kernel
13524 */
13525
13526 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13527 {
13528
13529 }
13530 else
13531 {
13532 /**
13533 * kernel amp source filename
13534 */
13535
13536 char source_file[256];
13537
13538 memset (source_file, 0, sizeof (source_file));
13539
13540 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
13541
13542 struct stat sst;
13543
13544 if (stat (source_file, &sst) == -1)
13545 {
13546 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13547
13548 return -1;
13549 }
13550
13551 /**
13552 * kernel amp cached filename
13553 */
13554
13555 char cached_file[256];
13556
13557 memset (cached_file, 0, sizeof (cached_file));
13558
13559 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, vendor_id, cached_file);
13560
13561 int cached = 1;
13562
13563 struct stat cst;
13564
13565 if (stat (cached_file, &cst) == -1)
13566 {
13567 cached = 0;
13568 }
13569
13570 /**
13571 * kernel compile or load
13572 */
13573
13574 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13575
13576 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13577
13578 if (cached == 0)
13579 {
13580 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13581
13582 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13583
13584 device_param->program_amp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13585
13586 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13587
13588 size_t binary_size;
13589
13590 clGetProgramInfo (device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13591
13592 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13593
13594 clGetProgramInfo (device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13595
13596 writeProgramBin (cached_file, binary, binary_size);
13597
13598 local_free (binary);
13599 }
13600 else
13601 {
13602 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13603
13604 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13605
13606 device_param->program_amp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13607
13608 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13609 }
13610
13611 local_free (kernel_lengths);
13612 local_free (kernel_sources[0]);
13613 local_free (kernel_sources);
13614
13615 // this is mostly for debug
13616
13617 size_t ret_val_size = 0;
13618
13619 clGetProgramBuildInfo (device_param->program_amp, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13620
13621 if (ret_val_size > 2)
13622 {
13623 char *build_log = (char *) mymalloc (ret_val_size + 1);
13624
13625 memset (build_log, 0, ret_val_size + 1);
13626
13627 clGetProgramBuildInfo (device_param->program_amp, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13628
13629 puts (build_log);
13630
13631 myfree (build_log);
13632 }
13633 }
13634
13635 /**
13636 * global buffers
13637 */
13638
13639 device_param->d_pws_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13640 device_param->d_pws_amp_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13641 device_param->d_tmps = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
13642 device_param->d_hooks = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
13643 device_param->d_bitmap_s1_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13644 device_param->d_bitmap_s1_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13645 device_param->d_bitmap_s1_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13646 device_param->d_bitmap_s1_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13647 device_param->d_bitmap_s2_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13648 device_param->d_bitmap_s2_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13649 device_param->d_bitmap_s2_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13650 device_param->d_bitmap_s2_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13651 device_param->d_plain_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
13652 device_param->d_digests_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
13653 device_param->d_digests_shown = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
13654 device_param->d_salt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
13655 device_param->d_result = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
13656 device_param->d_scryptV_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
13657
13658 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_a, CL_TRUE, 0, bitmap_size, bitmap_s1_a, 0, NULL, NULL);
13659 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_b, CL_TRUE, 0, bitmap_size, bitmap_s1_b, 0, NULL, NULL);
13660 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_c, CL_TRUE, 0, bitmap_size, bitmap_s1_c, 0, NULL, NULL);
13661 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_d, CL_TRUE, 0, bitmap_size, bitmap_s1_d, 0, NULL, NULL);
13662 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_a, CL_TRUE, 0, bitmap_size, bitmap_s2_a, 0, NULL, NULL);
13663 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_b, CL_TRUE, 0, bitmap_size, bitmap_s2_b, 0, NULL, NULL);
13664 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_c, CL_TRUE, 0, bitmap_size, bitmap_s2_c, 0, NULL, NULL);
13665 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_d, CL_TRUE, 0, bitmap_size, bitmap_s2_d, 0, NULL, NULL);
13666 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
13667 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
13668 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
13669
13670 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
13671 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
13672 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
13673 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
13674 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
13675 run_kernel_bzero (device_param, device_param->d_result, size_results);
13676
13677 /**
13678 * special buffers
13679 */
13680
13681 if (attack_kern == ATTACK_KERN_STRAIGHT)
13682 {
13683 device_param->d_rules = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
13684 device_param->d_rules_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
13685
13686 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
13687
13688 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
13689 }
13690 else if (attack_kern == ATTACK_KERN_COMBI)
13691 {
13692 device_param->d_combs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13693 device_param->d_combs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13694 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13695 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13696
13697 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
13698 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
13699 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13700 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13701 }
13702 else if (attack_kern == ATTACK_KERN_BF)
13703 {
13704 device_param->d_bfs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13705 device_param->d_bfs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13706 device_param->d_tm_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
13707 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13708 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13709
13710 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
13711 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
13712 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
13713 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13714 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13715 }
13716
13717 if (size_esalts)
13718 {
13719 device_param->d_esalt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
13720
13721 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
13722 }
13723
13724 /**
13725 * main host data
13726 */
13727
13728 uint *result = (uint *) mymalloc (size_results);
13729
13730 memset (result, 0, size_results);
13731
13732 device_param->result = result;
13733
13734 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
13735
13736 memset (pws_buf, 0, size_pws);
13737
13738 device_param->pws_buf = pws_buf;
13739
13740 pw_cache_t *pw_caches = (pw_cache_t *) mycalloc (64, sizeof (pw_cache_t));
13741
13742 for (int i = 0; i < 64; i++)
13743 {
13744 pw_caches[i].pw_buf.pw_len = i;
13745 pw_caches[i].cnt = 0;
13746 }
13747
13748 device_param->pw_caches = pw_caches;
13749
13750 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
13751
13752 device_param->combs_buf = combs_buf;
13753
13754 void *hooks_buf = mymalloc (size_hooks);
13755
13756 device_param->hooks_buf = hooks_buf;
13757
13758 device_param->pw_transpose = pw_transpose_to_hi1;
13759 device_param->pw_add = pw_add_to_hc1;
13760
13761 /**
13762 * kernel args
13763 */
13764
13765 device_param->kernel_params_buf32[21] = bitmap_mask;
13766 device_param->kernel_params_buf32[22] = bitmap_shift1;
13767 device_param->kernel_params_buf32[23] = bitmap_shift2;
13768 device_param->kernel_params_buf32[24] = 0; // salt_pos
13769 device_param->kernel_params_buf32[25] = 0; // loop_pos
13770 device_param->kernel_params_buf32[26] = 0; // loop_cnt
13771 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
13772 device_param->kernel_params_buf32[28] = 0; // digests_cnt
13773 device_param->kernel_params_buf32[29] = 0; // digests_offset
13774 device_param->kernel_params_buf32[30] = 0; // combs_mode
13775 device_param->kernel_params_buf32[31] = 0; // gid_max
13776
13777 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13778 ? &device_param->d_pws_buf
13779 : &device_param->d_pws_amp_buf;
13780 device_param->kernel_params[ 1] = &device_param->d_rules_c;
13781 device_param->kernel_params[ 2] = &device_param->d_combs_c;
13782 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
13783 device_param->kernel_params[ 4] = &device_param->d_tmps;
13784 device_param->kernel_params[ 5] = &device_param->d_hooks;
13785 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
13786 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
13787 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
13788 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
13789 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
13790 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
13791 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
13792 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
13793 device_param->kernel_params[14] = &device_param->d_plain_bufs;
13794 device_param->kernel_params[15] = &device_param->d_digests_buf;
13795 device_param->kernel_params[16] = &device_param->d_digests_shown;
13796 device_param->kernel_params[17] = &device_param->d_salt_bufs;
13797 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
13798 device_param->kernel_params[19] = &device_param->d_result;
13799 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
13800 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
13801 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
13802 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
13803 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
13804 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
13805 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
13806 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
13807 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
13808 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
13809 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
13810 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
13811
13812 device_param->kernel_params_mp_buf64[3] = 0;
13813 device_param->kernel_params_mp_buf32[4] = 0;
13814 device_param->kernel_params_mp_buf32[5] = 0;
13815 device_param->kernel_params_mp_buf32[6] = 0;
13816 device_param->kernel_params_mp_buf32[7] = 0;
13817 device_param->kernel_params_mp_buf32[8] = 0;
13818
13819 device_param->kernel_params_mp[0] = NULL;
13820 device_param->kernel_params_mp[1] = NULL;
13821 device_param->kernel_params_mp[2] = NULL;
13822 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
13823 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
13824 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
13825 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
13826 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
13827 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
13828
13829 device_param->kernel_params_mp_l_buf64[3] = 0;
13830 device_param->kernel_params_mp_l_buf32[4] = 0;
13831 device_param->kernel_params_mp_l_buf32[5] = 0;
13832 device_param->kernel_params_mp_l_buf32[6] = 0;
13833 device_param->kernel_params_mp_l_buf32[7] = 0;
13834 device_param->kernel_params_mp_l_buf32[8] = 0;
13835 device_param->kernel_params_mp_l_buf32[9] = 0;
13836
13837 device_param->kernel_params_mp_l[0] = NULL;
13838 device_param->kernel_params_mp_l[1] = NULL;
13839 device_param->kernel_params_mp_l[2] = NULL;
13840 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
13841 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
13842 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
13843 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
13844 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
13845 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
13846 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
13847
13848 device_param->kernel_params_mp_r_buf64[3] = 0;
13849 device_param->kernel_params_mp_r_buf32[4] = 0;
13850 device_param->kernel_params_mp_r_buf32[5] = 0;
13851 device_param->kernel_params_mp_r_buf32[6] = 0;
13852 device_param->kernel_params_mp_r_buf32[7] = 0;
13853 device_param->kernel_params_mp_r_buf32[8] = 0;
13854
13855 device_param->kernel_params_mp_r[0] = NULL;
13856 device_param->kernel_params_mp_r[1] = NULL;
13857 device_param->kernel_params_mp_r[2] = NULL;
13858 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
13859 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
13860 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
13861 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
13862 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
13863 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
13864
13865 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
13866 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
13867
13868 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
13869 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
13870 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
13871 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
13872 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
13873 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
13874 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
13875
13876 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
13877
13878 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
13879 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
13880
13881 /**
13882 * kernel name
13883 */
13884
13885 char kernel_name[64];
13886
13887 memset (kernel_name, 0, sizeof (kernel_name));
13888
13889 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13890 {
13891 if (opti_type & OPTI_TYPE_SINGLE_HASH)
13892 {
13893 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
13894
13895 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
13896
13897 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
13898
13899 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
13900
13901 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
13902
13903 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
13904 }
13905 else
13906 {
13907 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
13908
13909 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
13910
13911 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
13912
13913 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
13914
13915 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
13916
13917 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
13918 }
13919
13920 if (data.attack_mode == ATTACK_MODE_BF)
13921 {
13922 if (opts_type & OPTS_TYPE_PT_BITSLICE)
13923 {
13924 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
13925
13926 device_param->kernel_tb = hc_clCreateKernel (device_param->program, kernel_name);
13927
13928 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
13929
13930 device_param->kernel_tm = hc_clCreateKernel (device_param->program, kernel_name);
13931 }
13932 }
13933 }
13934 else
13935 {
13936 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
13937
13938 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
13939
13940 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
13941
13942 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
13943
13944 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
13945
13946 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
13947
13948 if (opts_type & OPTS_TYPE_HOOK12)
13949 {
13950 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
13951
13952 device_param->kernel12 = hc_clCreateKernel (device_param->program, kernel_name);
13953 }
13954
13955 if (opts_type & OPTS_TYPE_HOOK23)
13956 {
13957 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
13958
13959 device_param->kernel23 = hc_clCreateKernel (device_param->program, kernel_name);
13960 }
13961 }
13962
13963 for (uint i = 0; i <= 20; i++)
13964 {
13965 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
13966 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
13967 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
13968
13969 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
13970 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
13971 }
13972
13973 for (uint i = 21; i <= 31; i++)
13974 {
13975 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
13976 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
13977 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
13978
13979 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
13980 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
13981 }
13982
13983 if (attack_mode == ATTACK_MODE_BF)
13984 {
13985 device_param->kernel_mp_l = hc_clCreateKernel (device_param->program_mp, "l_markov");
13986 device_param->kernel_mp_r = hc_clCreateKernel (device_param->program_mp, "r_markov");
13987
13988 if (opts_type & OPTS_TYPE_PT_BITSLICE)
13989 {
13990 hc_clSetKernelArg (device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
13991
13992 hc_clSetKernelArg (device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
13993 hc_clSetKernelArg (device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
13994 }
13995 }
13996 else if (attack_mode == ATTACK_MODE_HYBRID1)
13997 {
13998 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
13999 }
14000 else if (attack_mode == ATTACK_MODE_HYBRID2)
14001 {
14002 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
14003 }
14004
14005 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14006 {
14007 // nothing to do
14008 }
14009 else
14010 {
14011 device_param->kernel_amp = hc_clCreateKernel (device_param->program_amp, "amp");
14012 }
14013
14014 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14015 {
14016 // nothing to do
14017 }
14018 else
14019 {
14020 for (uint i = 0; i < 5; i++)
14021 {
14022 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14023 }
14024
14025 for (uint i = 5; i < 7; i++)
14026 {
14027 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14028 }
14029 }
14030
14031 /**
14032 * Store initial fanspeed if gpu_temp_retain is enabled
14033 */
14034
14035 int gpu_temp_retain_set = 0;
14036
14037 if (gpu_temp_disable == 0)
14038 {
14039 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14040 {
14041 hc_thread_mutex_lock (mux_adl);
14042
14043 if (data.hm_device[device_id].fan_supported == 1)
14044 {
14045 if (gpu_temp_retain_chgd == 0)
14046 {
14047 uint cur_temp = 0;
14048 uint default_temp = 0;
14049
14050 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);
14051
14052 if (ADL_rc == ADL_OK)
14053 {
14054 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14055
14056 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14057
14058 // special case with multi gpu setups: always use minimum retain
14059
14060 if (gpu_temp_retain_set == 0)
14061 {
14062 gpu_temp_retain = gpu_temp_retain_target;
14063 gpu_temp_retain_set = 1;
14064 }
14065 else
14066 {
14067 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14068 }
14069
14070 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14071 }
14072 }
14073
14074 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14075
14076 temp_retain_fanspeed_value[device_id] = fan_speed;
14077
14078 if (fan_speed == -1)
14079 {
14080 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14081
14082 temp_retain_fanspeed_value[device_id] = 0;
14083 }
14084 }
14085
14086 hc_thread_mutex_unlock (mux_adl);
14087 }
14088 }
14089
14090 /**
14091 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14092 */
14093
14094 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14095 {
14096 hc_thread_mutex_lock (mux_adl);
14097
14098 if (data.hm_device[device_id].od_version == 6)
14099 {
14100 int ADL_rc;
14101
14102 // check powertune capabilities first, if not available then skip device
14103
14104 int powertune_supported = 0;
14105
14106 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14107 {
14108 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14109
14110 return (-1);
14111 }
14112
14113 if (powertune_supported != 0)
14114 {
14115 // powercontrol settings
14116
14117 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14118
14119 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14120 {
14121 ADL_rc = hc_ADL_Overdrive_PowerControl_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14122 }
14123
14124 if (ADL_rc != ADL_OK)
14125 {
14126 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14127
14128 return (-1);
14129 }
14130
14131 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14132 {
14133 log_error ("ERROR: Failed to set new ADL PowerControl values");
14134
14135 return (-1);
14136 }
14137
14138 // clocks
14139
14140 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14141
14142 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14143
14144 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)
14145 {
14146 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14147
14148 return (-1);
14149 }
14150
14151 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14152
14153 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14154
14155 if ((ADL_rc = hc_ADL_Overdrive_Capabilities_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14156 {
14157 log_error ("ERROR: Failed to get ADL device capabilities");
14158
14159 return (-1);
14160 }
14161
14162 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14163 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14164
14165 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14166 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14167
14168 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14169 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14170
14171 // warning if profile has to low max values
14172
14173 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14174 {
14175 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14176 }
14177
14178 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14179 {
14180 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14181 }
14182
14183 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14184
14185 performance_state->iNumberOfPerformanceLevels = 2;
14186
14187 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14188 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14189 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14190 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14191
14192 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)
14193 {
14194 log_info ("ERROR: Failed to set ADL performance state");
14195
14196 return (-1);
14197 }
14198
14199 local_free (performance_state);
14200 }
14201 }
14202
14203 hc_thread_mutex_unlock (mux_adl);
14204 }
14205 }
14206
14207 data.kernel_blocks_all = kernel_blocks_all;
14208
14209 if (data.quiet == 0) log_info ("");
14210
14211 /**
14212 * Inform user which algorithm is checked and at which workload setting
14213 */
14214
14215 if (benchmark == 1)
14216 {
14217 quiet = 0;
14218
14219 data.quiet = quiet;
14220
14221 char *hash_type = strhashtype (data.hash_mode); // not a bug
14222
14223 log_info ("Hashtype: %s", hash_type);
14224 log_info ("Workload: %u loops, %u accel", kernel_loops, kernel_accel);
14225 log_info ("");
14226 }
14227
14228 /**
14229 * keep track of the progress
14230 */
14231
14232 data.words_progress_done = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
14233 data.words_progress_rejected = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
14234 data.words_progress_restored = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
14235
14236 /**
14237 * open filehandles
14238 */
14239
14240 #if _WIN
14241 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14242 {
14243 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14244
14245 return (-1);
14246 }
14247
14248 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14249 {
14250 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14251
14252 return (-1);
14253 }
14254
14255 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14256 {
14257 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14258
14259 return (-1);
14260 }
14261 #endif
14262
14263 /**
14264 * dictionary pad
14265 */
14266
14267 segment_size *= (1024 * 1024);
14268
14269 data.segment_size = segment_size;
14270
14271 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14272
14273 wl_data->buf = (char *) mymalloc (segment_size);
14274 wl_data->avail = segment_size;
14275 wl_data->incr = segment_size;
14276 wl_data->cnt = 0;
14277 wl_data->pos = 0;
14278
14279 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14280
14281 data.wordlist_mode = wordlist_mode;
14282
14283 cs_t *css_buf = NULL;
14284 uint css_cnt = 0;
14285 uint dictcnt = 0;
14286 uint maskcnt = 1;
14287 char **masks = NULL;
14288 char **dictfiles = NULL;
14289
14290 uint mask_from_file = 0;
14291
14292 if (attack_mode == ATTACK_MODE_STRAIGHT)
14293 {
14294 if (wordlist_mode == WL_MODE_FILE)
14295 {
14296 int wls_left = myargc - (optind + 1);
14297
14298 for (int i = 0; i < wls_left; i++)
14299 {
14300 char *l0_filename = myargv[optind + 1 + i];
14301
14302 struct stat l0_stat;
14303
14304 if (stat (l0_filename, &l0_stat) == -1)
14305 {
14306 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14307
14308 return (-1);
14309 }
14310
14311 uint is_dir = S_ISDIR (l0_stat.st_mode);
14312
14313 if (is_dir == 0)
14314 {
14315 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14316
14317 dictcnt++;
14318
14319 dictfiles[dictcnt - 1] = l0_filename;
14320 }
14321 else
14322 {
14323 // do not allow --keyspace w/ a directory
14324
14325 if (keyspace == 1)
14326 {
14327 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14328
14329 return (-1);
14330 }
14331
14332 char **dictionary_files = NULL;
14333
14334 dictionary_files = scan_directory (l0_filename);
14335
14336 if (dictionary_files != NULL)
14337 {
14338 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14339
14340 for (int d = 0; dictionary_files[d] != NULL; d++)
14341 {
14342 char *l1_filename = dictionary_files[d];
14343
14344 struct stat l1_stat;
14345
14346 if (stat (l1_filename, &l1_stat) == -1)
14347 {
14348 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14349
14350 return (-1);
14351 }
14352
14353 if (S_ISREG (l1_stat.st_mode))
14354 {
14355 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14356
14357 dictcnt++;
14358
14359 dictfiles[dictcnt - 1] = strdup (l1_filename);
14360 }
14361 }
14362 }
14363
14364 local_free (dictionary_files);
14365 }
14366 }
14367
14368 if (dictcnt < 1)
14369 {
14370 log_error ("ERROR: No usable dictionary file found.");
14371
14372 return (-1);
14373 }
14374 }
14375 else if (wordlist_mode == WL_MODE_STDIN)
14376 {
14377 dictcnt = 1;
14378 }
14379 }
14380 else if (attack_mode == ATTACK_MODE_COMBI)
14381 {
14382 // display
14383
14384 char *dictfile1 = myargv[optind + 1 + 0];
14385 char *dictfile2 = myargv[optind + 1 + 1];
14386
14387 // find the bigger dictionary and use as base
14388
14389 FILE *fp1;
14390 FILE *fp2;
14391
14392 struct stat tmp_stat;
14393
14394 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14395 {
14396 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14397
14398 return (-1);
14399 }
14400
14401 if (stat (dictfile1, &tmp_stat) == -1)
14402 {
14403 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14404
14405 fclose (fp1);
14406
14407 return (-1);
14408 }
14409
14410 if (S_ISDIR (tmp_stat.st_mode))
14411 {
14412 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14413
14414 fclose (fp1);
14415
14416 return (-1);
14417 }
14418
14419 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14420 {
14421 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14422
14423 fclose (fp1);
14424
14425 return (-1);
14426 }
14427
14428 if (stat (dictfile2, &tmp_stat) == -1)
14429 {
14430 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14431
14432 fclose (fp1);
14433 fclose (fp2);
14434
14435 return (-1);
14436 }
14437
14438 if (S_ISDIR (tmp_stat.st_mode))
14439 {
14440 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14441
14442 fclose (fp1);
14443 fclose (fp2);
14444
14445 return (-1);
14446 }
14447
14448 data.combs_cnt = 1;
14449
14450 data.quiet = 1;
14451
14452 const uint64_t words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14453
14454 data.quiet = quiet;
14455
14456 if (words1_cnt == 0)
14457 {
14458 log_error ("ERROR: %s: empty file", dictfile1);
14459
14460 fclose (fp1);
14461 fclose (fp2);
14462
14463 return (-1);
14464 }
14465
14466 data.combs_cnt = 1;
14467
14468 data.quiet = 1;
14469
14470 const uint64_t words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14471
14472 data.quiet = quiet;
14473
14474 if (words2_cnt == 0)
14475 {
14476 log_error ("ERROR: %s: empty file", dictfile2);
14477
14478 fclose (fp1);
14479 fclose (fp2);
14480
14481 return (-1);
14482 }
14483
14484 fclose (fp1);
14485 fclose (fp2);
14486
14487 data.dictfile = dictfile1;
14488 data.dictfile2 = dictfile2;
14489
14490 if (words1_cnt >= words2_cnt)
14491 {
14492 data.combs_cnt = words2_cnt;
14493 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14494
14495 dictfiles = &data.dictfile;
14496
14497 dictcnt = 1;
14498 }
14499 else
14500 {
14501 data.combs_cnt = words1_cnt;
14502 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14503
14504 dictfiles = &data.dictfile2;
14505
14506 dictcnt = 1;
14507
14508 // we also have to switch wordlist related rules!
14509
14510 char *tmpc = data.rule_buf_l;
14511
14512 data.rule_buf_l = data.rule_buf_r;
14513 data.rule_buf_r = tmpc;
14514
14515 int tmpi = data.rule_len_l;
14516
14517 data.rule_len_l = data.rule_len_r;
14518 data.rule_len_r = tmpi;
14519 }
14520 }
14521 else if (attack_mode == ATTACK_MODE_BF)
14522 {
14523 char *mask = NULL;
14524
14525 maskcnt = 0;
14526
14527 if (benchmark == 0)
14528 {
14529 mask = myargv[optind + 1];
14530
14531 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
14532
14533 if ((optind + 2) <= myargc)
14534 {
14535 struct stat file_stat;
14536
14537 if (stat (mask, &file_stat) == -1)
14538 {
14539 maskcnt = 1;
14540
14541 masks[maskcnt - 1] = mystrdup (mask);
14542 }
14543 else
14544 {
14545 int wls_left = myargc - (optind + 1);
14546
14547 uint masks_avail = INCR_MASKS;
14548
14549 for (int i = 0; i < wls_left; i++)
14550 {
14551 if (i != 0)
14552 {
14553 mask = myargv[optind + 1 + i];
14554
14555 if (stat (mask, &file_stat) == -1)
14556 {
14557 log_error ("ERROR: %s: %s", mask, strerror (errno));
14558
14559 return (-1);
14560 }
14561 }
14562
14563 uint is_file = S_ISREG (file_stat.st_mode);
14564
14565 if (is_file == 1)
14566 {
14567 FILE *mask_fp;
14568
14569 if ((mask_fp = fopen (mask, "r")) == NULL)
14570 {
14571 log_error ("ERROR: %s: %s", mask, strerror (errno));
14572
14573 return (-1);
14574 }
14575
14576 char line_buf[BUFSIZ];
14577
14578 while (!feof (mask_fp))
14579 {
14580 memset (line_buf, 0, BUFSIZ);
14581
14582 int line_len = fgetl (mask_fp, line_buf);
14583
14584 if (line_len == 0) continue;
14585
14586 if (line_buf[0] == '#') continue;
14587
14588 if (masks_avail == maskcnt)
14589 {
14590 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14591
14592 masks_avail += INCR_MASKS;
14593 }
14594
14595 masks[maskcnt] = mystrdup (line_buf);
14596
14597 maskcnt++;
14598 }
14599
14600 fclose (mask_fp);
14601 }
14602 else
14603 {
14604 log_error ("ERROR: %s: unsupported file-type", mask);
14605
14606 return (-1);
14607 }
14608 }
14609
14610 mask_from_file = 1;
14611 }
14612 }
14613 else
14614 {
14615 custom_charset_1 = (char *) "?l?d?u";
14616 custom_charset_2 = (char *) "?l?d";
14617 custom_charset_3 = (char *) "?l?d*!$@_";
14618
14619 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
14620 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
14621 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
14622
14623 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
14624
14625 wordlist_mode = WL_MODE_MASK;
14626
14627 data.wordlist_mode = wordlist_mode;
14628
14629 increment = 1;
14630
14631 maskcnt = 1;
14632 }
14633 }
14634 else
14635 {
14636 /**
14637 * generate full masks and charsets
14638 */
14639
14640 masks = (char **) mymalloc (sizeof (char *));
14641
14642 switch (hash_mode)
14643 {
14644 case 1731: pw_min = 5;
14645 pw_max = 5;
14646 mask = mystrdup ("?b?b?b?b?b");
14647 break;
14648 case 12500: pw_min = 5;
14649 pw_max = 5;
14650 mask = mystrdup ("?b?b?b?b?b");
14651 break;
14652 default: pw_min = 7;
14653 pw_max = 7;
14654 mask = mystrdup ("?b?b?b?b?b?b?b");
14655 break;
14656 }
14657
14658 maskcnt = 1;
14659
14660 masks[maskcnt - 1] = mystrdup (mask);
14661
14662 wordlist_mode = WL_MODE_MASK;
14663
14664 data.wordlist_mode = wordlist_mode;
14665
14666 increment = 1;
14667 }
14668
14669 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
14670
14671 if (increment)
14672 {
14673 if (increment_min > pw_min) pw_min = increment_min;
14674
14675 if (increment_max < pw_max) pw_max = increment_max;
14676 }
14677 }
14678 else if (attack_mode == ATTACK_MODE_HYBRID1)
14679 {
14680 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14681
14682 // display
14683
14684 char *mask = myargv[myargc - 1];
14685
14686 maskcnt = 0;
14687
14688 masks = (char **) mymalloc (1 * sizeof (char *));
14689
14690 // mod
14691
14692 struct stat file_stat;
14693
14694 if (stat (mask, &file_stat) == -1)
14695 {
14696 maskcnt = 1;
14697
14698 masks[maskcnt - 1] = mystrdup (mask);
14699 }
14700 else
14701 {
14702 uint is_file = S_ISREG (file_stat.st_mode);
14703
14704 if (is_file == 1)
14705 {
14706 FILE *mask_fp;
14707
14708 if ((mask_fp = fopen (mask, "r")) == NULL)
14709 {
14710 log_error ("ERROR: %s: %s", mask, strerror (errno));
14711
14712 return (-1);
14713 }
14714
14715 char line_buf[BUFSIZ];
14716
14717 uint masks_avail = 1;
14718
14719 while (!feof (mask_fp))
14720 {
14721 memset (line_buf, 0, BUFSIZ);
14722
14723 int line_len = fgetl (mask_fp, line_buf);
14724
14725 if (line_len == 0) continue;
14726
14727 if (line_buf[0] == '#') continue;
14728
14729 if (masks_avail == maskcnt)
14730 {
14731 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14732
14733 masks_avail += INCR_MASKS;
14734 }
14735
14736 masks[maskcnt] = mystrdup (line_buf);
14737
14738 maskcnt++;
14739 }
14740
14741 fclose (mask_fp);
14742
14743 mask_from_file = 1;
14744 }
14745 else
14746 {
14747 maskcnt = 1;
14748
14749 masks[maskcnt - 1] = mystrdup (mask);
14750 }
14751 }
14752
14753 // base
14754
14755 int wls_left = myargc - (optind + 2);
14756
14757 for (int i = 0; i < wls_left; i++)
14758 {
14759 char *filename = myargv[optind + 1 + i];
14760
14761 struct stat file_stat;
14762
14763 if (stat (filename, &file_stat) == -1)
14764 {
14765 log_error ("ERROR: %s: %s", filename, strerror (errno));
14766
14767 return (-1);
14768 }
14769
14770 uint is_dir = S_ISDIR (file_stat.st_mode);
14771
14772 if (is_dir == 0)
14773 {
14774 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14775
14776 dictcnt++;
14777
14778 dictfiles[dictcnt - 1] = filename;
14779 }
14780 else
14781 {
14782 // do not allow --keyspace w/ a directory
14783
14784 if (keyspace == 1)
14785 {
14786 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14787
14788 return (-1);
14789 }
14790
14791 char **dictionary_files = NULL;
14792
14793 dictionary_files = scan_directory (filename);
14794
14795 if (dictionary_files != NULL)
14796 {
14797 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14798
14799 for (int d = 0; dictionary_files[d] != NULL; d++)
14800 {
14801 char *l1_filename = dictionary_files[d];
14802
14803 struct stat l1_stat;
14804
14805 if (stat (l1_filename, &l1_stat) == -1)
14806 {
14807 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14808
14809 return (-1);
14810 }
14811
14812 if (S_ISREG (l1_stat.st_mode))
14813 {
14814 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14815
14816 dictcnt++;
14817
14818 dictfiles[dictcnt - 1] = strdup (l1_filename);
14819 }
14820 }
14821 }
14822
14823 local_free (dictionary_files);
14824 }
14825 }
14826
14827 if (dictcnt < 1)
14828 {
14829 log_error ("ERROR: No usable dictionary file found.");
14830
14831 return (-1);
14832 }
14833
14834 if (increment)
14835 {
14836 maskcnt = 0;
14837
14838 uint mask_min = increment_min; // we can't reject smaller masks here
14839 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
14840
14841 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
14842 {
14843 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
14844
14845 if (cur_mask == NULL) break;
14846
14847 masks[maskcnt] = cur_mask;
14848
14849 maskcnt++;
14850
14851 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
14852 }
14853 }
14854 }
14855 else if (attack_mode == ATTACK_MODE_HYBRID2)
14856 {
14857 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14858
14859 // display
14860
14861 char *mask = myargv[optind + 1 + 0];
14862
14863 maskcnt = 0;
14864
14865 masks = (char **) mymalloc (1 * sizeof (char *));
14866
14867 // mod
14868
14869 struct stat file_stat;
14870
14871 if (stat (mask, &file_stat) == -1)
14872 {
14873 maskcnt = 1;
14874
14875 masks[maskcnt - 1] = mystrdup (mask);
14876 }
14877 else
14878 {
14879 uint is_file = S_ISREG (file_stat.st_mode);
14880
14881 if (is_file == 1)
14882 {
14883 FILE *mask_fp;
14884
14885 if ((mask_fp = fopen (mask, "r")) == NULL)
14886 {
14887 log_error ("ERROR: %s: %s", mask, strerror (errno));
14888
14889 return (-1);
14890 }
14891
14892 char line_buf[BUFSIZ];
14893
14894 uint masks_avail = 1;
14895
14896 while (!feof (mask_fp))
14897 {
14898 memset (line_buf, 0, BUFSIZ);
14899
14900 int line_len = fgetl (mask_fp, line_buf);
14901
14902 if (line_len == 0) continue;
14903
14904 if (line_buf[0] == '#') continue;
14905
14906 if (masks_avail == maskcnt)
14907 {
14908 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14909
14910 masks_avail += INCR_MASKS;
14911 }
14912
14913 masks[maskcnt] = mystrdup (line_buf);
14914
14915 maskcnt++;
14916 }
14917
14918 fclose (mask_fp);
14919
14920 mask_from_file = 1;
14921 }
14922 else
14923 {
14924 maskcnt = 1;
14925
14926 masks[maskcnt - 1] = mystrdup (mask);
14927 }
14928 }
14929
14930 // base
14931
14932 int wls_left = myargc - (optind + 2);
14933
14934 for (int i = 0; i < wls_left; i++)
14935 {
14936 char *filename = myargv[optind + 2 + i];
14937
14938 struct stat file_stat;
14939
14940 if (stat (filename, &file_stat) == -1)
14941 {
14942 log_error ("ERROR: %s: %s", filename, strerror (errno));
14943
14944 return (-1);
14945 }
14946
14947 uint is_dir = S_ISDIR (file_stat.st_mode);
14948
14949 if (is_dir == 0)
14950 {
14951 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14952
14953 dictcnt++;
14954
14955 dictfiles[dictcnt - 1] = filename;
14956 }
14957 else
14958 {
14959 // do not allow --keyspace w/ a directory
14960
14961 if (keyspace == 1)
14962 {
14963 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14964
14965 return (-1);
14966 }
14967
14968 char **dictionary_files = NULL;
14969
14970 dictionary_files = scan_directory (filename);
14971
14972 if (dictionary_files != NULL)
14973 {
14974 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14975
14976 for (int d = 0; dictionary_files[d] != NULL; d++)
14977 {
14978 char *l1_filename = dictionary_files[d];
14979
14980 struct stat l1_stat;
14981
14982 if (stat (l1_filename, &l1_stat) == -1)
14983 {
14984 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14985
14986 return (-1);
14987 }
14988
14989 if (S_ISREG (l1_stat.st_mode))
14990 {
14991 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14992
14993 dictcnt++;
14994
14995 dictfiles[dictcnt - 1] = strdup (l1_filename);
14996 }
14997 }
14998 }
14999
15000 local_free (dictionary_files);
15001 }
15002 }
15003
15004 if (dictcnt < 1)
15005 {
15006 log_error ("ERROR: No usable dictionary file found.");
15007
15008 return (-1);
15009 }
15010
15011 if (increment)
15012 {
15013 maskcnt = 0;
15014
15015 uint mask_min = increment_min; // we can't reject smaller masks here
15016 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15017
15018 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15019 {
15020 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15021
15022 if (cur_mask == NULL) break;
15023
15024 masks[maskcnt] = cur_mask;
15025
15026 maskcnt++;
15027
15028 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15029 }
15030 }
15031 }
15032
15033 data.pw_min = pw_min;
15034 data.pw_max = pw_max;
15035
15036 /**
15037 * weak hash check
15038 */
15039
15040 if (weak_hash_threshold >= salts_cnt)
15041 {
15042 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15043
15044 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15045 {
15046 weak_hash_check (&data.devices_param[0], salt_pos, kernel_loops);
15047 }
15048 }
15049
15050 // Display hack, guarantee that there is at least one \r before real start
15051
15052 if (data.quiet == 0) log_info_nn ("");
15053
15054 /**
15055 * status and monitor threads
15056 */
15057
15058 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15059
15060 hc_thread_t i_thread = 0;
15061
15062 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15063 {
15064 hc_thread_create (i_thread, thread_keypress, &benchmark);
15065 }
15066
15067 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15068
15069 uint ni_threads_cnt = 0;
15070
15071 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15072
15073 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15074
15075 ni_threads_cnt++;
15076
15077 /**
15078 * Outfile remove
15079 */
15080
15081 if (keyspace == 0)
15082 {
15083 if (outfile_check_timer != 0)
15084 {
15085 if (data.outfile_check_directory != NULL)
15086 {
15087 if ((hash_mode != 5200) &&
15088 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15089 (hash_mode != 9000))
15090 {
15091 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15092
15093 ni_threads_cnt++;
15094 }
15095 else
15096 {
15097 outfile_check_timer = 0;
15098 }
15099 }
15100 else
15101 {
15102 outfile_check_timer = 0;
15103 }
15104 }
15105 }
15106
15107 /**
15108 * Inform the user if we got some hashes remove because of the pot file remove feature
15109 */
15110
15111 if (data.quiet == 0)
15112 {
15113 if (potfile_remove_cracks > 0)
15114 {
15115 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15116 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15117 }
15118 }
15119
15120 data.outfile_check_timer = outfile_check_timer;
15121
15122 /**
15123 * main loop
15124 */
15125
15126 char **induction_dictionaries = NULL;
15127
15128 int induction_dictionaries_cnt = 0;
15129
15130 hcstat_table_t *root_table_buf = NULL;
15131 hcstat_table_t *markov_table_buf = NULL;
15132
15133 uint initial_restore_done = 0;
15134
15135 data.maskcnt = maskcnt;
15136
15137 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15138 {
15139 if (data.devices_status == STATUS_CRACKED) break;
15140
15141 data.devices_status = STATUS_INIT;
15142
15143 if (maskpos > rd->maskpos)
15144 {
15145 rd->dictpos = 0;
15146 }
15147
15148 rd->maskpos = maskpos;
15149 data.maskpos = maskpos;
15150
15151 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15152 {
15153 char *mask = masks[maskpos];
15154
15155 if (mask_from_file == 1)
15156 {
15157 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15158
15159 char *str_ptr;
15160 uint str_pos;
15161
15162 uint mask_offset = 0;
15163
15164 uint separator_cnt;
15165
15166 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15167 {
15168 str_ptr = strstr (mask + mask_offset, ",");
15169
15170 if (str_ptr == NULL) break;
15171
15172 str_pos = str_ptr - mask;
15173
15174 // escaped separator, i.e. "\,"
15175
15176 if (str_pos > 0)
15177 {
15178 if (mask[str_pos - 1] == '\\')
15179 {
15180 separator_cnt --;
15181
15182 mask_offset = str_pos + 1;
15183
15184 continue;
15185 }
15186 }
15187
15188 // reset the offset
15189
15190 mask_offset = 0;
15191
15192 mask[str_pos] = '\0';
15193
15194 switch (separator_cnt)
15195 {
15196 case 0:
15197 mp_reset_usr (mp_usr, 0);
15198
15199 custom_charset_1 = mask;
15200 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15201 break;
15202
15203 case 1:
15204 mp_reset_usr (mp_usr, 1);
15205
15206 custom_charset_2 = mask;
15207 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15208 break;
15209
15210 case 2:
15211 mp_reset_usr (mp_usr, 2);
15212
15213 custom_charset_3 = mask;
15214 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15215 break;
15216
15217 case 3:
15218 mp_reset_usr (mp_usr, 3);
15219
15220 custom_charset_4 = mask;
15221 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15222 break;
15223 }
15224
15225 mask = mask + str_pos + 1;
15226 }
15227 }
15228
15229 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15230 {
15231 if (maskpos > 0)
15232 {
15233 local_free (css_buf);
15234 local_free (data.root_css_buf);
15235 local_free (data.markov_css_buf);
15236
15237 local_free (masks[maskpos - 1]);
15238 }
15239
15240 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15241
15242 data.mask = mask;
15243 data.css_cnt = css_cnt;
15244 data.css_buf = css_buf;
15245
15246 uint uniq_tbls[SP_PW_MAX][CHARSIZ];
15247
15248 memset (uniq_tbls, 0, sizeof (uniq_tbls));
15249
15250 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15251
15252 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15253 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15254
15255 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15256
15257 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15258
15259 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15260 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15261
15262 data.root_css_buf = root_css_buf;
15263 data.markov_css_buf = markov_css_buf;
15264
15265 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15266
15267 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15268
15269 local_free (root_table_buf);
15270 local_free (markov_table_buf);
15271
15272 // args
15273
15274 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15275 {
15276 hc_device_param_t *device_param = &data.devices_param[device_id];
15277
15278 device_param->kernel_params_mp[0] = &device_param->d_combs;
15279 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15280 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15281
15282 device_param->kernel_params_mp_buf64[3] = 0;
15283 device_param->kernel_params_mp_buf32[4] = css_cnt;
15284 device_param->kernel_params_mp_buf32[5] = 0;
15285 device_param->kernel_params_mp_buf32[6] = 0;
15286 device_param->kernel_params_mp_buf32[7] = 0;
15287
15288 if (attack_mode == ATTACK_MODE_HYBRID1)
15289 {
15290 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15291 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15292 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15293 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15294 }
15295 else if (attack_mode == ATTACK_MODE_HYBRID2)
15296 {
15297 device_param->kernel_params_mp_buf32[5] = 0;
15298 device_param->kernel_params_mp_buf32[6] = 0;
15299 device_param->kernel_params_mp_buf32[7] = 0;
15300 }
15301
15302 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp[i]);
15303 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp[i]);
15304 for (uint i = 4; i < 8; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp[i]);
15305
15306 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);
15307 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);
15308 }
15309 }
15310 else if (attack_mode == ATTACK_MODE_BF)
15311 {
15312 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15313
15314 if (increment)
15315 {
15316 for (uint i = 0; i < dictcnt; i++)
15317 {
15318 local_free (dictfiles[i]);
15319 }
15320
15321 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15322 {
15323 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15324
15325 if (l1_filename == NULL) break;
15326
15327 dictcnt++;
15328
15329 dictfiles[dictcnt - 1] = l1_filename;
15330 }
15331 }
15332 else
15333 {
15334 dictcnt++;
15335
15336 dictfiles[dictcnt - 1] = mask;
15337 }
15338
15339 if (dictcnt == 0)
15340 {
15341 log_error ("ERROR: Mask is too small");
15342
15343 return (-1);
15344 }
15345 }
15346 }
15347
15348 free (induction_dictionaries);
15349
15350 // induction_dictionaries_cnt = 0; // implied
15351
15352 if (attack_mode != ATTACK_MODE_BF)
15353 {
15354 if (keyspace == 0)
15355 {
15356 induction_dictionaries = scan_directory (induction_directory);
15357
15358 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15359 }
15360 }
15361
15362 if (induction_dictionaries_cnt)
15363 {
15364 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15365 }
15366
15367 /**
15368 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15369 */
15370 if (keyspace == 1)
15371 {
15372 if ((maskcnt > 1) || (dictcnt > 1))
15373 {
15374 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15375
15376 return (-1);
15377 }
15378 }
15379
15380 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15381 {
15382 char *subid = logfile_generate_subid ();
15383
15384 data.subid = subid;
15385
15386 logfile_sub_msg ("START");
15387
15388 data.devices_status = STATUS_INIT;
15389
15390 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (uint64_t));
15391 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (uint64_t));
15392 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (uint64_t));
15393
15394 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15395
15396 data.cpt_pos = 0;
15397
15398 data.cpt_start = time (NULL);
15399
15400 data.cpt_total = 0;
15401
15402 if (data.restore == 0)
15403 {
15404 rd->words_cur = skip;
15405
15406 skip = 0;
15407
15408 data.skip = 0;
15409 }
15410
15411 data.ms_paused = 0;
15412
15413 data.words_cur = rd->words_cur;
15414
15415 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15416 {
15417 hc_device_param_t *device_param = &data.devices_param[device_id];
15418
15419 device_param->speed_pos = 0;
15420
15421 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (uint64_t));
15422 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15423 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15424
15425 device_param->kernel_power = device_param->kernel_power_user;
15426 device_param->kernel_blocks = device_param->kernel_blocks_user;
15427
15428 device_param->outerloop_pos = 0;
15429 device_param->outerloop_left = 0;
15430 device_param->innerloop_pos = 0;
15431 device_param->innerloop_left = 0;
15432
15433 // some more resets:
15434
15435 memset (device_param->pw_caches, 0, 64 * sizeof (pw_cache_t));
15436
15437 memset (device_param->pws_buf, 0, device_param->size_pws);
15438
15439 device_param->pw_cnt = 0;
15440 device_param->pws_cnt = 0;
15441
15442 device_param->words_off = 0;
15443 device_param->words_done = 0;
15444 }
15445
15446 data.kernel_blocks_div = 0;
15447
15448 // figure out some workload
15449
15450 if (attack_mode == ATTACK_MODE_STRAIGHT)
15451 {
15452 if (data.wordlist_mode == WL_MODE_FILE)
15453 {
15454 char *dictfile = NULL;
15455
15456 if (induction_dictionaries_cnt)
15457 {
15458 dictfile = induction_dictionaries[0];
15459 }
15460 else
15461 {
15462 dictfile = dictfiles[dictpos];
15463 }
15464
15465 data.dictfile = dictfile;
15466
15467 logfile_sub_string (dictfile);
15468
15469 for (uint i = 0; i < rp_files_cnt; i++)
15470 {
15471 logfile_sub_var_string ("rulefile", rp_files[i]);
15472 }
15473
15474 FILE *fd2 = fopen (dictfile, "rb");
15475
15476 if (fd2 == NULL)
15477 {
15478 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15479
15480 return (-1);
15481 }
15482
15483 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15484
15485 fclose (fd2);
15486
15487 if (data.words_cnt == 0)
15488 {
15489 if (data.devices_status == STATUS_CRACKED) break;
15490 if (data.devices_status == STATUS_ABORTED) break;
15491
15492 dictpos++;
15493
15494 continue;
15495 }
15496 }
15497 }
15498 else if (attack_mode == ATTACK_MODE_COMBI)
15499 {
15500 char *dictfile = data.dictfile;
15501 char *dictfile2 = data.dictfile2;
15502
15503 logfile_sub_string (dictfile);
15504 logfile_sub_string (dictfile2);
15505
15506 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
15507 {
15508 FILE *fd2 = fopen (dictfile, "rb");
15509
15510 if (fd2 == NULL)
15511 {
15512 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15513
15514 return (-1);
15515 }
15516
15517 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15518
15519 fclose (fd2);
15520 }
15521 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
15522 {
15523 FILE *fd2 = fopen (dictfile2, "rb");
15524
15525 if (fd2 == NULL)
15526 {
15527 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15528
15529 return (-1);
15530 }
15531
15532 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
15533
15534 fclose (fd2);
15535 }
15536
15537 if (data.words_cnt == 0)
15538 {
15539 if (data.devices_status == STATUS_CRACKED) break;
15540 if (data.devices_status == STATUS_ABORTED) break;
15541
15542 dictpos++;
15543
15544 continue;
15545 }
15546 }
15547 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15548 {
15549 char *dictfile = NULL;
15550
15551 if (induction_dictionaries_cnt)
15552 {
15553 dictfile = induction_dictionaries[0];
15554 }
15555 else
15556 {
15557 dictfile = dictfiles[dictpos];
15558 }
15559
15560 data.dictfile = dictfile;
15561
15562 char *mask = data.mask;
15563
15564 logfile_sub_string (dictfile);
15565 logfile_sub_string (mask);
15566
15567 FILE *fd2 = fopen (dictfile, "rb");
15568
15569 if (fd2 == NULL)
15570 {
15571 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15572
15573 return (-1);
15574 }
15575
15576 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15577
15578 fclose (fd2);
15579
15580 if (data.words_cnt == 0)
15581 {
15582 if (data.devices_status == STATUS_CRACKED) break;
15583 if (data.devices_status == STATUS_ABORTED) break;
15584
15585 dictpos++;
15586
15587 continue;
15588 }
15589 }
15590 else if (attack_mode == ATTACK_MODE_BF)
15591 {
15592 local_free (css_buf);
15593 local_free (data.root_css_buf);
15594 local_free (data.markov_css_buf);
15595
15596 char *mask = dictfiles[dictpos];
15597
15598 logfile_sub_string (mask);
15599
15600 // base
15601
15602 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15603
15604 if (opts_type & OPTS_TYPE_PT_UNICODE)
15605 {
15606 uint css_cnt_unicode = css_cnt * 2;
15607
15608 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
15609
15610 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
15611 {
15612 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
15613
15614 css_buf_unicode[j + 1].cs_buf[0] = 0;
15615 css_buf_unicode[j + 1].cs_len = 1;
15616 }
15617
15618 free (css_buf);
15619
15620 css_buf = css_buf_unicode;
15621 css_cnt = css_cnt_unicode;
15622 }
15623
15624 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
15625
15626 uint mask_min = pw_min;
15627 uint mask_max = pw_max;
15628
15629 if (opts_type & OPTS_TYPE_PT_UNICODE)
15630 {
15631 mask_min *= 2;
15632 mask_max *= 2;
15633 }
15634
15635 if ((css_cnt < mask_min) || (css_cnt > mask_max))
15636 {
15637 if (css_cnt < mask_min)
15638 {
15639 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
15640 }
15641
15642 if (css_cnt > mask_max)
15643 {
15644 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
15645 }
15646
15647 // skip to next mask
15648
15649 dictpos++;
15650
15651 rd->dictpos = dictpos;
15652
15653 logfile_sub_msg ("STOP");
15654
15655 continue;
15656 }
15657
15658 uint save_css_cnt = css_cnt;
15659
15660 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15661 {
15662 if (opti_type & OPTI_TYPE_APPENDED_SALT)
15663 {
15664 uint salt_len = (uint) data.salts_buf[0].salt_len;
15665 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
15666
15667 uint css_cnt_salt = css_cnt + salt_len;
15668
15669 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
15670
15671 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
15672
15673 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
15674 {
15675 css_buf_salt[j].cs_buf[0] = salt_buf[i];
15676 css_buf_salt[j].cs_len = 1;
15677 }
15678
15679 free (css_buf);
15680
15681 css_buf = css_buf_salt;
15682 css_cnt = css_cnt_salt;
15683 }
15684 }
15685
15686 data.mask = mask;
15687 data.css_cnt = css_cnt;
15688 data.css_buf = css_buf;
15689
15690 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
15691
15692 uint uniq_tbls[SP_PW_MAX][CHARSIZ];
15693
15694 memset (uniq_tbls, 0, sizeof (uniq_tbls));
15695
15696 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15697
15698 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15699 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15700
15701 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15702
15703 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15704
15705 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15706 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15707
15708 data.root_css_buf = root_css_buf;
15709 data.markov_css_buf = markov_css_buf;
15710
15711 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15712
15713 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15714
15715 local_free (root_table_buf);
15716 local_free (markov_table_buf);
15717
15718 // copy + args
15719
15720 uint css_cnt_l = css_cnt;
15721 uint css_cnt_r;
15722
15723 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15724 {
15725 if (save_css_cnt < 6)
15726 {
15727 css_cnt_r = 1;
15728 }
15729 else if (save_css_cnt == 6)
15730 {
15731 css_cnt_r = 2;
15732 }
15733 else
15734 {
15735 if (opts_type & OPTS_TYPE_PT_UNICODE)
15736 {
15737 if (save_css_cnt == 8 || save_css_cnt == 10)
15738 {
15739 css_cnt_r = 2;
15740 }
15741 else
15742 {
15743 css_cnt_r = 4;
15744 }
15745 }
15746 else
15747 {
15748 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
15749 {
15750 css_cnt_r = 3;
15751 }
15752 else
15753 {
15754 css_cnt_r = 4;
15755 }
15756 }
15757 }
15758 }
15759 else
15760 {
15761 css_cnt_r = 1;
15762
15763 /* unfinished code?
15764 int sum = css_buf[css_cnt_r - 1].cs_len;
15765
15766 for (uint i = 1; i < 4 && i < css_cnt; i++)
15767 {
15768 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
15769
15770 css_cnt_r++;
15771
15772 sum *= css_buf[css_cnt_r - 1].cs_len;
15773 }
15774 */
15775 }
15776
15777 css_cnt_l -= css_cnt_r;
15778
15779 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
15780
15781 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15782 {
15783 hc_device_param_t *device_param = &data.devices_param[device_id];
15784
15785 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
15786 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
15787 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
15788
15789 device_param->kernel_params_mp_l_buf64[3] = 0;
15790 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
15791 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
15792 device_param->kernel_params_mp_l_buf32[6] = 0;
15793 device_param->kernel_params_mp_l_buf32[7] = 0;
15794 device_param->kernel_params_mp_l_buf32[8] = 0;
15795
15796 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
15797 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
15798 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
15799 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
15800
15801 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
15802 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
15803 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
15804
15805 device_param->kernel_params_mp_r_buf64[3] = 0;
15806 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
15807 device_param->kernel_params_mp_r_buf32[5] = 0;
15808 device_param->kernel_params_mp_r_buf32[6] = 0;
15809 device_param->kernel_params_mp_r_buf32[7] = 0;
15810
15811 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]);
15812 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]);
15813 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]);
15814
15815 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]);
15816 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]);
15817 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]);
15818
15819 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);
15820 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);
15821 }
15822 }
15823
15824 uint64_t words_base = data.words_cnt;
15825
15826 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
15827 {
15828 if (data.kernel_rules_cnt)
15829 {
15830 words_base /= data.kernel_rules_cnt;
15831 }
15832 }
15833 else if (data.attack_kern == ATTACK_KERN_COMBI)
15834 {
15835 if (data.combs_cnt)
15836 {
15837 words_base /= data.combs_cnt;
15838 }
15839 }
15840 else if (data.attack_kern == ATTACK_KERN_BF)
15841 {
15842 if (data.bfs_cnt)
15843 {
15844 words_base /= data.bfs_cnt;
15845 }
15846 }
15847
15848 data.words_base = words_base;
15849
15850 if (keyspace == 1)
15851 {
15852 log_info ("%llu", (unsigned long long int) words_base);
15853
15854 return (0);
15855 }
15856
15857 if (data.words_cur > data.words_base)
15858 {
15859 log_error ("ERROR: restore value greater keyspace");
15860
15861 return (-1);
15862 }
15863
15864 if (data.words_cur)
15865 {
15866 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
15867 {
15868 for (uint i = 0; i < data.salts_cnt; i++)
15869 {
15870 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
15871 }
15872 }
15873 else if (data.attack_kern == ATTACK_KERN_COMBI)
15874 {
15875 for (uint i = 0; i < data.salts_cnt; i++)
15876 {
15877 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
15878 }
15879 }
15880 else if (data.attack_kern == ATTACK_KERN_BF)
15881 {
15882 for (uint i = 0; i < data.salts_cnt; i++)
15883 {
15884 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
15885 }
15886 }
15887 }
15888
15889 /*
15890 * Inform user about possible slow speeds
15891 */
15892
15893 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
15894 {
15895 if (data.words_base < kernel_blocks_all)
15896 {
15897 if (quiet == 0)
15898 {
15899 log_info ("");
15900 log_info ("ATTENTION!");
15901 log_info (" The wordlist or mask you are using is too small.");
15902 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
15903 log_info (" The cracking speed will drop.");
15904 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
15905 log_info ("");
15906 }
15907 }
15908 }
15909
15910 /*
15911 * Update loopback file
15912 */
15913
15914 if (loopback == 1)
15915 {
15916 time_t now;
15917
15918 time (&now);
15919
15920 uint random_num = get_random_num (0, 9999);
15921
15922 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
15923
15924 data.loopback_file = loopback_file;
15925 }
15926
15927 /*
15928 * Update dictionary statistic
15929 */
15930
15931 if (keyspace == 0)
15932 {
15933 dictstat_fp = fopen (dictstat, "wb");
15934
15935 if (dictstat_fp)
15936 {
15937 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
15938
15939 fclose (dictstat_fp);
15940 }
15941 }
15942
15943 data.devices_status = STATUS_RUNNING;
15944
15945 if (initial_restore_done == 0)
15946 {
15947 if (data.restore_disable == 0) cycle_restore ();
15948
15949 initial_restore_done = 1;
15950 }
15951
15952 hc_timer_set (&data.timer_running);
15953
15954 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
15955 {
15956 if ((quiet == 0) && (status == 0) && (benchmark == 0))
15957 {
15958 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
15959 if (quiet == 0) fflush (stdout);
15960 }
15961 }
15962 else if (wordlist_mode == WL_MODE_STDIN)
15963 {
15964 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
15965 if (data.quiet == 0) log_info ("");
15966 }
15967
15968 time_t runtime_start;
15969
15970 time (&runtime_start);
15971
15972 data.runtime_start = runtime_start;
15973
15974 /**
15975 * create cracker threads
15976 */
15977
15978 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (devices_cnt, sizeof (hc_thread_t));
15979
15980 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15981 {
15982 hc_device_param_t *device_param = &devices_param[device_id];
15983
15984 device_param->device_id = device_id;
15985
15986 if (wordlist_mode == WL_MODE_STDIN)
15987 {
15988 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
15989 }
15990 else
15991 {
15992 hc_thread_create (c_threads[device_id], thread_calc, device_param);
15993 }
15994 }
15995
15996 // wait for crack threads to exit
15997
15998 hc_thread_wait (devices_cnt, c_threads);
15999
16000 local_free (c_threads);
16001
16002 data.restore = 0;
16003
16004 // finalize task
16005
16006 logfile_sub_var_uint ("status-after-work", data.devices_status);
16007
16008 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16009
16010 if (data.devices_status == STATUS_CRACKED) break;
16011 if (data.devices_status == STATUS_ABORTED) break;
16012
16013 if (data.devices_status == STATUS_BYPASS)
16014 {
16015 data.devices_status = STATUS_RUNNING;
16016 }
16017
16018 if (induction_dictionaries_cnt)
16019 {
16020 unlink (induction_dictionaries[0]);
16021 }
16022
16023 free (induction_dictionaries);
16024
16025 if (attack_mode != ATTACK_MODE_BF)
16026 {
16027 induction_dictionaries = scan_directory (induction_directory);
16028
16029 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16030 }
16031
16032 if (benchmark == 0)
16033 {
16034 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16035 {
16036 if (quiet == 0) clear_prompt ();
16037
16038 if (quiet == 0) log_info ("");
16039
16040 if (status == 1)
16041 {
16042 status_display ();
16043 }
16044 else
16045 {
16046 if (quiet == 0) status_display ();
16047 }
16048
16049 if (quiet == 0) log_info ("");
16050 }
16051 }
16052
16053 if (attack_mode == ATTACK_MODE_BF)
16054 {
16055 dictpos++;
16056
16057 rd->dictpos = dictpos;
16058 }
16059 else
16060 {
16061 if (induction_dictionaries_cnt)
16062 {
16063 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16064 }
16065 else
16066 {
16067 dictpos++;
16068
16069 rd->dictpos = dictpos;
16070 }
16071 }
16072
16073 time_t runtime_stop;
16074
16075 time (&runtime_stop);
16076
16077 data.runtime_stop = runtime_stop;
16078
16079 logfile_sub_uint (runtime_start);
16080 logfile_sub_uint (runtime_stop);
16081
16082 logfile_sub_msg ("STOP");
16083
16084 global_free (subid);
16085 }
16086
16087 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16088
16089 if (data.devices_status == STATUS_CRACKED) break;
16090 if (data.devices_status == STATUS_ABORTED) break;
16091 if (data.devices_status == STATUS_QUIT) break;
16092
16093 if (data.devices_status == STATUS_BYPASS)
16094 {
16095 data.devices_status = STATUS_RUNNING;
16096 }
16097 }
16098
16099 // 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
16100
16101 if (attack_mode == ATTACK_MODE_STRAIGHT)
16102 {
16103 if (data.wordlist_mode == WL_MODE_FILE)
16104 {
16105 if (data.dictfile == NULL)
16106 {
16107 if (dictfiles != NULL)
16108 {
16109 data.dictfile = dictfiles[0];
16110
16111 hc_timer_set (&data.timer_running);
16112 }
16113 }
16114 }
16115 }
16116 // NOTE: combi is okay because it is already set beforehand
16117 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16118 {
16119 if (data.dictfile == NULL)
16120 {
16121 if (dictfiles != NULL)
16122 {
16123 hc_timer_set (&data.timer_running);
16124
16125 data.dictfile = dictfiles[0];
16126 }
16127 }
16128 }
16129 else if (attack_mode == ATTACK_MODE_BF)
16130 {
16131 if (data.mask == NULL)
16132 {
16133 hc_timer_set (&data.timer_running);
16134
16135 data.mask = masks[0];
16136 }
16137 }
16138
16139 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16140 {
16141 data.devices_status = STATUS_EXHAUSTED;
16142 }
16143
16144 // if cracked / aborted remove last induction dictionary
16145
16146 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16147 {
16148 struct stat induct_stat;
16149
16150 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16151 {
16152 unlink (induction_dictionaries[file_pos]);
16153 }
16154 }
16155
16156 // wait for non-interactive threads
16157
16158 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16159 {
16160 hc_thread_wait (1, &ni_threads[thread_idx]);
16161 }
16162
16163 local_free (ni_threads);
16164
16165 // wait for interactive threads
16166
16167 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16168 {
16169 hc_thread_wait (1, &i_thread);
16170 }
16171
16172 // we dont need restore file anymore
16173 if (data.restore_disable == 0)
16174 {
16175 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16176 {
16177 unlink (eff_restore_file);
16178 unlink (new_restore_file);
16179 }
16180 else
16181 {
16182 cycle_restore ();
16183 }
16184 }
16185
16186 // finally save left hashes
16187
16188 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16189 {
16190 save_hash ();
16191 }
16192
16193 /**
16194 * Clean up
16195 */
16196
16197 if (benchmark == 1)
16198 {
16199 status_benchmark ();
16200
16201 log_info ("");
16202 }
16203 else
16204 {
16205 if (quiet == 0) clear_prompt ();
16206
16207 if (quiet == 0) log_info ("");
16208
16209 if (status == 1)
16210 {
16211 status_display ();
16212 }
16213 else
16214 {
16215 if (quiet == 0) status_display ();
16216 }
16217
16218 if (quiet == 0) log_info ("");
16219 }
16220
16221 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16222 {
16223 hc_device_param_t *device_param = &data.devices_param[device_id];
16224
16225 local_free (device_param->result);
16226
16227 local_free (device_param->pw_caches);
16228
16229 local_free (device_param->combs_buf);
16230
16231 local_free (device_param->hooks_buf);
16232
16233 local_free (device_param->device_name);
16234
16235 local_free (device_param->device_name_chksum);
16236
16237 local_free (device_param->device_version);
16238
16239 local_free (device_param->driver_version);
16240
16241 if (device_param->pws_buf) myfree (device_param->pws_buf);
16242 if (device_param->d_pws_buf) hc_clReleaseMemObject (device_param->d_pws_buf);
16243 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (device_param->d_pws_amp_buf);
16244 if (device_param->d_rules) hc_clReleaseMemObject (device_param->d_rules);
16245 if (device_param->d_rules_c) hc_clReleaseMemObject (device_param->d_rules_c);
16246 if (device_param->d_combs) hc_clReleaseMemObject (device_param->d_combs);
16247 if (device_param->d_combs_c) hc_clReleaseMemObject (device_param->d_combs_c);
16248 if (device_param->d_bfs) hc_clReleaseMemObject (device_param->d_bfs);
16249 if (device_param->d_bfs_c) hc_clReleaseMemObject (device_param->d_bfs_c);
16250 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (device_param->d_bitmap_s1_a);
16251 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (device_param->d_bitmap_s1_b);
16252 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (device_param->d_bitmap_s1_c);
16253 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (device_param->d_bitmap_s1_d);
16254 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (device_param->d_bitmap_s2_a);
16255 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (device_param->d_bitmap_s2_b);
16256 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (device_param->d_bitmap_s2_c);
16257 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (device_param->d_bitmap_s2_d);
16258 if (device_param->d_plain_bufs) hc_clReleaseMemObject (device_param->d_plain_bufs);
16259 if (device_param->d_digests_buf) hc_clReleaseMemObject (device_param->d_digests_buf);
16260 if (device_param->d_digests_shown) hc_clReleaseMemObject (device_param->d_digests_shown);
16261 if (device_param->d_salt_bufs) hc_clReleaseMemObject (device_param->d_salt_bufs);
16262 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (device_param->d_esalt_bufs);
16263 if (device_param->d_tmps) hc_clReleaseMemObject (device_param->d_tmps);
16264 if (device_param->d_hooks) hc_clReleaseMemObject (device_param->d_hooks);
16265 if (device_param->d_result) hc_clReleaseMemObject (device_param->d_result);
16266 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (device_param->d_scryptV_buf);
16267 if (device_param->d_root_css_buf) hc_clReleaseMemObject (device_param->d_root_css_buf);
16268 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (device_param->d_markov_css_buf);
16269 if (device_param->d_tm_c) hc_clReleaseMemObject (device_param->d_tm_c);
16270
16271 if (device_param->kernel1) hc_clReleaseKernel (device_param->kernel1);
16272 if (device_param->kernel12) hc_clReleaseKernel (device_param->kernel12);
16273 if (device_param->kernel2) hc_clReleaseKernel (device_param->kernel2);
16274 if (device_param->kernel23) hc_clReleaseKernel (device_param->kernel23);
16275 if (device_param->kernel3) hc_clReleaseKernel (device_param->kernel3);
16276 if (device_param->kernel_mp) hc_clReleaseKernel (device_param->kernel_mp);
16277 if (device_param->kernel_mp_l) hc_clReleaseKernel (device_param->kernel_mp_l);
16278 if (device_param->kernel_mp_r) hc_clReleaseKernel (device_param->kernel_mp_r);
16279 if (device_param->kernel_tb) hc_clReleaseKernel (device_param->kernel_tb);
16280 if (device_param->kernel_tm) hc_clReleaseKernel (device_param->kernel_tm);
16281 if (device_param->kernel_amp) hc_clReleaseKernel (device_param->kernel_amp);
16282
16283 if (device_param->program) hc_clReleaseProgram (device_param->program);
16284 if (device_param->program_mp) hc_clReleaseProgram (device_param->program_mp);
16285 if (device_param->program_amp) hc_clReleaseProgram (device_param->program_amp);
16286 if (device_param->command_queue) hc_clReleaseCommandQueue (device_param->command_queue);
16287 if (device_param->context) hc_clReleaseContext (device_param->context);
16288 }
16289
16290 // reset default fan speed
16291
16292 if (gpu_temp_disable == 0)
16293 {
16294 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16295 {
16296 hc_thread_mutex_lock (mux_adl);
16297
16298 for (uint i = 0; i < data.devices_cnt; i++)
16299 {
16300 if (data.hm_device[i].fan_supported == 1)
16301 {
16302 int fanspeed = temp_retain_fanspeed_value[i];
16303
16304 if (fanspeed == -1) continue;
16305
16306 int rc = hm_set_fanspeed_with_device_id_amd (i, fanspeed);
16307
16308 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", i);
16309 }
16310 }
16311
16312 hc_thread_mutex_unlock (mux_adl);
16313 }
16314 }
16315
16316 // reset power tuning
16317
16318 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16319 {
16320 hc_thread_mutex_lock (mux_adl);
16321
16322 for (uint i = 0; i < data.devices_cnt; i++)
16323 {
16324 if (data.hm_device[i].od_version == 6)
16325 {
16326 // check powertune capabilities first, if not available then skip device
16327
16328 int powertune_supported = 0;
16329
16330 if ((hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll, data.hm_device[i].adapter_index.amd, &powertune_supported)) != ADL_OK)
16331 {
16332 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16333
16334 return (-1);
16335 }
16336
16337 if (powertune_supported != 0)
16338 {
16339 // powercontrol settings
16340
16341 if ((hc_ADL_Overdrive_PowerControl_Set (data.hm_dll, data.hm_device[i].adapter_index.amd, od_power_control_status[i])) != ADL_OK)
16342 {
16343 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16344
16345 return (-1);
16346 }
16347
16348 // clocks
16349
16350 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16351
16352 performance_state->iNumberOfPerformanceLevels = 2;
16353
16354 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[i].state.aLevels[0].iEngineClock;
16355 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[i].state.aLevels[1].iEngineClock;
16356 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[i].state.aLevels[0].iMemoryClock;
16357 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[i].state.aLevels[1].iMemoryClock;
16358
16359 if ((hc_ADL_Overdrive_State_Set (data.hm_dll, data.hm_device[i].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
16360 {
16361 log_info ("ERROR: Failed to restore ADL performance state");
16362
16363 return (-1);
16364 }
16365
16366 local_free (performance_state);
16367 }
16368 }
16369 }
16370
16371 hc_thread_mutex_unlock (mux_adl);
16372 }
16373
16374 if (gpu_temp_disable == 0)
16375 {
16376 if (vendor_id == VENDOR_ID_NV)
16377 {
16378 #ifdef LINUX
16379 hc_NVML_nvmlShutdown (data.hm_dll);
16380 #endif
16381
16382 #ifdef WIN
16383 NvAPI_Unload ();
16384 #endif
16385 }
16386
16387 if (vendor_id == VENDOR_ID_AMD)
16388 {
16389 hc_ADL_Main_Control_Destroy (data.hm_dll);
16390
16391 hm_close (data.hm_dll);
16392 }
16393
16394 #ifdef LINUX
16395 if (vendor_id == VENDOR_ID_NV)
16396 {
16397 hm_close (data.hm_dll);
16398 }
16399 #endif
16400 }
16401
16402 // free memory
16403
16404 local_free (masks);
16405
16406 local_free (dictstat_base);
16407
16408 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16409 {
16410 pot_t *pot_ptr = &pot[pot_pos];
16411
16412 hash_t *hash = &pot_ptr->hash;
16413
16414 local_free (hash->digest);
16415
16416 if (isSalted)
16417 {
16418 local_free (hash->salt);
16419 }
16420 }
16421
16422 local_free (pot);
16423
16424 local_free (all_kernel_rules_cnt);
16425 local_free (all_kernel_rules_buf);
16426
16427 local_free (wl_data->buf);
16428 local_free (wl_data);
16429
16430 local_free (bitmap_s1_a);
16431 local_free (bitmap_s1_b);
16432 local_free (bitmap_s1_c);
16433 local_free (bitmap_s1_d);
16434 local_free (bitmap_s2_a);
16435 local_free (bitmap_s2_b);
16436 local_free (bitmap_s2_c);
16437 local_free (bitmap_s2_d);
16438
16439 local_free (temp_retain_fanspeed_value);
16440 local_free (od_clock_mem_status);
16441 local_free (od_power_control_status);
16442
16443 global_free (devices_param);
16444
16445 global_free (kernel_rules_buf);
16446
16447 global_free (root_css_buf);
16448 global_free (markov_css_buf);
16449
16450 global_free (digests_buf);
16451 global_free (digests_shown);
16452 global_free (digests_shown_tmp);
16453
16454 global_free (salts_buf);
16455 global_free (salts_shown);
16456
16457 global_free (esalts_buf);
16458
16459 global_free (words_progress_done);
16460 global_free (words_progress_rejected);
16461 global_free (words_progress_restored);
16462
16463 if (pot_fp) fclose (pot_fp);
16464
16465 if (data.devices_status == STATUS_QUIT) break;
16466 }
16467
16468 // destroy others mutex
16469
16470 hc_thread_mutex_delete (mux_dispatcher);
16471 hc_thread_mutex_delete (mux_counter);
16472 hc_thread_mutex_delete (mux_display);
16473 hc_thread_mutex_delete (mux_adl);
16474
16475 // free memory
16476
16477 local_free (eff_restore_file);
16478 local_free (new_restore_file);
16479
16480 local_free (rd);
16481
16482 // loopback
16483
16484 local_free (loopback_file);
16485
16486 if (loopback == 1) unlink (loopback_file);
16487
16488 // induction directory
16489
16490 if (induction_dir == NULL)
16491 {
16492 if (attack_mode != ATTACK_MODE_BF)
16493 {
16494 if (rmdir (induction_directory) == -1)
16495 {
16496 if (errno == ENOENT)
16497 {
16498 // good, we can ignore
16499 }
16500 else if (errno == ENOTEMPTY)
16501 {
16502 // good, we can ignore
16503 }
16504 else
16505 {
16506 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
16507
16508 return (-1);
16509 }
16510 }
16511
16512 local_free (induction_directory);
16513 }
16514 }
16515
16516 // outfile-check directory
16517
16518 if (outfile_check_dir == NULL)
16519 {
16520 if (rmdir (outfile_check_directory) == -1)
16521 {
16522 if (errno == ENOENT)
16523 {
16524 // good, we can ignore
16525 }
16526 else if (errno == ENOTEMPTY)
16527 {
16528 // good, we can ignore
16529 }
16530 else
16531 {
16532 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
16533
16534 return (-1);
16535 }
16536 }
16537
16538 local_free (outfile_check_directory);
16539 }
16540
16541 time_t proc_stop;
16542
16543 time (&proc_stop);
16544
16545 logfile_top_uint (proc_start);
16546 logfile_top_uint (proc_stop);
16547
16548 logfile_top_msg ("STOP");
16549
16550 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
16551 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
16552
16553 if (data.devices_status == STATUS_ABORTED) return 2;
16554 if (data.devices_status == STATUS_QUIT) return 2;
16555 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
16556 if (data.devices_status == STATUS_EXHAUSTED) return 1;
16557 if (data.devices_status == STATUS_CRACKED) return 0;
16558
16559 return -1;
16560 }
Hashcat additions to support pwdhash